init

node_modules/css-declaration-sorter/dist/stable-sort.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+module.exports = function (items, comparator) {
+  comparator = comparator
+    ? comparator
+    : (a, b) => {
+      if (a < b) return -1;
+      if (a > b) return 1;
+      return 0;
+    };
+  let stabilizedItems = items.map((el, index) => [el, index]);
+  const stableComparator = (a, b) => {
+    let order = comparator(a[0], b[0]);
+    if (order != 0) return order;
+    return a[1] - b[1];
+  };
+  stabilizedItems.sort(stableComparator);
+  for (let i = 0; i < items.length; i++) {
+    items[i] = stabilizedItems[i][0];
+  }
+  return items;
+};

node_modules/css-declaration-sorter/license.md

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c)
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

node_modules/css-declaration-sorter/orders/alphabetical.mjs

@@ -0,0 +1,379 @@
+export const properties = [
+  "all",
+  "-webkit-line-clamp",
+  "accent-color",
+  "align-content",
+  "align-items",
+  "align-self",
+  "animation",
+  "animation-delay",
+  "animation-direction",
+  "animation-duration",
+  "animation-fill-mode",
+  "animation-iteration-count",
+  "animation-name",
+  "animation-play-state",
+  "animation-timing-function",
+  "appearance",
+  "ascent-override",
+  "aspect-ratio",
+  "backdrop-filter",
+  "backface-visibility",
+  "background",
+  "background-attachment",
+  "background-blend-mode",
+  "background-clip",
+  "background-color",
+  "background-image",
+  "background-origin",
+  "background-position",
+  "background-position-x",
+  "background-position-y",
+  "background-repeat",
+  "background-size",
+  "block-size",
+  "border",
+  "border-block",
+  "border-block-color",
+  "border-block-end",
+  "border-block-end-color",
+  "border-block-end-style",
+  "border-block-end-width",
+  "border-block-start",
+  "border-block-start-color",
+  "border-block-start-style",
+  "border-block-start-width",
+  "border-block-style",
+  "border-block-width",
+  "border-bottom",
+  "border-bottom-color",
+  "border-bottom-left-radius",
+  "border-bottom-right-radius",
+  "border-bottom-style",
+  "border-bottom-width",
+  "border-collapse",
+  "border-color",
+  "border-end-end-radius",
+  "border-end-start-radius",
+  "border-image",
+  "border-image-outset",
+  "border-image-repeat",
+  "border-image-slice",
+  "border-image-source",
+  "border-image-width",
+  "border-inline",
+  "border-inline-color",
+  "border-inline-end",
+  "border-inline-end-color",
+  "border-inline-end-style",
+  "border-inline-end-width",
+  "border-inline-start",
+  "border-inline-start-color",
+  "border-inline-start-style",
+  "border-inline-start-width",
+  "border-inline-style",
+  "border-inline-width",
+  "border-left",
+  "border-left-color",
+  "border-left-style",
+  "border-left-width",
+  "border-radius",
+  "border-right",
+  "border-right-color",
+  "border-right-style",
+  "border-right-width",
+  "border-spacing",
+  "border-start-end-radius",
+  "border-start-start-radius",
+  "border-style",
+  "border-top",
+  "border-top-color",
+  "border-top-left-radius",
+  "border-top-right-radius",
+  "border-top-style",
+  "border-top-width",
+  "border-width",
+  "bottom",
+  "box-decoration-break",
+  "box-shadow",
+  "box-sizing",
+  "break-after",
+  "break-before",
+  "break-inside",
+  "caption-side",
+  "caret-color",
+  "clear",
+  "clip-path",
+  "color",
+  "color-scheme",
+  "column-count",
+  "column-fill",
+  "column-gap",
+  "column-rule",
+  "column-rule-color",
+  "column-rule-style",
+  "column-rule-width",
+  "column-span",
+  "column-width",
+  "columns",
+  "contain",
+  "content",
+  "content-visibility",
+  "counter-increment",
+  "counter-reset",
+  "counter-set",
+  "cursor",
+  "descent-override",
+  "direction",
+  "display",
+  "empty-cells",
+  "filter",
+  "flex",
+  "flex-basis",
+  "flex-direction",
+  "flex-flow",
+  "flex-grow",
+  "flex-shrink",
+  "flex-wrap",
+  "float",
+  "font",
+  "font-display",
+  "font-family",
+  "font-kerning",
+  "font-language-override",
+  "font-optical-sizing",
+  "font-size",
+  "font-size-adjust",
+  "font-stretch",
+  "font-style",
+  "font-synthesis",
+  "font-variant",
+  "font-variant-alternates",
+  "font-variant-caps",
+  "font-variant-east-asian",
+  "font-variant-ligatures",
+  "font-variant-numeric",
+  "font-variant-position",
+  "font-variation-settings",
+  "font-weight",
+  "forced-color-adjust",
+  "gap",
+  "grid",
+  "grid-area",
+  "grid-auto-columns",
+  "grid-auto-flow",
+  "grid-auto-rows",
+  "grid-column",
+  "grid-column-end",
+  "grid-column-start",
+  "grid-row",
+  "grid-row-end",
+  "grid-row-start",
+  "grid-template",
+  "grid-template-areas",
+  "grid-template-columns",
+  "grid-template-rows",
+  "hanging-punctuation",
+  "height",
+  "hyphenate-character",
+  "hyphens",
+  "image-orientation",
+  "image-rendering",
+  "inline-size",
+  "inset",
+  "inset-block",
+  "inset-block-end",
+  "inset-block-start",
+  "inset-inline",
+  "inset-inline-end",
+  "inset-inline-start",
+  "isolation",
+  "justify-content",
+  "justify-items",
+  "justify-self",
+  "left",
+  "letter-spacing",
+  "line-break",
+  "line-gap-override",
+  "line-height",
+  "list-style",
+  "list-style-image",
+  "list-style-position",
+  "list-style-type",
+  "margin",
+  "margin-block",
+  "margin-block-end",
+  "margin-block-start",
+  "margin-bottom",
+  "margin-inline",
+  "margin-inline-end",
+  "margin-inline-start",
+  "margin-left",
+  "margin-right",
+  "margin-top",
+  "mask",
+  "mask-border",
+  "mask-border-outset",
+  "mask-border-repeat",
+  "mask-border-slice",
+  "mask-border-source",
+  "mask-border-width",
+  "mask-clip",
+  "mask-composite",
+  "mask-image",
+  "mask-mode",
+  "mask-origin",
+  "mask-position",
+  "mask-repeat",
+  "mask-size",
+  "mask-type",
+  "max-block-size",
+  "max-height",
+  "max-inline-size",
+  "max-width",
+  "min-block-size",
+  "min-height",
+  "min-inline-size",
+  "min-width",
+  "mix-blend-mode",
+  "object-fit",
+  "object-position",
+  "offset",
+  "offset-anchor",
+  "offset-distance",
+  "offset-path",
+  "offset-rotate",
+  "opacity",
+  "order",
+  "orphans",
+  "outline",
+  "outline-color",
+  "outline-offset",
+  "outline-style",
+  "outline-width",
+  "overflow",
+  "overflow-anchor",
+  "overflow-block",
+  "overflow-inline",
+  "overflow-wrap",
+  "overflow-x",
+  "overflow-y",
+  "overscroll-behavior",
+  "overscroll-behavior-block",
+  "overscroll-behavior-inline",
+  "overscroll-behavior-x",
+  "overscroll-behavior-y",
+  "padding",
+  "padding-block",
+  "padding-block-end",
+  "padding-block-start",
+  "padding-bottom",
+  "padding-inline",
+  "padding-inline-end",
+  "padding-inline-start",
+  "padding-left",
+  "padding-right",
+  "padding-top",
+  "page",
+  "page-break-after",
+  "page-break-before",
+  "page-break-inside",
+  "paint-order",
+  "perspective",
+  "perspective-origin",
+  "place-content",
+  "place-items",
+  "place-self",
+  "pointer-events",
+  "position",
+  "print-color-adjust",
+  "quotes",
+  "resize",
+  "right",
+  "rotate",
+  "row-gap",
+  "ruby-position",
+  "scale",
+  "scroll-behavior",
+  "scroll-margin",
+  "scroll-margin-block",
+  "scroll-margin-block-end",
+  "scroll-margin-block-start",
+  "scroll-margin-bottom",
+  "scroll-margin-inline",
+  "scroll-margin-inline-end",
+  "scroll-margin-inline-start",
+  "scroll-margin-left",
+  "scroll-margin-right",
+  "scroll-margin-top",
+  "scroll-padding",
+  "scroll-padding-block",
+  "scroll-padding-block-end",
+  "scroll-padding-block-start",
+  "scroll-padding-bottom",
+  "scroll-padding-inline",
+  "scroll-padding-inline-end",
+  "scroll-padding-inline-start",
+  "scroll-padding-left",
+  "scroll-padding-right",
+  "scroll-padding-top",
+  "scroll-snap-align",
+  "scroll-snap-stop",
+  "scroll-snap-type",
+  "scrollbar-color",
+  "scrollbar-gutter",
+  "scrollbar-width",
+  "shape-image-threshold",
+  "shape-margin",
+  "shape-outside",
+  "size-adjust",
+  "src",
+  "tab-size",
+  "table-layout",
+  "text-align",
+  "text-align-last",
+  "text-combine-upright",
+  "text-decoration",
+  "text-decoration-color",
+  "text-decoration-line",
+  "text-decoration-skip-ink",
+  "text-decoration-style",
+  "text-decoration-thickness",
+  "text-emphasis",
+  "text-emphasis-color",
+  "text-emphasis-position",
+  "text-emphasis-style",
+  "text-indent",
+  "text-justify",
+  "text-orientation",
+  "text-overflow",
+  "text-shadow",
+  "text-transform",
+  "text-underline-offset",
+  "text-underline-position",
+  "top",
+  "touch-action",
+  "transform",
+  "transform-box",
+  "transform-origin",
+  "transform-style",
+  "transition",
+  "transition-delay",
+  "transition-duration",
+  "transition-property",
+  "transition-timing-function",
+  "translate",
+  "unicode-bidi",
+  "unicode-range",
+  "user-select",
+  "vertical-align",
+  "visibility",
+  "white-space",
+  "widows",
+  "width",
+  "will-change",
+  "word-break",
+  "word-spacing",
+  "writing-mode",
+  "z-index"
+]

node_modules/css-declaration-sorter/orders/concentric-css.mjs

@@ -0,0 +1,383 @@
+export const properties = [
+  "all",
+  "display",
+  "position",
+  "top",
+  "right",
+  "bottom",
+  "left",
+  "offset",
+  "offset-anchor",
+  "offset-distance",
+  "offset-path",
+  "offset-rotate",
+  "grid",
+  "grid-template-rows",
+  "grid-template-columns",
+  "grid-template-areas",
+  "grid-auto-rows",
+  "grid-auto-columns",
+  "grid-auto-flow",
+  "column-gap",
+  "row-gap",
+  "grid-area",
+  "grid-row",
+  "grid-row-start",
+  "grid-row-end",
+  "grid-column",
+  "grid-column-start",
+  "grid-column-end",
+  "grid-template",
+  "flex",
+  "flex-grow",
+  "flex-shrink",
+  "flex-basis",
+  "flex-direction",
+  "flex-flow",
+  "flex-wrap",
+  "box-decoration-break",
+  "place-content",
+  "align-content",
+  "justify-content",
+  "place-items",
+  "align-items",
+  "justify-items",
+  "place-self",
+  "align-self",
+  "justify-self",
+  "vertical-align",
+  "order",
+  "float",
+  "clear",
+  "shape-margin",
+  "shape-outside",
+  "shape-image-threshold",
+  "orphans",
+  "gap",
+  "columns",
+  "column-fill",
+  "column-rule",
+  "column-rule-width",
+  "column-rule-style",
+  "column-rule-color",
+  "column-width",
+  "column-span",
+  "column-count",
+  "break-before",
+  "break-after",
+  "break-inside",
+  "page",
+  "page-break-before",
+  "page-break-after",
+  "page-break-inside",
+  "transform",
+  "transform-box",
+  "transform-origin",
+  "transform-style",
+  "translate",
+  "rotate",
+  "scale",
+
+  "perspective",
+  "perspective-origin",
+  "appearance",
+  "visibility",
+  "content-visibility",
+  "opacity",
+  "z-index",
+  "paint-order",
+  "mix-blend-mode",
+  "backface-visibility",
+  "backdrop-filter",
+  "clip-path",
+  "mask",
+  "mask-border",
+  "mask-border-outset",
+  "mask-border-repeat",
+  "mask-border-slice",
+  "mask-border-source",
+  "mask-border-width",
+  "mask-image",
+  "mask-mode",
+  "mask-position",
+  "mask-size",
+  "mask-repeat",
+  "mask-origin",
+  "mask-clip",
+  "mask-composite",
+  "mask-type",
+  "filter",
+  "animation",
+  "animation-duration",
+  "animation-timing-function",
+  "animation-delay",
+  "animation-iteration-count",
+  "animation-direction",
+  "animation-fill-mode",
+  "animation-play-state",
+  "animation-name",
+  "transition",
+  "transition-delay",
+  "transition-duration",
+  "transition-property",
+  "transition-timing-function",
+  "will-change",
+  "counter-increment",
+  "counter-reset",
+  "counter-set",
+  "cursor",
+
+  "box-sizing",
+  "contain",
+  "margin",
+  "margin-top",
+  "margin-right",
+  "margin-bottom",
+  "margin-left",
+  "margin-inline",
+  "margin-inline-start",
+  "margin-inline-end",
+  "margin-block",
+  "margin-block-start",
+  "margin-block-end",
+  "inset",
+  "inset-block",
+  "inset-block-end",
+  "inset-block-start",
+  "inset-inline",
+  "inset-inline-end",
+  "inset-inline-start",
+  "outline",
+  "outline-color",
+  "outline-style",
+  "outline-width",
+  "outline-offset",
+  "box-shadow",
+  "border",
+  "border-top",
+  "border-right",
+  "border-bottom",
+  "border-left",
+  "border-width",
+  "border-top-width",
+  "border-right-width",
+  "border-bottom-width",
+  "border-left-width",
+  "border-style",
+  "border-top-style",
+  "border-right-style",
+  "border-bottom-style",
+  "border-left-style",
+  "border-color",
+  "border-top-color",
+  "border-right-color",
+  "border-bottom-color",
+  "border-left-color",
+  "border-radius",
+  "border-top-right-radius",
+  "border-top-left-radius",
+  "border-bottom-right-radius",
+  "border-bottom-left-radius",
+  "border-inline",
+  "border-inline-width",
+  "border-inline-style",
+  "border-inline-color",
+  "border-inline-start",
+  "border-inline-start-width",
+  "border-inline-start-style",
+  "border-inline-start-color",
+  "border-inline-end",
+  "border-inline-end-width",
+  "border-inline-end-style",
+  "border-inline-end-color",
+  "border-block",
+  "border-block-width",
+  "border-block-style",
+  "border-block-color",
+  "border-block-start",
+  "border-block-start-width",
+  "border-block-start-style",
+  "border-block-start-color",
+  "border-block-end",
+  "border-block-end-width",
+  "border-block-end-style",
+  "border-block-end-color",
+  "border-image",
+  "border-image-source",
+  "border-image-slice",
+  "border-image-width",
+  "border-image-outset",
+  "border-image-repeat",
+  "border-collapse",
+  "border-spacing",
+  "border-start-start-radius",
+  "border-start-end-radius",
+  "border-end-start-radius",
+  "border-end-end-radius",
+  "background",
+  "background-image",
+  "background-position",
+  "background-size",
+  "background-repeat",
+  "background-origin",
+  "background-clip",
+  "background-attachment",
+  "background-color",
+  "background-blend-mode",
+  "background-position-x",
+  "background-position-y",
+  "isolation",
+  "padding",
+  "padding-top",
+  "padding-right",
+  "padding-bottom",
+  "padding-left",
+  "padding-inline",
+  "padding-inline-start",
+  "padding-inline-end",
+  "padding-block",
+  "padding-block-start",
+  "padding-block-end",
+  "image-orientation",
+  "image-rendering",
+
+  "aspect-ratio",
+  "width",
+  "min-width",
+  "max-width",
+  "height",
+  "min-height",
+  "max-height",
+  "-webkit-line-clamp",
+  "inline-size",
+  "min-inline-size",
+  "max-inline-size",
+  "block-size",
+  "min-block-size",
+  "max-block-size",
+  "table-layout",
+  "caption-side",
+  "empty-cells",
+  "overflow",
+  "overflow-anchor",
+  "overflow-block",
+  "overflow-inline",
+  "overflow-x",
+  "overflow-y",
+  "overscroll-behavior",
+  "overscroll-behavior-block",
+  "overscroll-behavior-inline",
+  "overscroll-behavior-x",
+  "overscroll-behavior-y",
+  "resize",
+  "object-fit",
+  "object-position",
+  "scroll-behavior",
+  "scroll-margin",
+  "scroll-margin-block",
+  "scroll-margin-block-end",
+  "scroll-margin-block-start",
+  "scroll-margin-bottom",
+  "scroll-margin-inline",
+  "scroll-margin-inline-end",
+  "scroll-margin-inline-start",
+  "scroll-margin-left",
+  "scroll-margin-right",
+  "scroll-margin-top",
+  "scroll-padding",
+  "scroll-padding-block",
+  "scroll-padding-block-end",
+  "scroll-padding-block-start",
+  "scroll-padding-bottom",
+  "scroll-padding-inline",
+  "scroll-padding-inline-end",
+  "scroll-padding-inline-start",
+  "scroll-padding-left",
+  "scroll-padding-right",
+  "scroll-padding-top",
+  "scroll-snap-align",
+  "scroll-snap-stop",
+  "scroll-snap-type",
+  "scrollbar-color",
+  "scrollbar-gutter",
+  "scrollbar-width",
+  "touch-action",
+  "pointer-events",
+
+  "content",
+  "quotes",
+  "hanging-punctuation",
+  "color",
+  "accent-color",
+  "print-color-adjust",
+  "forced-color-adjust",
+  "color-scheme",
+  "caret-color",
+  "font",
+  "font-style",
+  "font-variant",
+  "font-weight",
+  "font-stretch",
+  "font-size",
+  "size-adjust",
+  "line-height",
+  "src",
+  "font-family",
+  "font-display",
+  "font-kerning",
+  "font-language-override",
+  "font-optical-sizing",
+  "font-size-adjust",
+  "font-synthesis",
+  "font-variant-alternates",
+  "font-variant-caps",
+  "font-variant-east-asian",
+  "font-variant-ligatures",
+  "font-variant-numeric",
+  "font-variant-position",
+  "font-variation-settings",
+  "ascent-override",
+  "descent-override",
+  "line-gap-override",
+  "hyphens",
+  "hyphenate-character",
+  "letter-spacing",
+  "line-break",
+  "list-style",
+  "list-style-type",
+  "list-style-image",
+  "list-style-position",
+  "writing-mode",
+  "direction",
+  "unicode-bidi",
+  "unicode-range",
+  "user-select",
+  "ruby-position",
+  "text-combine-upright",
+  "text-align",
+  "text-align-last",
+  "text-decoration",
+  "text-decoration-line",
+  "text-decoration-style",
+  "text-decoration-color",
+  "text-decoration-thickness",
+  "text-decoration-skip-ink",
+  "text-emphasis",
+  "text-emphasis-style",
+  "text-emphasis-color",
+  "text-emphasis-position",
+  "text-indent",
+  "text-justify",
+  "text-underline-position",
+  "text-underline-offset",
+  "text-orientation",
+  "text-overflow",
+  "text-shadow",
+  "text-transform",
+  "white-space",
+  "word-break",
+  "word-spacing",
+  "overflow-wrap",
+  "tab-size",
+  "widows"
+]

node_modules/css-declaration-sorter/orders/smacss.mjs

@@ -0,0 +1,385 @@
+export const properties = [
+  "all",
+  "box-sizing",
+  "contain",
+  "display",
+  "appearance",
+  "visibility",
+  "content-visibility",
+  "z-index",
+  "paint-order",
+  "position",
+  "top",
+  "right",
+  "bottom",
+  "left",
+  "offset",
+  "offset-anchor",
+  "offset-distance",
+  "offset-path",
+  "offset-rotate",
+
+
+  "grid",
+  "grid-template-rows",
+  "grid-template-columns",
+  "grid-template-areas",
+  "grid-auto-rows",
+  "grid-auto-columns",
+  "grid-auto-flow",
+  "column-gap",
+  "row-gap",
+  "grid-area",
+  "grid-row",
+  "grid-row-start",
+  "grid-row-end",
+  "grid-column",
+  "grid-column-start",
+  "grid-column-end",
+  "grid-template",
+  "flex",
+  "flex-grow",
+  "flex-shrink",
+  "flex-basis",
+  "flex-direction",
+  "flex-flow",
+  "flex-wrap",
+  "box-decoration-break",
+  "place-content",
+  "place-items",
+  "place-self",
+  "align-content",
+  "align-items",
+  "align-self",
+  "justify-content",
+  "justify-items",
+  "justify-self",
+  "order",
+  "aspect-ratio",
+  "width",
+  "min-width",
+  "max-width",
+  "height",
+  "min-height",
+  "max-height",
+  "-webkit-line-clamp",
+  "inline-size",
+  "min-inline-size",
+  "max-inline-size",
+  "block-size",
+  "min-block-size",
+  "max-block-size",
+  "margin",
+  "margin-top",
+  "margin-right",
+  "margin-bottom",
+  "margin-left",
+  "margin-inline",
+  "margin-inline-start",
+  "margin-inline-end",
+  "margin-block",
+  "margin-block-start",
+  "margin-block-end",
+  "inset",
+  "inset-block",
+  "inset-block-end",
+  "inset-block-start",
+  "inset-inline",
+  "inset-inline-end",
+  "inset-inline-start",
+  "padding",
+  "padding-top",
+  "padding-right",
+  "padding-bottom",
+  "padding-left",
+  "padding-inline",
+  "padding-inline-start",
+  "padding-inline-end",
+  "padding-block",
+  "padding-block-start",
+  "padding-block-end",
+  "float",
+  "clear",
+  "overflow",
+  "overflow-anchor",
+  "overflow-block",
+  "overflow-inline",
+  "overflow-x",
+  "overflow-y",
+  "overscroll-behavior",
+  "overscroll-behavior-block",
+  "overscroll-behavior-inline",
+  "overscroll-behavior-x",
+  "overscroll-behavior-y",
+  "orphans",
+  "gap",
+  "columns",
+  "column-fill",
+  "column-rule",
+  "column-rule-color",
+  "column-rule-style",
+  "column-rule-width",
+  "column-span",
+  "column-count",
+  "column-width",
+  "object-fit",
+  "object-position",
+  "transform",
+  "transform-box",
+  "transform-origin",
+  "transform-style",
+  "translate",
+  "rotate",
+  "scale",
+
+  "border",
+  "border-top",
+  "border-right",
+  "border-bottom",
+  "border-left",
+  "border-width",
+  "border-top-width",
+  "border-right-width",
+  "border-bottom-width",
+  "border-left-width",
+  "border-style",
+  "border-top-style",
+  "border-right-style",
+  "border-bottom-style",
+  "border-left-style",
+  "border-radius",
+  "border-top-right-radius",
+  "border-top-left-radius",
+  "border-bottom-right-radius",
+  "border-bottom-left-radius",
+  "border-inline",
+  "border-inline-color",
+  "border-inline-style",
+  "border-inline-width",
+  "border-inline-start",
+  "border-inline-start-color",
+  "border-inline-start-style",
+  "border-inline-start-width",
+  "border-inline-end",
+  "border-inline-end-color",
+  "border-inline-end-style",
+  "border-inline-end-width",
+  "border-block",
+  "border-block-color",
+  "border-block-style",
+  "border-block-width",
+  "border-block-start",
+  "border-block-start-color",
+  "border-block-start-style",
+  "border-block-start-width",
+  "border-block-end",
+  "border-block-end-color",
+  "border-block-end-style",
+  "border-block-end-width",
+  "border-color",
+  "border-image",
+  "border-image-outset",
+  "border-image-repeat",
+  "border-image-slice",
+  "border-image-source",
+  "border-image-width",
+  "border-top-color",
+  "border-right-color",
+  "border-bottom-color",
+  "border-left-color",
+  "border-collapse",
+  "border-spacing",
+  "border-start-start-radius",
+  "border-start-end-radius",
+  "border-end-start-radius",
+  "border-end-end-radius",
+  "outline",
+  "outline-color",
+  "outline-style",
+  "outline-width",
+  "outline-offset",
+
+  "backdrop-filter",
+  "backface-visibility",
+  "background",
+  "background-image",
+  "background-position",
+  "background-size",
+  "background-repeat",
+  "background-origin",
+  "background-clip",
+  "background-attachment",
+  "background-color",
+  "background-blend-mode",
+  "background-position-x",
+  "background-position-y",
+  "box-shadow",
+  "isolation",
+
+  "content",
+  "quotes",
+  "hanging-punctuation",
+  "color",
+  "accent-color",
+  "print-color-adjust",
+  "forced-color-adjust",
+  "color-scheme",
+  "caret-color",
+  "font",
+  "font-style",
+  "font-variant",
+  "font-weight",
+  "src",
+  "font-stretch",
+  "font-size",
+  "size-adjust",
+  "line-height",
+  "font-family",
+  "font-display",
+  "font-kerning",
+  "font-language-override",
+  "font-optical-sizing",
+  "font-size-adjust",
+  "font-synthesis",
+  "font-variant-alternates",
+  "font-variant-caps",
+  "font-variant-east-asian",
+  "font-variant-ligatures",
+  "font-variant-numeric",
+  "font-variant-position",
+  "font-variation-settings",
+  "ascent-override",
+  "descent-override",
+  "line-gap-override",
+  "hyphens",
+  "hyphenate-character",
+  "letter-spacing",
+  "line-break",
+  "list-style",
+  "list-style-image",
+  "list-style-position",
+  "list-style-type",
+  "direction",
+  "text-align",
+  "text-align-last",
+  "text-decoration",
+  "text-decoration-line",
+  "text-decoration-style",
+  "text-decoration-color",
+  "text-decoration-thickness",
+  "text-decoration-skip-ink",
+  "text-emphasis",
+  "text-emphasis-style",
+  "text-emphasis-color",
+  "text-emphasis-position",
+  "text-indent",
+  "text-justify",
+  "text-underline-position",
+  "text-underline-offset",
+  "text-orientation",
+  "text-overflow",
+  "text-shadow",
+  "text-transform",
+  "vertical-align",
+  "white-space",
+  "word-break",
+  "word-spacing",
+  "overflow-wrap",
+
+  "animation",
+  "animation-duration",
+  "animation-timing-function",
+  "animation-delay",
+  "animation-iteration-count",
+  "animation-direction",
+  "animation-fill-mode",
+  "animation-play-state",
+  "animation-name",
+  "mix-blend-mode",
+  "break-before",
+  "break-after",
+  "break-inside",
+  "page",
+  "page-break-before",
+  "page-break-after",
+  "page-break-inside",
+  "caption-side",
+  "clip-path",
+  "counter-increment",
+  "counter-reset",
+  "counter-set",
+  "cursor",
+  "empty-cells",
+  "filter",
+  "image-orientation",
+  "image-rendering",
+  "mask",
+  "mask-border",
+  "mask-border-outset",
+  "mask-border-repeat",
+  "mask-border-slice",
+  "mask-border-source",
+  "mask-border-width",
+  "mask-clip",
+  "mask-composite",
+  "mask-image",
+  "mask-mode",
+  "mask-origin",
+  "mask-position",
+  "mask-repeat",
+  "mask-size",
+  "mask-type",
+  "opacity",
+  "perspective",
+  "perspective-origin",
+  "pointer-events",
+  "resize",
+  "scroll-behavior",
+  "scroll-margin",
+  "scroll-margin-block",
+  "scroll-margin-block-end",
+  "scroll-margin-block-start",
+  "scroll-margin-bottom",
+  "scroll-margin-inline",
+  "scroll-margin-inline-end",
+  "scroll-margin-inline-start",
+  "scroll-margin-left",
+  "scroll-margin-right",
+  "scroll-margin-top",
+  "scroll-padding",
+  "scroll-padding-block",
+  "scroll-padding-block-end",
+  "scroll-padding-block-start",
+  "scroll-padding-bottom",
+  "scroll-padding-inline",
+  "scroll-padding-inline-end",
+  "scroll-padding-inline-start",
+  "scroll-padding-left",
+  "scroll-padding-right",
+  "scroll-padding-top",
+  "scroll-snap-align",
+  "scroll-snap-stop",
+  "scroll-snap-type",
+  "scrollbar-color",
+  "scrollbar-gutter",
+  "scrollbar-width",
+  "shape-image-threshold",
+  "shape-margin",
+  "shape-outside",
+  "tab-size",
+  "table-layout",
+  "ruby-position",
+  "text-combine-upright",
+  "touch-action",
+  "transition",
+  "transition-delay",
+  "transition-duration",
+  "transition-property",
+  "transition-timing-function",
+  "will-change",
+  "unicode-bidi",
+  "unicode-range",
+  "user-select",
+  "widows",
+  "writing-mode"
+]

node_modules/css-declaration-sorter/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "css-declaration-sorter",
+  "version": "6.3.0",
+  "description": "Sorts CSS declarations fast and automatically in a certain order.",
+  "type": "module",
+  "main": "./dist/main.cjs",
+  "exports": {
+    "import": "./src/main.mjs",
+    "require": "./dist/main.cjs"
+  },
+  "types": "./src/main.d.ts",
+  "files": [
+    "src/main.mjs",
+    "src/main.d.ts",
+    "src/shorthand-data.mjs",
+    "orders",
+    "dist"
+  ],
+  "scripts": {
+    "build": "rollup -c",
+    "preversion": "npm test",
+    "test": "uvu src .+\\.test\\.mjs",
+    "test:ci": "npm test && npm run lint -- --max-warnings 0",
+    "lint": "eslint src/*.mjs",
+    "scrape": "node src/property-scraper.mjs",
+    "prepack": "npm run build"
+  },
+  "devDependencies": {
+    "@mdn/browser-compat-data": "^4.2.1",
+    "@rollup/plugin-dynamic-import-vars": "^1.4.2",
+    "@rollup/plugin-replace": "^4.0.0",
+    "eslint": "^8.12.0",
+    "postcss": "^8.4.12",
+    "rollup": "^2.70.1",
+    "uvu": "^0.5.3"
+  },
+  "peerDependencies": {
+    "postcss": "^8.0.9"
+  },
+  "engines": {
+    "node": "^10 || ^12 || >=14"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Siilwyn/css-declaration-sorter.git"
+  },
+  "author": "Selwyn <talk@selwyn.cc> (https://selwyn.cc/)",
+  "license": "ISC",
+  "keywords": [
+    "postcss",
+    "postcss-plugin",
+    "css",
+    "declaration",
+    "sorter",
+    "property",
+    "order"
+  ]
+}

node_modules/css-declaration-sorter/readme.md

@@ -0,0 +1,129 @@
+<img alt='CSS declaration sorter logo' src='https://raw.githubusercontent.com/Siilwyn/css-declaration-sorter/master/logo.svg?sanitize=true' height='260' align='right'>
+
+# CSS Declaration Sorter
+[![LGTM Grade][lgtm-badge]][lgtm]
+[![npm][npm-badge]][npm]
+
+A Node.js module and [PostCSS] plugin to sort CSS, SCSS or Less declarations based on their property names. Ensuring styling is organized, more consistent and in order... The goal of this package is to sort the source code of a project in the build process or to decrease the distributed CSS gzipped size.
+
+Check out [the Prettier plugin](https://github.com/Siilwyn/prettier-plugin-css-order) for usage with a variety of file formats.
+
+## Niceness
+- Up-to-date CSS properties fetched from the [MDN Compatibility Data](https://github.com/mdn/browser-compat-data/) project.
+- Choose your wanted order or provide your own.
+- Nested rules sorting support.
+- SCSS and Less support when combined with either [postcss-scss](https://github.com/postcss/postcss-scss) or [postcss-less](https://github.com/webschik/postcss-less).
+- Thought-out sorting orders out of the box, **approved by their authors**.
+
+## Alphabetical example
+Input:
+```css
+body {
+    display: block;
+    animation: none;
+    color: #C55;
+    border: 0;
+}
+```
+
+Output:
+```css
+body {
+    animation: none;
+    border: 0;
+    color: #C55;
+    display: block;
+}
+```
+
+## Built-in sorting orders
+- Alphabetical  
+`alphabetical`  
+*Default, order in a simple alphabetical manner from a - z.*
+
+- [SMACSS](http://smacss.com/book/formatting#grouping)  
+`smacss`  
+*Order from most important, flow affecting properties, to least important properties.*
+  1. Box
+  2. Border
+  3. Background
+  4. Text
+  5. Other
+
+- [Concentric CSS](https://github.com/brandon-rhodes/Concentric-CSS)  
+`concentric-css`  
+*Order properties applying outside the box model, moving inward to intrinsic changes.*
+  1. Positioning
+  2. Visibility
+  3. Box model
+  4. Dimensions
+  5. Text
+
+## Usage
+Following the PostCSS plugin guidelines, this package depends on PostCSS as a peer dependency:  
+`npm install postcss css-declaration-sorter --save-dev`
+
+### CLI
+This module does not include its own CLI but works with the official [PostCSS CLI](https://github.com/postcss/postcss-cli). To use the examples below, the `postcss-cli` package is a required dependency.
+
+Piping out result from file:  
+`postcss input.css --use css-declaration-sorter | cat`
+
+Sorting multiple files by overwriting:  
+`postcss *.css --use css-declaration-sorter --replace --no-map`
+
+Sorting all files in a directory with SCSS syntax using [postcss-scss](https://github.com/postcss/postcss-scss) by overwriting:  
+`postcss ./src/**/*.scss --syntax postcss-scss --use css-declaration-sorter --replace --no-map`
+
+Sorting all files in the directory with SCSS syntax and SMACSS order by overwriting, using `package.json` configuration:  
+```json
+"postcss": {
+  "syntax": "postcss-scss",
+  "map": false,
+  "plugins": {
+    "css-declaration-sorter": { "order": "smacss" }
+  }
+}
+```
+
+`postcss ./src/**/*.scss --replace --config package.json`
+
+### Vanilla JS
+```js
+import postcss from 'postcss';
+import { cssDeclarationSorter } from 'css-declaration-sorter';
+
+postcss([cssDeclarationSorter({ order: 'smacss' })])
+  .process('a { color: hyperblue; display: block; }', { from: undefined })
+  .then(result => console.log(
+    result.css === 'a { display: block; color: hyperblue; }'
+  ));
+```
+___
+
+**[View more usage examples](/examples) in combination with other tools.**  
+
+___
+
+## API
+### cssDeclarationSorter({ order, keepOverrides })
+
+#### order
+Type: `string` or `function`  
+Default: `alphabetical`  
+Options: `alphabetical`, `smacss`, `concentric-css`
+
+Provide the name of one of the built-in sort orders or a comparison function that is passed to ([`Array.sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)). This function receives two declaration names and is expected to return `-1`, `0` or `1` depending on the wanted order.
+
+#### keepOverrides
+Type: `Boolean`  
+Default: `false`  
+
+To prevent breaking legacy CSS where shorthand declarations override longhand declarations (also taking into account vendor prefixes) this option can enabled. For example `animation-name: some; animation: greeting;` will be kept in this order when `keepOverrides` is `true`.
+
+[PostCSS]: https://github.com/postcss/postcss
+
+[lgtm]: https://lgtm.com/projects/g/Siilwyn/css-declaration-sorter/
+[lgtm-badge]: https://tinyshields.dev/lgtm/grade/javascript/g/Siilwyn/css-declaration-sorter.svg
+[npm]: https://www.npmjs.com/package/css-declaration-sorter
+[npm-badge]: https://tinyshields.dev/npm/css-declaration-sorter.svg

node_modules/css-declaration-sorter/src/main.d.ts

@@ -0,0 +1,27 @@
+import type { PluginCreator } from 'postcss';
+
+declare const cssDeclarationSorter: PluginCreator<{
+  /**
+  Provide the name of one of the built-in sort orders or a comparison function that is passed to `Array.sort`.
+
+  @default 'alphabetical'
+  */
+  order?: SortOrder | SortFunction | undefined;
+
+  /**
+  To prevent breaking legacy CSS where shorthand declarations override longhand declarations. For example `animation-name: some; animation: greeting;` will be kept in this order.
+
+  @default false
+  */
+  keepOverrides?: boolean;
+}>;
+
+export = cssDeclarationSorter;
+
+type SortOrder = 'alphabetical' | 'concentric-css' | 'smacss';
+
+/**
+ * This function receives two declaration property names and is expected
+ * to return -1, 0 or 1 depending on the wanted order.
+ */
+type SortFunction = (propertyNameA: string, propertyNameB: string) => -1 | 0 | 1;

node_modules/css-declaration-sorter/src/main.mjs

@@ -0,0 +1,145 @@
+import { shorthandData } from './shorthand-data.mjs';
+
+const builtInOrders = [
+  'alphabetical',
+  'concentric-css',
+  'smacss',
+];
+
+export const cssDeclarationSorter = ({ order = 'alphabetical', keepOverrides = false } = {}) => ({
+  postcssPlugin: 'css-declaration-sorter',
+  OnceExit (css) {
+    let withKeepOverrides = comparator => comparator;
+    if (keepOverrides) {
+      withKeepOverrides = withOverridesComparator(shorthandData);
+    }
+
+    if (typeof order === 'function') {
+      return processCss({ css, comparator: withKeepOverrides(order) });
+    }
+
+    if (!builtInOrders.includes(order))
+      return Promise.reject(
+        Error([
+          `Invalid built-in order '${order}' provided.`,
+          `Available built-in orders are: ${builtInOrders}`,
+        ].join('\n'))
+      );
+
+    return import(`../orders/${order}.mjs`)
+      .then(({ properties }) => processCss({
+        css,
+        comparator: withKeepOverrides(orderComparator(properties)),
+      }));
+  },
+});
+
+cssDeclarationSorter.postcss = true;
+
+// Kept for backward compatibility
+export default cssDeclarationSorter;
+
+function processCss ({ css, comparator }) {
+  const comments = [];
+  const rulesCache = [];
+
+  css.walk(node => {
+    const nodes = node.nodes;
+    const type = node.type;
+
+    if (type === 'comment') {
+      // Don't do anything to root comments or the last newline comment
+      const isNewlineNode = node.raws.before && node.raws.before.includes('\n');
+      const lastNewlineNode = isNewlineNode && !node.next();
+      const onlyNode = !node.prev() && !node.next() || !node.parent;
+
+      if (lastNewlineNode || onlyNode || node.parent.type === 'root') {
+        return;
+      }
+
+      if (isNewlineNode) {
+        const pairedNode = node.next() || node.prev();
+        if (pairedNode) {
+          comments.unshift({
+            'comment': node,
+            'pairedNode': pairedNode,
+            'insertPosition': node.next() ? 'Before' : 'After',
+          });
+          node.remove();
+        }
+      } else {
+        const pairedNode = node.prev() || node.next();
+        if (pairedNode) {
+          comments.push({
+            'comment': node,
+            'pairedNode': pairedNode,
+            'insertPosition': 'After',
+          });
+          node.remove();
+        }
+      }
+      return;
+    }
+
+    // Add rule-like nodes to a cache so that we can remove all
+    // comment nodes before we start sorting.
+    const isRule = type === 'rule' || type === 'atrule';
+    if (isRule && nodes && nodes.length > 1) {
+      rulesCache.push(nodes);
+    }
+  });
+
+  // Perform a sort once all comment nodes are removed
+  rulesCache.forEach(nodes => {
+    sortCssDeclarations({ nodes, comparator });
+  });
+
+  // Add comments back to the nodes they are paired with
+  comments.forEach(node => {
+    const pairedNode = node.pairedNode;
+    node.comment.remove();
+    pairedNode.parent && pairedNode.parent['insert' + node.insertPosition](pairedNode, node.comment);
+  });
+}
+
+function sortCssDeclarations ({ nodes, comparator }) {
+  nodes.sort((a, b) => {
+    if (a.type === 'decl' && b.type === 'decl') {
+      return comparator(a.prop, b.prop);
+    } else {
+      return compareDifferentType(a, b);
+    }
+  });
+}
+
+function withOverridesComparator (shorthandData) {
+  return function (comparator) {
+    return function (a, b) {
+      a = removeVendorPrefix(a);
+      b = removeVendorPrefix(b);
+
+      if (shorthandData[a] && shorthandData[a].includes(b)) return 0;
+      if (shorthandData[b] && shorthandData[b].includes(a)) return 0;
+
+      return comparator(a, b);
+    };
+  };
+}
+
+function orderComparator (order) {
+  return function (a, b) {
+    return order.indexOf(a) - order.indexOf(b);
+  };
+}
+
+function compareDifferentType (a, b) {
+  if (b.type === 'atrule') {
+    return 0;
+  }
+
+  return a.type === 'decl' ? -1 : b.type === 'decl' ? 1 : 0;
+}
+
+function removeVendorPrefix (property) {
+  return property.replace(/^-\w+-/, '');
+}

node_modules/css-declaration-sorter/src/shorthand-data.mjs

@@ -0,0 +1,409 @@
+export const shorthandData = {
+  'animation': [
+    'animation-name',
+    'animation-duration',
+    'animation-timing-function',
+    'animation-delay',
+    'animation-iteration-count',
+    'animation-direction',
+    'animation-fill-mode',
+    'animation-play-state',
+  ],
+  'background': [
+    'background-image',
+    'background-size',
+    'background-position',
+    'background-repeat',
+    'background-origin',
+    'background-clip',
+    'background-attachment',
+    'background-color',
+  ],
+  'columns': [
+    'column-width',
+    'column-count',
+  ],
+  'column-rule': [
+    'column-rule-width',
+    'column-rule-style',
+    'column-rule-color',
+  ],
+  'flex': [
+    'flex-grow',
+    'flex-shrink',
+    'flex-basis',
+  ],
+  'flex-flow': [
+    'flex-direction',
+    'flex-wrap',
+  ],
+  'font': [
+    'font-style',
+    'font-variant',
+    'font-weight',
+    'font-stretch',
+    'font-size',
+    'font-family',
+    'line-height',
+  ],
+  'grid': [
+    'grid-template-rows',
+    'grid-template-columns',
+    'grid-template-areas',
+    'grid-auto-rows',
+    'grid-auto-columns',
+    'grid-auto-flow',
+    'column-gap',
+    'row-gap',
+  ],
+  'grid-area': [
+    'grid-row-start',
+    'grid-column-start',
+    'grid-row-end',
+    'grid-column-end',
+  ],
+  'grid-column': [
+    'grid-column-start',
+    'grid-column-end',
+  ],
+  'grid-row': [
+    'grid-row-start',
+    'grid-row-end',
+  ],
+  'grid-template': [
+    'grid-template-columns',
+    'grid-template-rows',
+    'grid-template-areas',
+  ],
+  'list-style': [
+    'list-style-type',
+    'list-style-position',
+    'list-style-image',
+  ],
+  'padding': [
+    'padding-block',
+    'padding-block-start',
+    'padding-block-end',
+    'padding-inline',
+    'padding-inline-start',
+    'padding-inline-end',
+    'padding-top',
+    'padding-right',
+    'padding-bottom',
+    'padding-left',
+  ],
+  'padding-block': [
+    'padding-block-start',
+    'padding-block-end',
+    'padding-top',
+    'padding-right',
+    'padding-bottom',
+    'padding-left',
+  ],
+  'padding-block-start': [
+    'padding-top',
+    'padding-right',
+    'padding-left',
+  ],
+  'padding-block-end': [
+    'padding-right',
+    'padding-bottom',
+    'padding-left',
+  ],
+  'padding-inline': [
+    'padding-inline-start',
+    'padding-inline-end',
+    'padding-top',
+    'padding-right',
+    'padding-bottom',
+    'padding-left',
+  ],
+  'padding-inline-start': [
+    'padding-top',
+    'padding-right',
+    'padding-left',
+  ],
+  'padding-inline-end': [
+    'padding-right',
+    'padding-bottom',
+    'padding-left',
+  ],
+  'margin': [
+    'margin-block',
+    'margin-block-start',
+    'margin-block-end',
+    'margin-inline',
+    'margin-inline-start',
+    'margin-inline-end',
+    'margin-top',
+    'margin-right',
+    'margin-bottom',
+    'margin-left',
+  ],
+  'margin-block': [
+    'margin-block-start',
+    'margin-block-end',
+    'margin-top',
+    'margin-right',
+    'margin-bottom',
+    'margin-left',
+  ],
+  'margin-inline': [
+    'margin-inline-start',
+    'margin-inline-end',
+    'margin-top',
+    'margin-right',
+    'margin-bottom',
+    'margin-left',
+  ],
+  'margin-inline-start': [
+    'margin-top',
+    'margin-right',
+    'margin-bottom',
+    'margin-left',
+  ],
+  'margin-inline-end': [
+    'margin-top',
+    'margin-right',
+    'margin-bottom',
+    'margin-left',
+  ],
+  'border': [
+    'border-top',
+    'border-right',
+    'border-bottom',
+    'border-left',
+    'border-width',
+    'border-style',
+    'border-color',
+    'border-top-width',
+    'border-right-width',
+    'border-bottom-width',
+    'border-left-width',
+    'border-top-style',
+    'border-right-style',
+    'border-bottom-style',
+    'border-left-style',
+    'border-top-color',
+    'border-right-color',
+    'border-bottom-color',
+    'border-left-color',
+    'border-block',
+    'border-block-start',
+    'border-block-end',
+    'border-block-width',
+    'border-block-style',
+    'border-block-color',
+    'border-inline',
+    'border-inline-start',
+    'border-inline-end',
+    'border-inline-width',
+    'border-inline-style',
+    'border-inline-color',
+  ],
+  'border-top': [
+    'border-width',
+    'border-style',
+    'border-color',
+    'border-top-width',
+    'border-top-style',
+    'border-top-color',
+  ],
+  'border-right': [
+    'border-width',
+    'border-style',
+    'border-color',
+    'border-right-width',
+    'border-right-style',
+    'border-right-color',
+  ],
+  'border-bottom': [
+    'border-width',
+    'border-style',
+    'border-color',
+    'border-bottom-width',
+    'border-bottom-style',
+    'border-bottom-color',
+  ],
+  'border-left': [
+    'border-width',
+    'border-style',
+    'border-color',
+    'border-left-width',
+    'border-left-style',
+    'border-left-color',
+  ],
+  'border-color': [
+    'border-top-color',
+    'border-bottom-color',
+    'border-left-color',
+    'border-right-color',
+  ],
+  'border-width': [
+    'border-top-width',
+    'border-bottom-width',
+    'border-left-width',
+    'border-right-width',
+  ],
+  'border-style': [
+    'border-top-style',
+    'border-bottom-style',
+    'border-left-style',
+    'border-right-style',
+  ],
+  'border-radius': [
+    'border-top-right-radius',
+    'border-top-left-radius',
+    'border-bottom-right-radius',
+    'border-bottom-left-radius',
+  ],
+  'border-block': [
+    'border-block-start',
+    'border-block-end',
+    'border-block-width',
+    'border-width',
+    'border-block-style',
+    'border-style',
+    'border-block-color',
+    'border-color',
+  ],
+  'border-block-start': [
+    'border-block-start-width',
+    'border-width',
+    'border-block-start-style',
+    'border-style',
+    'border-block-start-color',
+    'border-color',
+  ],
+  'border-block-end': [
+    'border-block-end-width',
+    'border-width',
+    'border-block-end-style',
+    'border-style',
+    'border-block-end-color',
+    'border-color',
+  ],
+  'border-inline': [
+    'border-inline-start',
+    'border-inline-end',
+    'border-inline-width',
+    'border-width',
+    'border-inline-style',
+    'border-style',
+    'border-inline-color',
+    'border-color',
+  ],
+  'border-inline-start': [
+    'border-inline-start-width',
+    'border-width',
+    'border-inline-start-style',
+    'border-style',
+    'border-inline-start-color',
+    'border-color',
+  ],
+  'border-inline-end': [
+    'border-inline-end-width',
+    'border-width',
+    'border-inline-end-style',
+    'border-style',
+    'border-inline-end-color',
+    'border-color',
+  ],
+  'border-image': [
+    'border-image-source',
+    'border-image-slice',
+    'border-image-width',
+    'border-image-outset',
+    'border-image-repeat',
+  ],
+  'mask': [
+    'mask-image',
+    'mask-mode',
+    'mask-position',
+    'mask-size',
+    'mask-repeat',
+    'mask-origin',
+    'mask-clip',
+    'mask-composite',
+  ],
+  'inline-size': [
+    'width',
+    'height',
+  ],
+  'block-size': [
+    'width',
+    'height',
+  ],
+  'max-inline-size': [
+    'max-width',
+    'max-height',
+  ],
+  'max-block-size': [
+    'max-width',
+    'max-height',
+  ],
+  'inset': [
+    'inset-block',
+    'inset-block-start',
+    'inset-block-end',
+    'inset-inline',
+    'inset-inline-start',
+    'inset-inline-end',
+    'top',
+    'right',
+    'bottom',
+    'left',
+  ],
+  'inset-block': [
+    'inset-block-start',
+    'inset-block-end',
+    'top',
+    'right',
+    'bottom',
+    'left',
+  ],
+  'inset-inline': [
+    'inset-inline-start',
+    'inset-inline-end',
+    'top',
+    'right',
+    'bottom',
+    'left',
+  ],
+  'outline': [
+    'outline-color',
+    'outline-style',
+    'outline-width',
+  ],
+  'overflow': [
+    'overflow-x',
+    'overflow-y',
+  ],
+  'place-content': [
+    'align-content',
+    'justify-content',
+  ],
+  'place-items': [
+    'align-items',
+    'justify-items',
+  ],
+  'place-self': [
+    'align-self',
+    'justify-self',
+  ],
+  'text-decoration': [
+    'text-decoration-color',
+    'text-decoration-style',
+    'text-decoration-line',
+  ],
+  'transition': [
+    'transition-delay',
+    'transition-duration',
+    'transition-property',
+    'transition-timing-function',
+  ],
+  'text-emphasis': [
+    'text-emphasis-style',
+    'text-emphasis-color',
+  ],
+};

node_modules/css-loader/LICENSE

@@ -0,0 +1,20 @@
+Copyright JS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/css-loader/dist/CssSyntaxError.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+class CssSyntaxError extends Error {
+  constructor(error) {
+    super(error);
+    const {
+      reason,
+      line,
+      column,
+      file
+    } = error;
+    this.name = "CssSyntaxError"; // Based on https://github.com/postcss/postcss/blob/master/lib/css-syntax-error.es6#L132
+    // We don't need `plugin` and `file` properties.
+
+    this.message = `${this.name}\n\n`;
+
+    if (typeof line !== "undefined") {
+      this.message += `(${line}:${column}) `;
+    }
+
+    this.message += file ? `${file} ` : "<css input> ";
+    this.message += `${reason}`;
+    const code = error.showSourceCode();
+
+    if (code) {
+      this.message += `\n\n${code}\n`;
+    } // We don't need stack https://github.com/postcss/postcss/blob/master/docs/guidelines/runner.md#31-dont-show-js-stack-for-csssyntaxerror
+
+
+    this.stack = false;
+  }
+
+}
+
+exports.default = CssSyntaxError;

node_modules/css-loader/dist/Warning.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+class Warning extends Error {
+  constructor(warning) {
+    super(warning);
+    const {
+      text,
+      line,
+      column
+    } = warning;
+    this.name = "Warning"; // Based on https://github.com/postcss/postcss/blob/master/lib/warning.es6#L74
+    // We don't need `plugin` properties.
+
+    this.message = `${this.name}\n\n`;
+
+    if (typeof line !== "undefined") {
+      this.message += `(${line}:${column}) `;
+    }
+
+    this.message += `${text}`; // We don't need stack https://github.com/postcss/postcss/blob/master/docs/guidelines/runner.md#31-dont-show-js-stack-for-csssyntaxerror
+
+    this.stack = false;
+  }
+
+}
+
+exports.default = Warning;

node_modules/css-loader/dist/cjs.js

@@ -0,0 +1,6 @@
+"use strict";
+
+const loader = require("./index");
+
+module.exports = loader.default;
+module.exports.defaultGetLocalIdent = require("./utils").defaultGetLocalIdent;

node_modules/css-loader/dist/index.js

@@ -0,0 +1,186 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = loader;
+
+var _postcss = _interopRequireDefault(require("postcss"));
+
+var _package = _interopRequireDefault(require("postcss/package.json"));
+
+var _semver = require("semver");
+
+var _CssSyntaxError = _interopRequireDefault(require("./CssSyntaxError"));
+
+var _Warning = _interopRequireDefault(require("./Warning"));
+
+var _options = _interopRequireDefault(require("./options.json"));
+
+var _plugins = require("./plugins");
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/*
+  MIT License http://www.opensource.org/licenses/mit-license.php
+  Author Tobias Koppers @sokra
+*/
+async function loader(content, map, meta) {
+  const rawOptions = this.getOptions(_options.default);
+  const plugins = [];
+  const callback = this.async();
+  let options;
+
+  try {
+    options = (0, _utils.normalizeOptions)(rawOptions, this);
+  } catch (error) {
+    callback(error);
+    return;
+  }
+
+  const replacements = [];
+  const exports = [];
+
+  if ((0, _utils.shouldUseModulesPlugins)(options)) {
+    plugins.push(...(0, _utils.getModulesPlugins)(options, this));
+  }
+
+  const importPluginImports = [];
+  const importPluginApi = [];
+  let isSupportAbsoluteURL = false; // TODO enable by default in the next major release
+
+  if (this._compilation && this._compilation.options && this._compilation.options.experiments && this._compilation.options.experiments.buildHttp) {
+    isSupportAbsoluteURL = true;
+  }
+
+  const isSupportDataURL = options.esModule && Boolean("fsStartTime" in this._compiler);
+
+  if ((0, _utils.shouldUseImportPlugin)(options)) {
+    plugins.push((0, _plugins.importParser)({
+      isSupportAbsoluteURL: false,
+      isSupportDataURL: false,
+      isCSSStyleSheet: options.exportType === "css-style-sheet",
+      loaderContext: this,
+      imports: importPluginImports,
+      api: importPluginApi,
+      filter: options.import.filter,
+      urlHandler: url => (0, _utils.stringifyRequest)(this, (0, _utils.combineRequests)((0, _utils.getPreRequester)(this)(options.importLoaders), url))
+    }));
+  }
+
+  const urlPluginImports = [];
+
+  if ((0, _utils.shouldUseURLPlugin)(options)) {
+    const needToResolveURL = !options.esModule;
+    plugins.push((0, _plugins.urlParser)({
+      isSupportAbsoluteURL,
+      isSupportDataURL,
+      imports: urlPluginImports,
+      replacements,
+      context: this.context,
+      rootContext: this.rootContext,
+      filter: (0, _utils.getFilter)(options.url.filter, this.resourcePath),
+      resolver: needToResolveURL ? this.getResolve({
+        mainFiles: [],
+        extensions: []
+      }) : // eslint-disable-next-line no-undefined
+      undefined,
+      urlHandler: url => (0, _utils.stringifyRequest)(this, url) // Support data urls as input in new URL added in webpack@5.38.0
+
+    }));
+  }
+
+  const icssPluginImports = [];
+  const icssPluginApi = [];
+  const needToUseIcssPlugin = (0, _utils.shouldUseIcssPlugin)(options);
+
+  if (needToUseIcssPlugin) {
+    plugins.push((0, _plugins.icssParser)({
+      loaderContext: this,
+      imports: icssPluginImports,
+      api: icssPluginApi,
+      replacements,
+      exports,
+      urlHandler: url => (0, _utils.stringifyRequest)(this, (0, _utils.combineRequests)((0, _utils.getPreRequester)(this)(options.importLoaders), url))
+    }));
+  } // Reuse CSS AST (PostCSS AST e.g 'postcss-loader') to avoid reparsing
+
+
+  if (meta) {
+    const {
+      ast
+    } = meta;
+
+    if (ast && ast.type === "postcss" && (0, _semver.satisfies)(ast.version, `^${_package.default.version}`)) {
+      // eslint-disable-next-line no-param-reassign
+      content = ast.root;
+    }
+  }
+
+  const {
+    resourcePath
+  } = this;
+  let result;
+
+  try {
+    result = await (0, _postcss.default)(plugins).process(content, {
+      hideNothingWarning: true,
+      from: resourcePath,
+      to: resourcePath,
+      map: options.sourceMap ? {
+        prev: map ? (0, _utils.normalizeSourceMap)(map, resourcePath) : null,
+        inline: false,
+        annotation: false
+      } : false
+    });
+  } catch (error) {
+    if (error.file) {
+      this.addDependency(error.file);
+    }
+
+    callback(error.name === "CssSyntaxError" ? new _CssSyntaxError.default(error) : error);
+    return;
+  }
+
+  for (const warning of result.warnings()) {
+    this.emitWarning(new _Warning.default(warning));
+  }
+
+  const imports = [].concat(icssPluginImports.sort(_utils.sort)).concat(importPluginImports.sort(_utils.sort)).concat(urlPluginImports.sort(_utils.sort));
+  const api = [].concat(importPluginApi.sort(_utils.sort)).concat(icssPluginApi.sort(_utils.sort));
+
+  if (options.modules.exportOnlyLocals !== true) {
+    imports.unshift({
+      type: "api_import",
+      importName: "___CSS_LOADER_API_IMPORT___",
+      url: (0, _utils.stringifyRequest)(this, require.resolve("./runtime/api"))
+    });
+
+    if (options.sourceMap) {
+      imports.unshift({
+        importName: "___CSS_LOADER_API_SOURCEMAP_IMPORT___",
+        url: (0, _utils.stringifyRequest)(this, require.resolve("./runtime/sourceMaps"))
+      });
+    } else {
+      imports.unshift({
+        importName: "___CSS_LOADER_API_NO_SOURCEMAP_IMPORT___",
+        url: (0, _utils.stringifyRequest)(this, require.resolve("./runtime/noSourceMaps"))
+      });
+    }
+  }
+
+  const importCode = (0, _utils.getImportCode)(imports, options);
+  let moduleCode;
+
+  try {
+    moduleCode = (0, _utils.getModuleCode)(result, api, replacements, options, this);
+  } catch (error) {
+    callback(error);
+    return;
+  }
+
+  const exportCode = (0, _utils.getExportCode)(exports, replacements, needToUseIcssPlugin, options);
+  callback(null, `${importCode}${moduleCode}${exportCode}`);
+}

node_modules/css-loader/dist/options.json

@@ -0,0 +1,209 @@
+{
+  "title": "CSS Loader options",
+  "additionalProperties": false,
+  "properties": {
+    "url": {
+      "description": "Allows to enables/disables `url()`/`image-set()` functions handling.",
+      "link": "https://github.com/webpack-contrib/css-loader#url",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "filter": {
+              "instanceof": "Function"
+            }
+          },
+          "additionalProperties": false
+        }
+      ]
+    },
+    "import": {
+      "description": "Allows to enables/disables `@import` at-rules handling.",
+      "link": "https://github.com/webpack-contrib/css-loader#import",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "object",
+          "properties": {
+            "filter": {
+              "instanceof": "Function"
+            }
+          },
+          "additionalProperties": false
+        }
+      ]
+    },
+    "modules": {
+      "description": "Allows to enable/disable CSS Modules or ICSS and setup configuration.",
+      "link": "https://github.com/webpack-contrib/css-loader#modules",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "enum": ["local", "global", "pure", "icss"]
+        },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "auto": {
+              "description": "Allows auto enable CSS modules based on filename.",
+              "link": "https://github.com/webpack-contrib/css-loader#auto",
+              "anyOf": [
+                {
+                  "instanceof": "RegExp"
+                },
+                {
+                  "instanceof": "Function"
+                },
+                {
+                  "type": "boolean"
+                }
+              ]
+            },
+            "mode": {
+              "description": "Setup `mode` option.",
+              "link": "https://github.com/webpack-contrib/css-loader#mode",
+              "anyOf": [
+                {
+                  "enum": ["local", "global", "pure", "icss"]
+                },
+                {
+                  "instanceof": "Function"
+                }
+              ]
+            },
+            "localIdentName": {
+              "description": "Allows to configure the generated local ident name.",
+              "link": "https://github.com/webpack-contrib/css-loader#localidentname",
+              "type": "string",
+              "minLength": 1
+            },
+            "localIdentContext": {
+              "description": "Allows to redefine basic loader context for local ident name.",
+              "link": "https://github.com/webpack-contrib/css-loader#localidentcontext",
+              "type": "string",
+              "minLength": 1
+            },
+            "localIdentHashSalt": {
+              "description": "Allows to add custom hash to generate more unique classes.",
+              "link": "https://github.com/webpack-contrib/css-loader#localidenthashsalt",
+              "type": "string",
+              "minLength": 1
+            },
+            "localIdentHashFunction": {
+              "description": "Allows to specify hash function to generate classes.",
+              "link": "https://github.com/webpack-contrib/css-loader#localidenthashfunction",
+              "type": "string",
+              "minLength": 1
+            },
+            "localIdentHashDigest": {
+              "description": "Allows to specify hash digest to generate classes.",
+              "link": "https://github.com/webpack-contrib/css-loader#localidenthashdigest",
+              "type": "string",
+              "minLength": 1
+            },
+            "localIdentHashDigestLength": {
+              "description": "Allows to specify hash digest length to generate classes.",
+              "link": "https://github.com/webpack-contrib/css-loader#localidenthashdigestlength",
+              "type": "number"
+            },
+            "hashStrategy": {
+              "description": "Allows to specify should localName be used when computing the hash.",
+              "link": "https://github.com/webpack-contrib/css-loader#hashstrategy",
+              "enum": ["resource-path-and-local-name", "minimal-subset"]
+            },
+            "localIdentRegExp": {
+              "description": "Allows to specify custom RegExp for local ident name.",
+              "link": "https://github.com/webpack-contrib/css-loader#localidentregexp",
+              "anyOf": [
+                {
+                  "type": "string",
+                  "minLength": 1
+                },
+                {
+                  "instanceof": "RegExp"
+                }
+              ]
+            },
+            "getLocalIdent": {
+              "description": "Allows to specify a function to generate the classname.",
+              "link": "https://github.com/webpack-contrib/css-loader#getlocalident",
+              "instanceof": "Function"
+            },
+            "namedExport": {
+              "description": "Enables/disables ES modules named export for locals.",
+              "link": "https://github.com/webpack-contrib/css-loader#namedexport",
+              "type": "boolean"
+            },
+            "exportGlobals": {
+              "description": "Allows to export names from global class or id, so you can use that as local name.",
+              "link": "https://github.com/webpack-contrib/css-loader#exportglobals",
+              "type": "boolean"
+            },
+            "exportLocalsConvention": {
+              "description": "Style of exported classnames.",
+              "link": "https://github.com/webpack-contrib/css-loader#localsconvention",
+              "anyOf": [
+                {
+                  "enum": [
+                    "asIs",
+                    "camelCase",
+                    "camelCaseOnly",
+                    "dashes",
+                    "dashesOnly"
+                  ]
+                },
+                {
+                  "instanceof": "Function"
+                }
+              ]
+            },
+            "exportOnlyLocals": {
+              "description": "Export only locals.",
+              "link": "https://github.com/webpack-contrib/css-loader#exportonlylocals",
+              "type": "boolean"
+            }
+          }
+        }
+      ]
+    },
+    "sourceMap": {
+      "description": "Allows to enable/disable source maps.",
+      "link": "https://github.com/webpack-contrib/css-loader#sourcemap",
+      "type": "boolean"
+    },
+    "importLoaders": {
+      "description": "Allows enables/disables or setups number of loaders applied before CSS loader for `@import`/CSS Modules and ICSS imports.",
+      "link": "https://github.com/webpack-contrib/css-loader#importloaders",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "string"
+        },
+        {
+          "type": "integer"
+        }
+      ]
+    },
+    "esModule": {
+      "description": "Use the ES modules syntax.",
+      "link": "https://github.com/webpack-contrib/css-loader#esmodule",
+      "type": "boolean"
+    },
+    "exportType": {
+      "description": "Allows exporting styles as array with modules, string or constructable stylesheet (i.e. `CSSStyleSheet`).",
+      "link": "https://github.com/webpack-contrib/css-loader#exporttype",
+      "enum": ["array", "string", "css-style-sheet"]
+    }
+  },
+  "type": "object"
+}

node_modules/css-loader/dist/plugins/index.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "icssParser", {
+  enumerable: true,
+  get: function () {
+    return _postcssIcssParser.default;
+  }
+});
+Object.defineProperty(exports, "importParser", {
+  enumerable: true,
+  get: function () {
+    return _postcssImportParser.default;
+  }
+});
+Object.defineProperty(exports, "urlParser", {
+  enumerable: true,
+  get: function () {
+    return _postcssUrlParser.default;
+  }
+});
+
+var _postcssImportParser = _interopRequireDefault(require("./postcss-import-parser"));
+
+var _postcssIcssParser = _interopRequireDefault(require("./postcss-icss-parser"));
+
+var _postcssUrlParser = _interopRequireDefault(require("./postcss-url-parser"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

node_modules/css-loader/dist/plugins/postcss-icss-parser.js

@@ -0,0 +1,134 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _icssUtils = require("icss-utils");
+
+var _utils = require("../utils");
+
+const plugin = (options = {}) => {
+  return {
+    postcssPlugin: "postcss-icss-parser",
+
+    async OnceExit(root) {
+      const importReplacements = Object.create(null);
+      const {
+        icssImports,
+        icssExports
+      } = (0, _icssUtils.extractICSS)(root);
+      const imports = new Map();
+      const tasks = [];
+      const {
+        loaderContext
+      } = options;
+      const resolver = loaderContext.getResolve({
+        dependencyType: "icss",
+        conditionNames: ["style"],
+        extensions: ["..."],
+        mainFields: ["css", "style", "main", "..."],
+        mainFiles: ["index", "..."],
+        preferRelative: true
+      }); // eslint-disable-next-line guard-for-in
+
+      for (const url in icssImports) {
+        const tokens = icssImports[url];
+
+        if (Object.keys(tokens).length === 0) {
+          // eslint-disable-next-line no-continue
+          continue;
+        }
+
+        let normalizedUrl = url;
+        let prefix = "";
+        const queryParts = normalizedUrl.split("!");
+
+        if (queryParts.length > 1) {
+          normalizedUrl = queryParts.pop();
+          prefix = queryParts.join("!");
+        }
+
+        const request = (0, _utils.requestify)((0, _utils.normalizeUrl)(normalizedUrl, true), loaderContext.rootContext);
+
+        const doResolve = async () => {
+          const resolvedUrl = await (0, _utils.resolveRequests)(resolver, loaderContext.context, [...new Set([normalizedUrl, request])]);
+
+          if (!resolvedUrl) {
+            return;
+          } // eslint-disable-next-line consistent-return
+
+
+          return {
+            url: resolvedUrl,
+            prefix,
+            tokens
+          };
+        };
+
+        tasks.push(doResolve());
+      }
+
+      const results = await Promise.all(tasks);
+
+      for (let index = 0; index <= results.length - 1; index++) {
+        const item = results[index];
+
+        if (!item) {
+          // eslint-disable-next-line no-continue
+          continue;
+        }
+
+        const newUrl = item.prefix ? `${item.prefix}!${item.url}` : item.url;
+        const importKey = newUrl;
+        let importName = imports.get(importKey);
+
+        if (!importName) {
+          importName = `___CSS_LOADER_ICSS_IMPORT_${imports.size}___`;
+          imports.set(importKey, importName);
+          options.imports.push({
+            type: "icss_import",
+            importName,
+            url: options.urlHandler(newUrl),
+            icss: true,
+            index
+          });
+          options.api.push({
+            importName,
+            dedupe: true,
+            index
+          });
+        }
+
+        for (const [replacementIndex, token] of Object.keys(item.tokens).entries()) {
+          const replacementName = `___CSS_LOADER_ICSS_IMPORT_${index}_REPLACEMENT_${replacementIndex}___`;
+          const localName = item.tokens[token];
+          importReplacements[token] = replacementName;
+          options.replacements.push({
+            replacementName,
+            importName,
+            localName
+          });
+        }
+      }
+
+      if (Object.keys(importReplacements).length > 0) {
+        (0, _icssUtils.replaceSymbols)(root, importReplacements);
+      }
+
+      for (const name of Object.keys(icssExports)) {
+        const value = (0, _icssUtils.replaceValueSymbols)(icssExports[name], importReplacements);
+        options.exports.push({
+          name,
+          value
+        });
+      }
+    }
+
+  };
+};
+
+plugin.postcss = true;
+var _default = plugin;
+exports.default = _default;

node_modules/css-loader/dist/plugins/postcss-import-parser.js

@@ -0,0 +1,327 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+
+var _utils = require("../utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function parseNode(atRule, key, options) {
+  // Convert only top-level @import
+  if (atRule.parent.type !== "root") {
+    return;
+  }
+
+  if (atRule.raws && atRule.raws.afterName && atRule.raws.afterName.trim().length > 0) {
+    const lastCommentIndex = atRule.raws.afterName.lastIndexOf("/*");
+    const matched = atRule.raws.afterName.slice(lastCommentIndex).match(_utils.WEBPACK_IGNORE_COMMENT_REGEXP);
+
+    if (matched && matched[2] === "true") {
+      return;
+    }
+  }
+
+  const prevNode = atRule.prev();
+
+  if (prevNode && prevNode.type === "comment") {
+    const matched = prevNode.text.match(_utils.WEBPACK_IGNORE_COMMENT_REGEXP);
+
+    if (matched && matched[2] === "true") {
+      return;
+    }
+  } // Nodes do not exists - `@import url('http://') :root {}`
+
+
+  if (atRule.nodes) {
+    const error = new Error("It looks like you didn't end your @import statement correctly. Child nodes are attached to it.");
+    error.node = atRule;
+    throw error;
+  }
+
+  const rawParams = atRule.raws && atRule.raws[key] && typeof atRule.raws[key].raw !== "undefined" ? atRule.raws[key].raw : atRule[key];
+  const {
+    nodes: paramsNodes
+  } = (0, _postcssValueParser.default)(rawParams); // No nodes - `@import ;`
+  // Invalid type - `@import foo-bar;`
+
+  if (paramsNodes.length === 0 || paramsNodes[0].type !== "string" && paramsNodes[0].type !== "function") {
+    const error = new Error(`Unable to find uri in "${atRule.toString()}"`);
+    error.node = atRule;
+    throw error;
+  }
+
+  let isStringValue;
+  let url;
+
+  if (paramsNodes[0].type === "string") {
+    isStringValue = true;
+    url = paramsNodes[0].value;
+  } else {
+    // Invalid function - `@import nourl(test.css);`
+    if (paramsNodes[0].value.toLowerCase() !== "url") {
+      const error = new Error(`Unable to find uri in "${atRule.toString()}"`);
+      error.node = atRule;
+      throw error;
+    }
+
+    isStringValue = paramsNodes[0].nodes.length !== 0 && paramsNodes[0].nodes[0].type === "string";
+    url = isStringValue ? paramsNodes[0].nodes[0].value : _postcssValueParser.default.stringify(paramsNodes[0].nodes);
+  }
+
+  url = (0, _utils.normalizeUrl)(url, isStringValue);
+  const {
+    requestable,
+    needResolve
+  } = (0, _utils.isURLRequestable)(url, options);
+  let prefix;
+
+  if (requestable && needResolve) {
+    const queryParts = url.split("!");
+
+    if (queryParts.length > 1) {
+      url = queryParts.pop();
+      prefix = queryParts.join("!");
+    }
+  } // Empty url - `@import "";` or `@import url();`
+
+
+  if (url.trim().length === 0) {
+    const error = new Error(`Unable to find uri in "${atRule.toString()}"`);
+    error.node = atRule;
+    throw error;
+  }
+
+  const additionalNodes = paramsNodes.slice(1);
+  let supports;
+  let layer;
+  let media;
+
+  if (additionalNodes.length > 0) {
+    let nodes = [];
+
+    for (const node of additionalNodes) {
+      nodes.push(node);
+      const isLayerFunction = node.type === "function" && node.value.toLowerCase() === "layer";
+      const isLayerWord = node.type === "word" && node.value.toLowerCase() === "layer";
+
+      if (isLayerFunction || isLayerWord) {
+        if (isLayerFunction) {
+          nodes.splice(nodes.length - 1, 1, ...node.nodes);
+        } else {
+          nodes.splice(nodes.length - 1, 1, {
+            type: "string",
+            value: "",
+            unclosed: false
+          });
+        }
+
+        layer = _postcssValueParser.default.stringify(nodes).trim().toLowerCase();
+        nodes = [];
+      } else if (node.type === "function" && node.value.toLowerCase() === "supports") {
+        nodes.splice(nodes.length - 1, 1, ...node.nodes);
+        supports = _postcssValueParser.default.stringify(nodes).trim().toLowerCase();
+        nodes = [];
+      }
+    }
+
+    if (nodes.length > 0) {
+      media = _postcssValueParser.default.stringify(nodes).trim().toLowerCase();
+    }
+  } // eslint-disable-next-line consistent-return
+
+
+  return {
+    atRule,
+    prefix,
+    url,
+    layer,
+    supports,
+    media,
+    requestable,
+    needResolve
+  };
+}
+
+const plugin = (options = {}) => {
+  return {
+    postcssPlugin: "postcss-import-parser",
+
+    prepare(result) {
+      const parsedAtRules = [];
+      return {
+        AtRule: {
+          import(atRule) {
+            if (options.isCSSStyleSheet) {
+              options.loaderContext.emitError(new Error(atRule.error("'@import' rules are not allowed here and will not be processed").message));
+              return;
+            }
+
+            const {
+              isSupportDataURL,
+              isSupportAbsoluteURL
+            } = options;
+            let parsedAtRule;
+
+            try {
+              parsedAtRule = parseNode(atRule, "params", {
+                isSupportAbsoluteURL,
+                isSupportDataURL
+              });
+            } catch (error) {
+              result.warn(error.message, {
+                node: error.node
+              });
+            }
+
+            if (!parsedAtRule) {
+              return;
+            }
+
+            parsedAtRules.push(parsedAtRule);
+          }
+
+        },
+
+        async OnceExit() {
+          if (parsedAtRules.length === 0) {
+            return;
+          }
+
+          const {
+            loaderContext
+          } = options;
+          const resolver = loaderContext.getResolve({
+            dependencyType: "css",
+            conditionNames: ["style"],
+            mainFields: ["css", "style", "main", "..."],
+            mainFiles: ["index", "..."],
+            extensions: [".css", "..."],
+            preferRelative: true
+          });
+          const resolvedAtRules = await Promise.all(parsedAtRules.map(async parsedAtRule => {
+            const {
+              atRule,
+              requestable,
+              needResolve,
+              prefix,
+              url,
+              layer,
+              supports,
+              media
+            } = parsedAtRule;
+
+            if (options.filter) {
+              const needKeep = await options.filter(url, media, loaderContext.resourcePath, supports, layer);
+
+              if (!needKeep) {
+                return;
+              }
+            }
+
+            if (needResolve) {
+              const request = (0, _utils.requestify)(url, loaderContext.rootContext);
+              const resolvedUrl = await (0, _utils.resolveRequests)(resolver, loaderContext.context, [...new Set([request, url])]);
+
+              if (!resolvedUrl) {
+                return;
+              }
+
+              if (resolvedUrl === loaderContext.resourcePath) {
+                atRule.remove();
+                return;
+              }
+
+              atRule.remove(); // eslint-disable-next-line consistent-return
+
+              return {
+                url: resolvedUrl,
+                layer,
+                supports,
+                media,
+                prefix,
+                requestable
+              };
+            }
+
+            atRule.remove(); // eslint-disable-next-line consistent-return
+
+            return {
+              url,
+              layer,
+              supports,
+              media,
+              prefix,
+              requestable
+            };
+          }));
+          const urlToNameMap = new Map();
+
+          for (let index = 0; index <= resolvedAtRules.length - 1; index++) {
+            const resolvedAtRule = resolvedAtRules[index];
+
+            if (!resolvedAtRule) {
+              // eslint-disable-next-line no-continue
+              continue;
+            }
+
+            const {
+              url,
+              requestable,
+              layer,
+              supports,
+              media
+            } = resolvedAtRule;
+
+            if (!requestable) {
+              options.api.push({
+                url,
+                layer,
+                supports,
+                media,
+                index
+              }); // eslint-disable-next-line no-continue
+
+              continue;
+            }
+
+            const {
+              prefix
+            } = resolvedAtRule;
+            const newUrl = prefix ? `${prefix}!${url}` : url;
+            let importName = urlToNameMap.get(newUrl);
+
+            if (!importName) {
+              importName = `___CSS_LOADER_AT_RULE_IMPORT_${urlToNameMap.size}___`;
+              urlToNameMap.set(newUrl, importName);
+              options.imports.push({
+                type: "rule_import",
+                importName,
+                url: options.urlHandler(newUrl),
+                index
+              });
+            }
+
+            options.api.push({
+              importName,
+              layer,
+              supports,
+              media,
+              index
+            });
+          }
+        }
+
+      };
+    }
+
+  };
+};
+
+plugin.postcss = true;
+var _default = plugin;
+exports.default = _default;

node_modules/css-loader/dist/plugins/postcss-url-parser.js

@@ -0,0 +1,413 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _postcssValueParser = _interopRequireDefault(require("postcss-value-parser"));
+
+var _utils = require("../utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const isUrlFunc = /url/i;
+const isImageSetFunc = /^(?:-webkit-)?image-set$/i;
+const needParseDeclaration = /(?:url|(?:-webkit-)?image-set)\(/i;
+
+function getNodeFromUrlFunc(node) {
+  return node.nodes && node.nodes[0];
+}
+
+function getWebpackIgnoreCommentValue(index, nodes, inBetween) {
+  if (index === 0 && typeof inBetween !== "undefined") {
+    return inBetween;
+  }
+
+  let prevValueNode = nodes[index - 1];
+
+  if (!prevValueNode) {
+    // eslint-disable-next-line consistent-return
+    return;
+  }
+
+  if (prevValueNode.type === "space") {
+    if (!nodes[index - 2]) {
+      // eslint-disable-next-line consistent-return
+      return;
+    }
+
+    prevValueNode = nodes[index - 2];
+  }
+
+  if (prevValueNode.type !== "comment") {
+    // eslint-disable-next-line consistent-return
+    return;
+  }
+
+  const matched = prevValueNode.value.match(_utils.WEBPACK_IGNORE_COMMENT_REGEXP);
+  return matched && matched[2] === "true";
+}
+
+function shouldHandleURL(url, declaration, result, options) {
+  if (url.length === 0) {
+    result.warn(`Unable to find uri in '${declaration.toString()}'`, {
+      node: declaration
+    });
+    return {
+      requestable: false,
+      needResolve: false
+    };
+  }
+
+  return (0, _utils.isURLRequestable)(url, options);
+}
+
+function parseDeclaration(declaration, key, result, options) {
+  if (!needParseDeclaration.test(declaration[key])) {
+    return;
+  }
+
+  const parsed = (0, _postcssValueParser.default)(declaration.raws && declaration.raws.value && declaration.raws.value.raw ? declaration.raws.value.raw : declaration[key]);
+  let inBetween;
+
+  if (declaration.raws && declaration.raws.between) {
+    const lastCommentIndex = declaration.raws.between.lastIndexOf("/*");
+    const matched = declaration.raws.between.slice(lastCommentIndex).match(_utils.WEBPACK_IGNORE_COMMENT_REGEXP);
+
+    if (matched) {
+      inBetween = matched[2] === "true";
+    }
+  }
+
+  let isIgnoreOnDeclaration = false;
+  const prevNode = declaration.prev();
+
+  if (prevNode && prevNode.type === "comment") {
+    const matched = prevNode.text.match(_utils.WEBPACK_IGNORE_COMMENT_REGEXP);
+
+    if (matched) {
+      isIgnoreOnDeclaration = matched[2] === "true";
+    }
+  }
+
+  let needIgnore;
+  const parsedURLs = [];
+  parsed.walk((valueNode, index, valueNodes) => {
+    if (valueNode.type !== "function") {
+      return;
+    }
+
+    if (isUrlFunc.test(valueNode.value)) {
+      needIgnore = getWebpackIgnoreCommentValue(index, valueNodes, inBetween);
+
+      if (isIgnoreOnDeclaration && typeof needIgnore === "undefined" || needIgnore) {
+        if (needIgnore) {
+          // eslint-disable-next-line no-undefined
+          needIgnore = undefined;
+        }
+
+        return;
+      }
+
+      const {
+        nodes
+      } = valueNode;
+      const isStringValue = nodes.length !== 0 && nodes[0].type === "string";
+      let url = isStringValue ? nodes[0].value : _postcssValueParser.default.stringify(nodes);
+      url = (0, _utils.normalizeUrl)(url, isStringValue);
+      const {
+        requestable,
+        needResolve
+      } = shouldHandleURL(url, declaration, result, options); // Do not traverse inside `url`
+
+      if (!requestable) {
+        // eslint-disable-next-line consistent-return
+        return false;
+      }
+
+      const queryParts = url.split("!");
+      let prefix;
+
+      if (queryParts.length > 1) {
+        url = queryParts.pop();
+        prefix = queryParts.join("!");
+      }
+
+      parsedURLs.push({
+        declaration,
+        parsed,
+        node: getNodeFromUrlFunc(valueNode),
+        prefix,
+        url,
+        needQuotes: false,
+        needResolve
+      }); // eslint-disable-next-line consistent-return
+
+      return false;
+    } else if (isImageSetFunc.test(valueNode.value)) {
+      for (const [innerIndex, nNode] of valueNode.nodes.entries()) {
+        const {
+          type,
+          value
+        } = nNode;
+
+        if (type === "function" && isUrlFunc.test(value)) {
+          needIgnore = getWebpackIgnoreCommentValue(innerIndex, valueNode.nodes);
+
+          if (isIgnoreOnDeclaration && typeof needIgnore === "undefined" || needIgnore) {
+            if (needIgnore) {
+              // eslint-disable-next-line no-undefined
+              needIgnore = undefined;
+            } // eslint-disable-next-line no-continue
+
+
+            continue;
+          }
+
+          const {
+            nodes
+          } = nNode;
+          const isStringValue = nodes.length !== 0 && nodes[0].type === "string";
+          let url = isStringValue ? nodes[0].value : _postcssValueParser.default.stringify(nodes);
+          url = (0, _utils.normalizeUrl)(url, isStringValue);
+          const {
+            requestable,
+            needResolve
+          } = shouldHandleURL(url, declaration, result, options); // Do not traverse inside `url`
+
+          if (!requestable) {
+            // eslint-disable-next-line consistent-return
+            return false;
+          }
+
+          const queryParts = url.split("!");
+          let prefix;
+
+          if (queryParts.length > 1) {
+            url = queryParts.pop();
+            prefix = queryParts.join("!");
+          }
+
+          parsedURLs.push({
+            declaration,
+            parsed,
+            node: getNodeFromUrlFunc(nNode),
+            prefix,
+            url,
+            needQuotes: false,
+            needResolve
+          });
+        } else if (type === "string") {
+          needIgnore = getWebpackIgnoreCommentValue(innerIndex, valueNode.nodes);
+
+          if (isIgnoreOnDeclaration && typeof needIgnore === "undefined" || needIgnore) {
+            if (needIgnore) {
+              // eslint-disable-next-line no-undefined
+              needIgnore = undefined;
+            } // eslint-disable-next-line no-continue
+
+
+            continue;
+          }
+
+          let url = (0, _utils.normalizeUrl)(value, true);
+          const {
+            requestable,
+            needResolve
+          } = shouldHandleURL(url, declaration, result, options); // Do not traverse inside `url`
+
+          if (!requestable) {
+            // eslint-disable-next-line consistent-return
+            return false;
+          }
+
+          const queryParts = url.split("!");
+          let prefix;
+
+          if (queryParts.length > 1) {
+            url = queryParts.pop();
+            prefix = queryParts.join("!");
+          }
+
+          parsedURLs.push({
+            declaration,
+            parsed,
+            node: nNode,
+            prefix,
+            url,
+            needQuotes: true,
+            needResolve
+          });
+        }
+      } // Do not traverse inside `image-set`
+      // eslint-disable-next-line consistent-return
+
+
+      return false;
+    }
+  }); // eslint-disable-next-line consistent-return
+
+  return parsedURLs;
+}
+
+const plugin = (options = {}) => {
+  return {
+    postcssPlugin: "postcss-url-parser",
+
+    prepare(result) {
+      const parsedDeclarations = [];
+      return {
+        Declaration(declaration) {
+          const {
+            isSupportDataURL,
+            isSupportAbsoluteURL
+          } = options;
+          const parsedURL = parseDeclaration(declaration, "value", result, {
+            isSupportDataURL,
+            isSupportAbsoluteURL
+          });
+
+          if (!parsedURL) {
+            return;
+          }
+
+          parsedDeclarations.push(...parsedURL);
+        },
+
+        async OnceExit() {
+          if (parsedDeclarations.length === 0) {
+            return;
+          }
+
+          const resolvedDeclarations = await Promise.all(parsedDeclarations.map(async parsedDeclaration => {
+            const {
+              url,
+              needResolve
+            } = parsedDeclaration;
+
+            if (options.filter) {
+              const needKeep = await options.filter(url);
+
+              if (!needKeep) {
+                // eslint-disable-next-line consistent-return
+                return;
+              }
+            }
+
+            if (!needResolve) {
+              // eslint-disable-next-line consistent-return
+              return parsedDeclaration;
+            }
+
+            const splittedUrl = url.split(/(\?)?#/);
+            const [pathname, query, hashOrQuery] = splittedUrl;
+            let hash = query ? "?" : "";
+            hash += hashOrQuery ? `#${hashOrQuery}` : "";
+            const {
+              resolver,
+              rootContext
+            } = options;
+            const request = (0, _utils.requestify)(pathname, rootContext, Boolean(resolver));
+
+            if (!resolver) {
+              // eslint-disable-next-line consistent-return
+              return { ...parsedDeclaration,
+                url: request,
+                hash
+              };
+            }
+
+            const resolvedURL = await (0, _utils.resolveRequests)(resolver, options.context, [...new Set([request, url])]);
+
+            if (!resolvedURL) {
+              // eslint-disable-next-line consistent-return
+              return;
+            } // eslint-disable-next-line consistent-return
+
+
+            return { ...parsedDeclaration,
+              url: resolvedURL,
+              hash
+            };
+          }));
+          const urlToNameMap = new Map();
+          const urlToReplacementMap = new Map();
+          let hasUrlImportHelper = false;
+
+          for (let index = 0; index <= resolvedDeclarations.length - 1; index++) {
+            const item = resolvedDeclarations[index];
+
+            if (!item) {
+              // eslint-disable-next-line no-continue
+              continue;
+            }
+
+            if (!hasUrlImportHelper) {
+              options.imports.push({
+                type: "get_url_import",
+                importName: "___CSS_LOADER_GET_URL_IMPORT___",
+                url: options.urlHandler(require.resolve("../runtime/getUrl.js")),
+                index: -1
+              });
+              hasUrlImportHelper = true;
+            }
+
+            const {
+              url,
+              prefix
+            } = item;
+            const newUrl = prefix ? `${prefix}!${url}` : url;
+            let importName = urlToNameMap.get(newUrl);
+
+            if (!importName) {
+              importName = `___CSS_LOADER_URL_IMPORT_${urlToNameMap.size}___`;
+              urlToNameMap.set(newUrl, importName);
+              options.imports.push({
+                type: "url",
+                importName,
+                url: options.resolver ? options.urlHandler(newUrl) : JSON.stringify(newUrl),
+                index
+              });
+            }
+
+            const {
+              hash,
+              needQuotes
+            } = item;
+            const replacementKey = JSON.stringify({
+              newUrl,
+              hash,
+              needQuotes
+            });
+            let replacementName = urlToReplacementMap.get(replacementKey);
+
+            if (!replacementName) {
+              replacementName = `___CSS_LOADER_URL_REPLACEMENT_${urlToReplacementMap.size}___`;
+              urlToReplacementMap.set(replacementKey, replacementName);
+              options.replacements.push({
+                replacementName,
+                importName,
+                hash,
+                needQuotes
+              });
+            } // eslint-disable-next-line no-param-reassign
+
+
+            item.node.type = "word"; // eslint-disable-next-line no-param-reassign
+
+            item.node.value = replacementName; // eslint-disable-next-line no-param-reassign
+
+            item.declaration.value = item.parsed.toString();
+          }
+        }
+
+      };
+    }
+
+  };
+};
+
+plugin.postcss = true;
+var _default = plugin;
+exports.default = _default;

node_modules/css-loader/dist/runtime/api.js

@@ -0,0 +1,102 @@
+"use strict";
+
+/*
+  MIT License http://www.opensource.org/licenses/mit-license.php
+  Author Tobias Koppers @sokra
+*/
+module.exports = function (cssWithMappingToString) {
+  var list = []; // return the list of modules as css string
+
+  list.toString = function toString() {
+    return this.map(function (item) {
+      var content = "";
+      var needLayer = typeof item[5] !== "undefined";
+
+      if (item[4]) {
+        content += "@supports (".concat(item[4], ") {");
+      }
+
+      if (item[2]) {
+        content += "@media ".concat(item[2], " {");
+      }
+
+      if (needLayer) {
+        content += "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {");
+      }
+
+      content += cssWithMappingToString(item);
+
+      if (needLayer) {
+        content += "}";
+      }
+
+      if (item[2]) {
+        content += "}";
+      }
+
+      if (item[4]) {
+        content += "}";
+      }
+
+      return content;
+    }).join("");
+  }; // import a list of modules into the list
+
+
+  list.i = function i(modules, media, dedupe, supports, layer) {
+    if (typeof modules === "string") {
+      modules = [[null, modules, undefined]];
+    }
+
+    var alreadyImportedModules = {};
+
+    if (dedupe) {
+      for (var k = 0; k < this.length; k++) {
+        var id = this[k][0];
+
+        if (id != null) {
+          alreadyImportedModules[id] = true;
+        }
+      }
+    }
+
+    for (var _k = 0; _k < modules.length; _k++) {
+      var item = [].concat(modules[_k]);
+
+      if (dedupe && alreadyImportedModules[item[0]]) {
+        continue;
+      }
+
+      if (typeof layer !== "undefined") {
+        if (typeof item[5] === "undefined") {
+          item[5] = layer;
+        } else {
+          item[1] = "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {").concat(item[1], "}");
+          item[5] = layer;
+        }
+      }
+
+      if (media) {
+        if (!item[2]) {
+          item[2] = media;
+        } else {
+          item[1] = "@media ".concat(item[2], " {").concat(item[1], "}");
+          item[2] = media;
+        }
+      }
+
+      if (supports) {
+        if (!item[4]) {
+          item[4] = "".concat(supports);
+        } else {
+          item[1] = "@supports (".concat(item[4], ") {").concat(item[1], "}");
+          item[4] = supports;
+        }
+      }
+
+      list.push(item);
+    }
+  };
+
+  return list;
+};

node_modules/css-loader/dist/runtime/getUrl.js

@@ -0,0 +1,29 @@
+"use strict";
+
+module.exports = function (url, options) {
+  if (!options) {
+    options = {};
+  }
+
+  if (!url) {
+    return url;
+  }
+
+  url = String(url.__esModule ? url.default : url); // If url is already wrapped in quotes, remove them
+
+  if (/^['"].*['"]$/.test(url)) {
+    url = url.slice(1, -1);
+  }
+
+  if (options.hash) {
+    url += options.hash;
+  } // Should url be wrapped?
+  // See https://drafts.csswg.org/css-values-3/#urls
+
+
+  if (/["'() \t\n]|(%20)/.test(url) || options.needQuotes) {
+    return "\"".concat(url.replace(/"/g, '\\"').replace(/\n/g, "\\n"), "\"");
+  }
+
+  return url;
+};

node_modules/css-loader/dist/runtime/noSourceMaps.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function (i) {
+  return i[1];
+};

node_modules/css-loader/dist/runtime/sourceMaps.js

@@ -0,0 +1,22 @@
+"use strict";
+
+module.exports = function (item) {
+  var content = item[1];
+  var cssMapping = item[3];
+
+  if (!cssMapping) {
+    return content;
+  }
+
+  if (typeof btoa === "function") {
+    var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));
+    var data = "sourceMappingURL=data:application/json;charset=utf-8;base64,".concat(base64);
+    var sourceMapping = "/*# ".concat(data, " */");
+    var sourceURLs = cssMapping.sources.map(function (source) {
+      return "/*# sourceURL=".concat(cssMapping.sourceRoot || "").concat(source, " */");
+    });
+    return [content].concat(sourceURLs).concat([sourceMapping]).join("\n");
+  }
+
+  return [content].join("\n");
+};

node_modules/css-loader/node_modules/.bin/semver

@@ -0,0 +1 @@
+../semver/bin/semver.js

node_modules/css-loader/node_modules/semver/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

node_modules/css-loader/node_modules/semver/README.md

@@ -0,0 +1,568 @@
+semver(1) -- The semantic versioner for npm
+===========================================
+
+## Install
+
+```bash
+npm install semver
+````
+
+## Usage
+
+As a node module:
+
+```js
+const semver = require('semver')
+
+semver.valid('1.2.3') // '1.2.3'
+semver.valid('a.b.c') // null
+semver.clean('  =v1.2.3   ') // '1.2.3'
+semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true
+semver.gt('1.2.3', '9.8.7') // false
+semver.lt('1.2.3', '9.8.7') // true
+semver.minVersion('>=1.0.0') // '1.0.0'
+semver.valid(semver.coerce('v2')) // '2.0.0'
+semver.valid(semver.coerce('42.6.7.9.3-alpha')) // '42.6.7'
+```
+
+You can also just load the module for the function that you care about, if
+you'd like to minimize your footprint.
+
+```js
+// load the whole API at once in a single object
+const semver = require('semver')
+
+// or just load the bits you need
+// all of them listed here, just pick and choose what you want
+
+// classes
+const SemVer = require('semver/classes/semver')
+const Comparator = require('semver/classes/comparator')
+const Range = require('semver/classes/range')
+
+// functions for working with versions
+const semverParse = require('semver/functions/parse')
+const semverValid = require('semver/functions/valid')
+const semverClean = require('semver/functions/clean')
+const semverInc = require('semver/functions/inc')
+const semverDiff = require('semver/functions/diff')
+const semverMajor = require('semver/functions/major')
+const semverMinor = require('semver/functions/minor')
+const semverPatch = require('semver/functions/patch')
+const semverPrerelease = require('semver/functions/prerelease')
+const semverCompare = require('semver/functions/compare')
+const semverRcompare = require('semver/functions/rcompare')
+const semverCompareLoose = require('semver/functions/compare-loose')
+const semverCompareBuild = require('semver/functions/compare-build')
+const semverSort = require('semver/functions/sort')
+const semverRsort = require('semver/functions/rsort')
+
+// low-level comparators between versions
+const semverGt = require('semver/functions/gt')
+const semverLt = require('semver/functions/lt')
+const semverEq = require('semver/functions/eq')
+const semverNeq = require('semver/functions/neq')
+const semverGte = require('semver/functions/gte')
+const semverLte = require('semver/functions/lte')
+const semverCmp = require('semver/functions/cmp')
+const semverCoerce = require('semver/functions/coerce')
+
+// working with ranges
+const semverSatisfies = require('semver/functions/satisfies')
+const semverMaxSatisfying = require('semver/ranges/max-satisfying')
+const semverMinSatisfying = require('semver/ranges/min-satisfying')
+const semverToComparators = require('semver/ranges/to-comparators')
+const semverMinVersion = require('semver/ranges/min-version')
+const semverValidRange = require('semver/ranges/valid')
+const semverOutside = require('semver/ranges/outside')
+const semverGtr = require('semver/ranges/gtr')
+const semverLtr = require('semver/ranges/ltr')
+const semverIntersects = require('semver/ranges/intersects')
+const simplifyRange = require('semver/ranges/simplify')
+const rangeSubset = require('semver/ranges/subset')
+```
+
+As a command-line utility:
+
+```
+$ semver -h
+
+A JavaScript implementation of the https://semver.org/ specification
+Copyright Isaac Z. Schlueter
+
+Usage: semver [options] <version> [<version> [...]]
+Prints valid versions sorted by SemVer precedence
+
+Options:
+-r --range <range>
+        Print versions that match the specified range.
+
+-i --increment [<level>]
+        Increment a version by the specified level.  Level can
+        be one of: major, minor, patch, premajor, preminor,
+        prepatch, or prerelease.  Default level is 'patch'.
+        Only one version may be specified.
+
+--preid <identifier>
+        Identifier to be used to prefix premajor, preminor,
+        prepatch or prerelease version increments.
+
+-l --loose
+        Interpret versions and ranges loosely
+
+-p --include-prerelease
+        Always include prerelease versions in range matching
+
+-c --coerce
+        Coerce a string into SemVer if possible
+        (does not imply --loose)
+
+--rtl
+        Coerce version strings right to left
+
+--ltr
+        Coerce version strings left to right (default)
+
+Program exits successfully if any valid version satisfies
+all supplied ranges, and prints all satisfying versions.
+
+If no satisfying versions are found, then exits failure.
+
+Versions are printed in ascending order, so supplying
+multiple versions to the utility will just sort them.
+```
+
+## Versions
+
+A "version" is described by the `v2.0.0` specification found at
+<https://semver.org/>.
+
+A leading `"="` or `"v"` character is stripped off and ignored.
+
+## Ranges
+
+A `version range` is a set of `comparators` which specify versions
+that satisfy the range.
+
+A `comparator` is composed of an `operator` and a `version`.  The set
+of primitive `operators` is:
+
+* `<` Less than
+* `<=` Less than or equal to
+* `>` Greater than
+* `>=` Greater than or equal to
+* `=` Equal.  If no operator is specified, then equality is assumed,
+  so this operator is optional, but MAY be included.
+
+For example, the comparator `>=1.2.7` would match the versions
+`1.2.7`, `1.2.8`, `2.5.3`, and `1.3.9`, but not the versions `1.2.6`
+or `1.1.0`.
+
+Comparators can be joined by whitespace to form a `comparator set`,
+which is satisfied by the **intersection** of all of the comparators
+it includes.
+
+A range is composed of one or more comparator sets, joined by `||`.  A
+version matches a range if and only if every comparator in at least
+one of the `||`-separated comparator sets is satisfied by the version.
+
+For example, the range `>=1.2.7 <1.3.0` would match the versions
+`1.2.7`, `1.2.8`, and `1.2.99`, but not the versions `1.2.6`, `1.3.0`,
+or `1.1.0`.
+
+The range `1.2.7 || >=1.2.9 <2.0.0` would match the versions `1.2.7`,
+`1.2.9`, and `1.4.6`, but not the versions `1.2.8` or `2.0.0`.
+
+### Prerelease Tags
+
+If a version has a prerelease tag (for example, `1.2.3-alpha.3`) then
+it will only be allowed to satisfy comparator sets if at least one
+comparator with the same `[major, minor, patch]` tuple also has a
+prerelease tag.
+
+For example, the range `>1.2.3-alpha.3` would be allowed to match the
+version `1.2.3-alpha.7`, but it would *not* be satisfied by
+`3.4.5-alpha.9`, even though `3.4.5-alpha.9` is technically "greater
+than" `1.2.3-alpha.3` according to the SemVer sort rules.  The version
+range only accepts prerelease tags on the `1.2.3` version.  The
+version `3.4.5` *would* satisfy the range, because it does not have a
+prerelease flag, and `3.4.5` is greater than `1.2.3-alpha.7`.
+
+The purpose for this behavior is twofold.  First, prerelease versions
+frequently are updated very quickly, and contain many breaking changes
+that are (by the author's design) not yet fit for public consumption.
+Therefore, by default, they are excluded from range matching
+semantics.
+
+Second, a user who has opted into using a prerelease version has
+clearly indicated the intent to use *that specific* set of
+alpha/beta/rc versions.  By including a prerelease tag in the range,
+the user is indicating that they are aware of the risk.  However, it
+is still not appropriate to assume that they have opted into taking a
+similar risk on the *next* set of prerelease versions.
+
+Note that this behavior can be suppressed (treating all prerelease
+versions as if they were normal versions, for the purpose of range
+matching) by setting the `includePrerelease` flag on the options
+object to any
+[functions](https://github.com/npm/node-semver#functions) that do
+range matching.
+
+#### Prerelease Identifiers
+
+The method `.inc` takes an additional `identifier` string argument that
+will append the value of the string as a prerelease identifier:
+
+```javascript
+semver.inc('1.2.3', 'prerelease', 'beta')
+// '1.2.4-beta.0'
+```
+
+command-line example:
+
+```bash
+$ semver 1.2.3 -i prerelease --preid beta
+1.2.4-beta.0
+```
+
+Which then can be used to increment further:
+
+```bash
+$ semver 1.2.4-beta.0 -i prerelease
+1.2.4-beta.1
+```
+
+### Advanced Range Syntax
+
+Advanced range syntax desugars to primitive comparators in
+deterministic ways.
+
+Advanced ranges may be combined in the same way as primitive
+comparators using white space or `||`.
+
+#### Hyphen Ranges `X.Y.Z - A.B.C`
+
+Specifies an inclusive set.
+
+* `1.2.3 - 2.3.4` := `>=1.2.3 <=2.3.4`
+
+If a partial version is provided as the first version in the inclusive
+range, then the missing pieces are replaced with zeroes.
+
+* `1.2 - 2.3.4` := `>=1.2.0 <=2.3.4`
+
+If a partial version is provided as the second version in the
+inclusive range, then all versions that start with the supplied parts
+of the tuple are accepted, but nothing that would be greater than the
+provided tuple parts.
+
+* `1.2.3 - 2.3` := `>=1.2.3 <2.4.0-0`
+* `1.2.3 - 2` := `>=1.2.3 <3.0.0-0`
+
+#### X-Ranges `1.2.x` `1.X` `1.2.*` `*`
+
+Any of `X`, `x`, or `*` may be used to "stand in" for one of the
+numeric values in the `[major, minor, patch]` tuple.
+
+* `*` := `>=0.0.0` (Any non-prerelease version satisfies, unless
+  `includePrerelease` is specified, in which case any version at all
+  satisfies)
+* `1.x` := `>=1.0.0 <2.0.0-0` (Matching major version)
+* `1.2.x` := `>=1.2.0 <1.3.0-0` (Matching major and minor versions)
+
+A partial version range is treated as an X-Range, so the special
+character is in fact optional.
+
+* `""` (empty string) := `*` := `>=0.0.0`
+* `1` := `1.x.x` := `>=1.0.0 <2.0.0-0`
+* `1.2` := `1.2.x` := `>=1.2.0 <1.3.0-0`
+
+#### Tilde Ranges `~1.2.3` `~1.2` `~1`
+
+Allows patch-level changes if a minor version is specified on the
+comparator.  Allows minor-level changes if not.
+
+* `~1.2.3` := `>=1.2.3 <1.(2+1).0` := `>=1.2.3 <1.3.0-0`
+* `~1.2` := `>=1.2.0 <1.(2+1).0` := `>=1.2.0 <1.3.0-0` (Same as `1.2.x`)
+* `~1` := `>=1.0.0 <(1+1).0.0` := `>=1.0.0 <2.0.0-0` (Same as `1.x`)
+* `~0.2.3` := `>=0.2.3 <0.(2+1).0` := `>=0.2.3 <0.3.0-0`
+* `~0.2` := `>=0.2.0 <0.(2+1).0` := `>=0.2.0 <0.3.0-0` (Same as `0.2.x`)
+* `~0` := `>=0.0.0 <(0+1).0.0` := `>=0.0.0 <1.0.0-0` (Same as `0.x`)
+* `~1.2.3-beta.2` := `>=1.2.3-beta.2 <1.3.0-0` Note that prereleases in
+  the `1.2.3` version will be allowed, if they are greater than or
+  equal to `beta.2`.  So, `1.2.3-beta.4` would be allowed, but
+  `1.2.4-beta.2` would not, because it is a prerelease of a
+  different `[major, minor, patch]` tuple.
+
+#### Caret Ranges `^1.2.3` `^0.2.5` `^0.0.4`
+
+Allows changes that do not modify the left-most non-zero element in the
+`[major, minor, patch]` tuple.  In other words, this allows patch and
+minor updates for versions `1.0.0` and above, patch updates for
+versions `0.X >=0.1.0`, and *no* updates for versions `0.0.X`.
+
+Many authors treat a `0.x` version as if the `x` were the major
+"breaking-change" indicator.
+
+Caret ranges are ideal when an author may make breaking changes
+between `0.2.4` and `0.3.0` releases, which is a common practice.
+However, it presumes that there will *not* be breaking changes between
+`0.2.4` and `0.2.5`.  It allows for changes that are presumed to be
+additive (but non-breaking), according to commonly observed practices.
+
+* `^1.2.3` := `>=1.2.3 <2.0.0-0`
+* `^0.2.3` := `>=0.2.3 <0.3.0-0`
+* `^0.0.3` := `>=0.0.3 <0.0.4-0`
+* `^1.2.3-beta.2` := `>=1.2.3-beta.2 <2.0.0-0` Note that prereleases in
+  the `1.2.3` version will be allowed, if they are greater than or
+  equal to `beta.2`.  So, `1.2.3-beta.4` would be allowed, but
+  `1.2.4-beta.2` would not, because it is a prerelease of a
+  different `[major, minor, patch]` tuple.
+* `^0.0.3-beta` := `>=0.0.3-beta <0.0.4-0`  Note that prereleases in the
+  `0.0.3` version *only* will be allowed, if they are greater than or
+  equal to `beta`.  So, `0.0.3-pr.2` would be allowed.
+
+When parsing caret ranges, a missing `patch` value desugars to the
+number `0`, but will allow flexibility within that value, even if the
+major and minor versions are both `0`.
+
+* `^1.2.x` := `>=1.2.0 <2.0.0-0`
+* `^0.0.x` := `>=0.0.0 <0.1.0-0`
+* `^0.0` := `>=0.0.0 <0.1.0-0`
+
+A missing `minor` and `patch` values will desugar to zero, but also
+allow flexibility within those values, even if the major version is
+zero.
+
+* `^1.x` := `>=1.0.0 <2.0.0-0`
+* `^0.x` := `>=0.0.0 <1.0.0-0`
+
+### Range Grammar
+
+Putting all this together, here is a Backus-Naur grammar for ranges,
+for the benefit of parser authors:
+
+```bnf
+range-set  ::= range ( logical-or range ) *
+logical-or ::= ( ' ' ) * '||' ( ' ' ) *
+range      ::= hyphen | simple ( ' ' simple ) * | ''
+hyphen     ::= partial ' - ' partial
+simple     ::= primitive | partial | tilde | caret
+primitive  ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
+partial    ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
+xr         ::= 'x' | 'X' | '*' | nr
+nr         ::= '0' | ['1'-'9'] ( ['0'-'9'] ) *
+tilde      ::= '~' partial
+caret      ::= '^' partial
+qualifier  ::= ( '-' pre )? ( '+' build )?
+pre        ::= parts
+build      ::= parts
+parts      ::= part ( '.' part ) *
+part       ::= nr | [-0-9A-Za-z]+
+```
+
+## Functions
+
+All methods and classes take a final `options` object argument.  All
+options in this object are `false` by default.  The options supported
+are:
+
+- `loose`  Be more forgiving about not-quite-valid semver strings.
+  (Any resulting output will always be 100% strict compliant, of
+  course.)  For backwards compatibility reasons, if the `options`
+  argument is a boolean value instead of an object, it is interpreted
+  to be the `loose` param.
+- `includePrerelease`  Set to suppress the [default
+  behavior](https://github.com/npm/node-semver#prerelease-tags) of
+  excluding prerelease tagged versions from ranges unless they are
+  explicitly opted into.
+
+Strict-mode Comparators and Ranges will be strict about the SemVer
+strings that they parse.
+
+* `valid(v)`: Return the parsed version, or null if it's not valid.
+* `inc(v, release)`: Return the version incremented by the release
+  type (`major`,   `premajor`, `minor`, `preminor`, `patch`,
+  `prepatch`, or `prerelease`), or null if it's not valid
+  * `premajor` in one call will bump the version up to the next major
+    version and down to a prerelease of that major version.
+    `preminor`, and `prepatch` work the same way.
+  * If called from a non-prerelease version, the `prerelease` will work the
+    same as `prepatch`. It increments the patch version, then makes a
+    prerelease. If the input version is already a prerelease it simply
+    increments it.
+* `prerelease(v)`: Returns an array of prerelease components, or null
+  if none exist. Example: `prerelease('1.2.3-alpha.1') -> ['alpha', 1]`
+* `major(v)`: Return the major version number.
+* `minor(v)`: Return the minor version number.
+* `patch(v)`: Return the patch version number.
+* `intersects(r1, r2, loose)`: Return true if the two supplied ranges
+  or comparators intersect.
+* `parse(v)`: Attempt to parse a string as a semantic version, returning either
+  a `SemVer` object or `null`.
+
+### Comparison
+
+* `gt(v1, v2)`: `v1 > v2`
+* `gte(v1, v2)`: `v1 >= v2`
+* `lt(v1, v2)`: `v1 < v2`
+* `lte(v1, v2)`: `v1 <= v2`
+* `eq(v1, v2)`: `v1 == v2` This is true if they're logically equivalent,
+  even if they're not the exact same string.  You already know how to
+  compare strings.
+* `neq(v1, v2)`: `v1 != v2` The opposite of `eq`.
+* `cmp(v1, comparator, v2)`: Pass in a comparison string, and it'll call
+  the corresponding function above.  `"==="` and `"!=="` do simple
+  string comparison, but are included for completeness.  Throws if an
+  invalid comparison string is provided.
+* `compare(v1, v2)`: Return `0` if `v1 == v2`, or `1` if `v1` is greater, or `-1` if
+  `v2` is greater.  Sorts in ascending order if passed to `Array.sort()`.
+* `rcompare(v1, v2)`: The reverse of compare.  Sorts an array of versions
+  in descending order when passed to `Array.sort()`.
+* `compareBuild(v1, v2)`: The same as `compare` but considers `build` when two versions
+  are equal.  Sorts in ascending order if passed to `Array.sort()`.
+  `v2` is greater.  Sorts in ascending order if passed to `Array.sort()`.
+* `diff(v1, v2)`: Returns difference between two versions by the release type
+  (`major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, or `prerelease`),
+  or null if the versions are the same.
+
+### Comparators
+
+* `intersects(comparator)`: Return true if the comparators intersect
+
+### Ranges
+
+* `validRange(range)`: Return the valid range or null if it's not valid
+* `satisfies(version, range)`: Return true if the version satisfies the
+  range.
+* `maxSatisfying(versions, range)`: Return the highest version in the list
+  that satisfies the range, or `null` if none of them do.
+* `minSatisfying(versions, range)`: Return the lowest version in the list
+  that satisfies the range, or `null` if none of them do.
+* `minVersion(range)`: Return the lowest version that can possibly match
+  the given range.
+* `gtr(version, range)`: Return `true` if version is greater than all the
+  versions possible in the range.
+* `ltr(version, range)`: Return `true` if version is less than all the
+  versions possible in the range.
+* `outside(version, range, hilo)`: Return true if the version is outside
+  the bounds of the range in either the high or low direction.  The
+  `hilo` argument must be either the string `'>'` or `'<'`.  (This is
+  the function called by `gtr` and `ltr`.)
+* `intersects(range)`: Return true if any of the ranges comparators intersect
+* `simplifyRange(versions, range)`: Return a "simplified" range that
+  matches the same items in `versions` list as the range specified.  Note
+  that it does *not* guarantee that it would match the same versions in all
+  cases, only for the set of versions provided.  This is useful when
+  generating ranges by joining together multiple versions with `||`
+  programmatically, to provide the user with something a bit more
+  ergonomic.  If the provided range is shorter in string-length than the
+  generated range, then that is returned.
+* `subset(subRange, superRange)`: Return `true` if the `subRange` range is
+  entirely contained by the `superRange` range.
+
+Note that, since ranges may be non-contiguous, a version might not be
+greater than a range, less than a range, *or* satisfy a range!  For
+example, the range `1.2 <1.2.9 || >2.0.0` would have a hole from `1.2.9`
+until `2.0.0`, so the version `1.2.10` would not be greater than the
+range (because `2.0.1` satisfies, which is higher), nor less than the
+range (since `1.2.8` satisfies, which is lower), and it also does not
+satisfy the range.
+
+If you want to know if a version satisfies or does not satisfy a
+range, use the `satisfies(version, range)` function.
+
+### Coercion
+
+* `coerce(version, options)`: Coerces a string to semver if possible
+
+This aims to provide a very forgiving translation of a non-semver string to
+semver. It looks for the first digit in a string, and consumes all
+remaining characters which satisfy at least a partial semver (e.g., `1`,
+`1.2`, `1.2.3`) up to the max permitted length (256 characters).  Longer
+versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`).  All
+surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes
+`3.4.0`).  Only text which lacks digits will fail coercion (`version one`
+is not valid).  The maximum  length for any semver component considered for
+coercion is 16 characters; longer components will be ignored
+(`10000000000000000.4.7.4` becomes `4.7.4`).  The maximum value for any
+semver component is `Number.MAX_SAFE_INTEGER || (2**53 - 1)`; higher value
+components are invalid (`9999999999999999.4.7.4` is likely invalid).
+
+If the `options.rtl` flag is set, then `coerce` will return the right-most
+coercible tuple that does not share an ending index with a longer coercible
+tuple.  For example, `1.2.3.4` will return `2.3.4` in rtl mode, not
+`4.0.0`.  `1.2.3/4` will return `4.0.0`, because the `4` is not a part of
+any other overlapping SemVer tuple.
+
+### Clean
+
+* `clean(version)`: Clean a string to be a valid semver if possible
+
+This will return a cleaned and trimmed semver version. If the provided
+version is not valid a null will be returned. This does not work for
+ranges.
+
+ex.
+* `s.clean(' = v 2.1.5foo')`: `null`
+* `s.clean(' = v 2.1.5foo', { loose: true })`: `'2.1.5-foo'`
+* `s.clean(' = v 2.1.5-foo')`: `null`
+* `s.clean(' = v 2.1.5-foo', { loose: true })`: `'2.1.5-foo'`
+* `s.clean('=v2.1.5')`: `'2.1.5'`
+* `s.clean('  =v2.1.5')`: `2.1.5`
+* `s.clean('      2.1.5   ')`: `'2.1.5'`
+* `s.clean('~1.0.0')`: `null`
+
+## Exported Modules
+
+<!--
+TODO: Make sure that all of these items are documented (classes aren't,
+eg), and then pull the module name into the documentation for that specific
+thing.
+-->
+
+You may pull in just the part of this semver utility that you need, if you
+are sensitive to packing and tree-shaking concerns.  The main
+`require('semver')` export uses getter functions to lazily load the parts
+of the API that are used.
+
+The following modules are available:
+
+* `require('semver')`
+* `require('semver/classes')`
+* `require('semver/classes/comparator')`
+* `require('semver/classes/range')`
+* `require('semver/classes/semver')`
+* `require('semver/functions/clean')`
+* `require('semver/functions/cmp')`
+* `require('semver/functions/coerce')`
+* `require('semver/functions/compare')`
+* `require('semver/functions/compare-build')`
+* `require('semver/functions/compare-loose')`
+* `require('semver/functions/diff')`
+* `require('semver/functions/eq')`
+* `require('semver/functions/gt')`
+* `require('semver/functions/gte')`
+* `require('semver/functions/inc')`
+* `require('semver/functions/lt')`
+* `require('semver/functions/lte')`
+* `require('semver/functions/major')`
+* `require('semver/functions/minor')`
+* `require('semver/functions/neq')`
+* `require('semver/functions/parse')`
+* `require('semver/functions/patch')`
+* `require('semver/functions/prerelease')`
+* `require('semver/functions/rcompare')`
+* `require('semver/functions/rsort')`
+* `require('semver/functions/satisfies')`
+* `require('semver/functions/sort')`
+* `require('semver/functions/valid')`
+* `require('semver/ranges/gtr')`
+* `require('semver/ranges/intersects')`
+* `require('semver/ranges/ltr')`
+* `require('semver/ranges/max-satisfying')`
+* `require('semver/ranges/min-satisfying')`
+* `require('semver/ranges/min-version')`
+* `require('semver/ranges/outside')`
+* `require('semver/ranges/to-comparators')`
+* `require('semver/ranges/valid')`

node_modules/css-loader/node_modules/semver/bin/semver.js

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+// Standalone semver comparison program.
+// Exits successfully and prints matching version(s) if
+// any supplied version is valid and passes all tests.
+
+const argv = process.argv.slice(2)
+
+let versions = []
+
+const range = []
+
+let inc = null
+
+const version = require('../package.json').version
+
+let loose = false
+
+let includePrerelease = false
+
+let coerce = false
+
+let rtl = false
+
+let identifier
+
+const semver = require('../')
+
+let reverse = false
+
+let options = {}
+
+const main = () => {
+  if (!argv.length) {
+    return help()
+  }
+  while (argv.length) {
+    let a = argv.shift()
+    const indexOfEqualSign = a.indexOf('=')
+    if (indexOfEqualSign !== -1) {
+      const value = a.slice(indexOfEqualSign + 1)
+      a = a.slice(0, indexOfEqualSign)
+      argv.unshift(value)
+    }
+    switch (a) {
+      case '-rv': case '-rev': case '--rev': case '--reverse':
+        reverse = true
+        break
+      case '-l': case '--loose':
+        loose = true
+        break
+      case '-p': case '--include-prerelease':
+        includePrerelease = true
+        break
+      case '-v': case '--version':
+        versions.push(argv.shift())
+        break
+      case '-i': case '--inc': case '--increment':
+        switch (argv[0]) {
+          case 'major': case 'minor': case 'patch': case 'prerelease':
+          case 'premajor': case 'preminor': case 'prepatch':
+            inc = argv.shift()
+            break
+          default:
+            inc = 'patch'
+            break
+        }
+        break
+      case '--preid':
+        identifier = argv.shift()
+        break
+      case '-r': case '--range':
+        range.push(argv.shift())
+        break
+      case '-c': case '--coerce':
+        coerce = true
+        break
+      case '--rtl':
+        rtl = true
+        break
+      case '--ltr':
+        rtl = false
+        break
+      case '-h': case '--help': case '-?':
+        return help()
+      default:
+        versions.push(a)
+        break
+    }
+  }
+
+  options = { loose: loose, includePrerelease: includePrerelease, rtl: rtl }
+
+  versions = versions.map((v) => {
+    return coerce ? (semver.coerce(v, options) || { version: v }).version : v
+  }).filter((v) => {
+    return semver.valid(v)
+  })
+  if (!versions.length) {
+    return fail()
+  }
+  if (inc && (versions.length !== 1 || range.length)) {
+    return failInc()
+  }
+
+  for (let i = 0, l = range.length; i < l; i++) {
+    versions = versions.filter((v) => {
+      return semver.satisfies(v, range[i], options)
+    })
+    if (!versions.length) {
+      return fail()
+    }
+  }
+  return success(versions)
+}
+
+const failInc = () => {
+  console.error('--inc can only be used on a single version with no range')
+  fail()
+}
+
+const fail = () => process.exit(1)
+
+const success = () => {
+  const compare = reverse ? 'rcompare' : 'compare'
+  versions.sort((a, b) => {
+    return semver[compare](a, b, options)
+  }).map((v) => {
+    return semver.clean(v, options)
+  }).map((v) => {
+    return inc ? semver.inc(v, inc, options, identifier) : v
+  }).forEach((v, i, _) => {
+    console.log(v)
+  })
+}
+
+const help = () => console.log(
+`SemVer ${version}
+
+A JavaScript implementation of the https://semver.org/ specification
+Copyright Isaac Z. Schlueter
+
+Usage: semver [options] <version> [<version> [...]]
+Prints valid versions sorted by SemVer precedence
+
+Options:
+-r --range <range>
+        Print versions that match the specified range.
+
+-i --increment [<level>]
+        Increment a version by the specified level.  Level can
+        be one of: major, minor, patch, premajor, preminor,
+        prepatch, or prerelease.  Default level is 'patch'.
+        Only one version may be specified.
+
+--preid <identifier>
+        Identifier to be used to prefix premajor, preminor,
+        prepatch or prerelease version increments.
+
+-l --loose
+        Interpret versions and ranges loosely
+
+-p --include-prerelease
+        Always include prerelease versions in range matching
+
+-c --coerce
+        Coerce a string into SemVer if possible
+        (does not imply --loose)
+
+--rtl
+        Coerce version strings right to left
+
+--ltr
+        Coerce version strings left to right (default)
+
+Program exits successfully if any valid version satisfies
+all supplied ranges, and prints all satisfying versions.
+
+If no satisfying versions are found, then exits failure.
+
+Versions are printed in ascending order, so supplying
+multiple versions to the utility will just sort them.`)
+
+main()

node_modules/css-loader/node_modules/semver/classes/comparator.js

@@ -0,0 +1,136 @@
+const ANY = Symbol('SemVer ANY')
+// hoisted class for cyclic dependency
+class Comparator {
+  static get ANY () {
+    return ANY
+  }
+
+  constructor (comp, options) {
+    options = parseOptions(options)
+
+    if (comp instanceof Comparator) {
+      if (comp.loose === !!options.loose) {
+        return comp
+      } else {
+        comp = comp.value
+      }
+    }
+
+    debug('comparator', comp, options)
+    this.options = options
+    this.loose = !!options.loose
+    this.parse(comp)
+
+    if (this.semver === ANY) {
+      this.value = ''
+    } else {
+      this.value = this.operator + this.semver.version
+    }
+
+    debug('comp', this)
+  }
+
+  parse (comp) {
+    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
+    const m = comp.match(r)
+
+    if (!m) {
+      throw new TypeError(`Invalid comparator: ${comp}`)
+    }
+
+    this.operator = m[1] !== undefined ? m[1] : ''
+    if (this.operator === '=') {
+      this.operator = ''
+    }
+
+    // if it literally is just '>' or '' then allow anything.
+    if (!m[2]) {
+      this.semver = ANY
+    } else {
+      this.semver = new SemVer(m[2], this.options.loose)
+    }
+  }
+
+  toString () {
+    return this.value
+  }
+
+  test (version) {
+    debug('Comparator.test', version, this.options.loose)
+
+    if (this.semver === ANY || version === ANY) {
+      return true
+    }
+
+    if (typeof version === 'string') {
+      try {
+        version = new SemVer(version, this.options)
+      } catch (er) {
+        return false
+      }
+    }
+
+    return cmp(version, this.operator, this.semver, this.options)
+  }
+
+  intersects (comp, options) {
+    if (!(comp instanceof Comparator)) {
+      throw new TypeError('a Comparator is required')
+    }
+
+    if (!options || typeof options !== 'object') {
+      options = {
+        loose: !!options,
+        includePrerelease: false,
+      }
+    }
+
+    if (this.operator === '') {
+      if (this.value === '') {
+        return true
+      }
+      return new Range(comp.value, options).test(this.value)
+    } else if (comp.operator === '') {
+      if (comp.value === '') {
+        return true
+      }
+      return new Range(this.value, options).test(comp.semver)
+    }
+
+    const sameDirectionIncreasing =
+      (this.operator === '>=' || this.operator === '>') &&
+      (comp.operator === '>=' || comp.operator === '>')
+    const sameDirectionDecreasing =
+      (this.operator === '<=' || this.operator === '<') &&
+      (comp.operator === '<=' || comp.operator === '<')
+    const sameSemVer = this.semver.version === comp.semver.version
+    const differentDirectionsInclusive =
+      (this.operator === '>=' || this.operator === '<=') &&
+      (comp.operator === '>=' || comp.operator === '<=')
+    const oppositeDirectionsLessThan =
+      cmp(this.semver, '<', comp.semver, options) &&
+      (this.operator === '>=' || this.operator === '>') &&
+        (comp.operator === '<=' || comp.operator === '<')
+    const oppositeDirectionsGreaterThan =
+      cmp(this.semver, '>', comp.semver, options) &&
+      (this.operator === '<=' || this.operator === '<') &&
+        (comp.operator === '>=' || comp.operator === '>')
+
+    return (
+      sameDirectionIncreasing ||
+      sameDirectionDecreasing ||
+      (sameSemVer && differentDirectionsInclusive) ||
+      oppositeDirectionsLessThan ||
+      oppositeDirectionsGreaterThan
+    )
+  }
+}
+
+module.exports = Comparator
+
+const parseOptions = require('../internal/parse-options')
+const { re, t } = require('../internal/re')
+const cmp = require('../functions/cmp')
+const debug = require('../internal/debug')
+const SemVer = require('./semver')
+const Range = require('./range')

node_modules/css-loader/node_modules/semver/classes/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+  SemVer: require('./semver.js'),
+  Range: require('./range.js'),
+  Comparator: require('./comparator.js'),
+}

node_modules/css-loader/node_modules/semver/classes/range.js

@@ -0,0 +1,519 @@
+// hoisted class for cyclic dependency
+class Range {
+  constructor (range, options) {
+    options = parseOptions(options)
+
+    if (range instanceof Range) {
+      if (
+        range.loose === !!options.loose &&
+        range.includePrerelease === !!options.includePrerelease
+      ) {
+        return range
+      } else {
+        return new Range(range.raw, options)
+      }
+    }
+
+    if (range instanceof Comparator) {
+      // just put it in the set and return
+      this.raw = range.value
+      this.set = [[range]]
+      this.format()
+      return this
+    }
+
+    this.options = options
+    this.loose = !!options.loose
+    this.includePrerelease = !!options.includePrerelease
+
+    // First, split based on boolean or ||
+    this.raw = range
+    this.set = range
+      .split('||')
+      // map the range to a 2d array of comparators
+      .map(r => this.parseRange(r.trim()))
+      // throw out any comparator lists that are empty
+      // this generally means that it was not a valid range, which is allowed
+      // in loose mode, but will still throw if the WHOLE range is invalid.
+      .filter(c => c.length)
+
+    if (!this.set.length) {
+      throw new TypeError(`Invalid SemVer Range: ${range}`)
+    }
+
+    // if we have any that are not the null set, throw out null sets.
+    if (this.set.length > 1) {
+      // keep the first one, in case they're all null sets
+      const first = this.set[0]
+      this.set = this.set.filter(c => !isNullSet(c[0]))
+      if (this.set.length === 0) {
+        this.set = [first]
+      } else if (this.set.length > 1) {
+        // if we have any that are *, then the range is just *
+        for (const c of this.set) {
+          if (c.length === 1 && isAny(c[0])) {
+            this.set = [c]
+            break
+          }
+        }
+      }
+    }
+
+    this.format()
+  }
+
+  format () {
+    this.range = this.set
+      .map((comps) => {
+        return comps.join(' ').trim()
+      })
+      .join('||')
+      .trim()
+    return this.range
+  }
+
+  toString () {
+    return this.range
+  }
+
+  parseRange (range) {
+    range = range.trim()
+
+    // memoize range parsing for performance.
+    // this is a very hot path, and fully deterministic.
+    const memoOpts = Object.keys(this.options).join(',')
+    const memoKey = `parseRange:${memoOpts}:${range}`
+    const cached = cache.get(memoKey)
+    if (cached) {
+      return cached
+    }
+
+    const loose = this.options.loose
+    // `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
+    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]
+    range = range.replace(hr, hyphenReplace(this.options.includePrerelease))
+    debug('hyphen replace', range)
+    // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
+    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)
+    debug('comparator trim', range)
+
+    // `~ 1.2.3` => `~1.2.3`
+    range = range.replace(re[t.TILDETRIM], tildeTrimReplace)
+
+    // `^ 1.2.3` => `^1.2.3`
+    range = range.replace(re[t.CARETTRIM], caretTrimReplace)
+
+    // normalize spaces
+    range = range.split(/\s+/).join(' ')
+
+    // At this point, the range is completely trimmed and
+    // ready to be split into comparators.
+
+    let rangeList = range
+      .split(' ')
+      .map(comp => parseComparator(comp, this.options))
+      .join(' ')
+      .split(/\s+/)
+      // >=0.0.0 is equivalent to *
+      .map(comp => replaceGTE0(comp, this.options))
+
+    if (loose) {
+      // in loose mode, throw out any that are not valid comparators
+      rangeList = rangeList.filter(comp => {
+        debug('loose invalid filter', comp, this.options)
+        return !!comp.match(re[t.COMPARATORLOOSE])
+      })
+    }
+    debug('range list', rangeList)
+
+    // if any comparators are the null set, then replace with JUST null set
+    // if more than one comparator, remove any * comparators
+    // also, don't include the same comparator more than once
+    const rangeMap = new Map()
+    const comparators = rangeList.map(comp => new Comparator(comp, this.options))
+    for (const comp of comparators) {
+      if (isNullSet(comp)) {
+        return [comp]
+      }
+      rangeMap.set(comp.value, comp)
+    }
+    if (rangeMap.size > 1 && rangeMap.has('')) {
+      rangeMap.delete('')
+    }
+
+    const result = [...rangeMap.values()]
+    cache.set(memoKey, result)
+    return result
+  }
+
+  intersects (range, options) {
+    if (!(range instanceof Range)) {
+      throw new TypeError('a Range is required')
+    }
+
+    return this.set.some((thisComparators) => {
+      return (
+        isSatisfiable(thisComparators, options) &&
+        range.set.some((rangeComparators) => {
+          return (
+            isSatisfiable(rangeComparators, options) &&
+            thisComparators.every((thisComparator) => {
+              return rangeComparators.every((rangeComparator) => {
+                return thisComparator.intersects(rangeComparator, options)
+              })
+            })
+          )
+        })
+      )
+    })
+  }
+
+  // if ANY of the sets match ALL of its comparators, then pass
+  test (version) {
+    if (!version) {
+      return false
+    }
+
+    if (typeof version === 'string') {
+      try {
+        version = new SemVer(version, this.options)
+      } catch (er) {
+        return false
+      }
+    }
+
+    for (let i = 0; i < this.set.length; i++) {
+      if (testSet(this.set[i], version, this.options)) {
+        return true
+      }
+    }
+    return false
+  }
+}
+module.exports = Range
+
+const LRU = require('lru-cache')
+const cache = new LRU({ max: 1000 })
+
+const parseOptions = require('../internal/parse-options')
+const Comparator = require('./comparator')
+const debug = require('../internal/debug')
+const SemVer = require('./semver')
+const {
+  re,
+  t,
+  comparatorTrimReplace,
+  tildeTrimReplace,
+  caretTrimReplace,
+} = require('../internal/re')
+
+const isNullSet = c => c.value === '<0.0.0-0'
+const isAny = c => c.value === ''
+
+// take a set of comparators and determine whether there
+// exists a version which can satisfy it
+const isSatisfiable = (comparators, options) => {
+  let result = true
+  const remainingComparators = comparators.slice()
+  let testComparator = remainingComparators.pop()
+
+  while (result && remainingComparators.length) {
+    result = remainingComparators.every((otherComparator) => {
+      return testComparator.intersects(otherComparator, options)
+    })
+
+    testComparator = remainingComparators.pop()
+  }
+
+  return result
+}
+
+// comprised of xranges, tildes, stars, and gtlt's at this point.
+// already replaced the hyphen ranges
+// turn into a set of JUST comparators.
+const parseComparator = (comp, options) => {
+  debug('comp', comp, options)
+  comp = replaceCarets(comp, options)
+  debug('caret', comp)
+  comp = replaceTildes(comp, options)
+  debug('tildes', comp)
+  comp = replaceXRanges(comp, options)
+  debug('xrange', comp)
+  comp = replaceStars(comp, options)
+  debug('stars', comp)
+  return comp
+}
+
+const isX = id => !id || id.toLowerCase() === 'x' || id === '*'
+
+// ~, ~> --> * (any, kinda silly)
+// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
+// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
+// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
+// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
+// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
+const replaceTildes = (comp, options) =>
+  comp.trim().split(/\s+/).map((c) => {
+    return replaceTilde(c, options)
+  }).join(' ')
+
+const replaceTilde = (comp, options) => {
+  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]
+  return comp.replace(r, (_, M, m, p, pr) => {
+    debug('tilde', comp, _, M, m, p, pr)
+    let ret
+
+    if (isX(M)) {
+      ret = ''
+    } else if (isX(m)) {
+      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`
+    } else if (isX(p)) {
+      // ~1.2 == >=1.2.0 <1.3.0-0
+      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`
+    } else if (pr) {
+      debug('replaceTilde pr', pr)
+      ret = `>=${M}.${m}.${p}-${pr
+      } <${M}.${+m + 1}.0-0`
+    } else {
+      // ~1.2.3 == >=1.2.3 <1.3.0-0
+      ret = `>=${M}.${m}.${p
+      } <${M}.${+m + 1}.0-0`
+    }
+
+    debug('tilde return', ret)
+    return ret
+  })
+}
+
+// ^ --> * (any, kinda silly)
+// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
+// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
+// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
+// ^1.2.3 --> >=1.2.3 <2.0.0-0
+// ^1.2.0 --> >=1.2.0 <2.0.0-0
+const replaceCarets = (comp, options) =>
+  comp.trim().split(/\s+/).map((c) => {
+    return replaceCaret(c, options)
+  }).join(' ')
+
+const replaceCaret = (comp, options) => {
+  debug('caret', comp, options)
+  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]
+  const z = options.includePrerelease ? '-0' : ''
+  return comp.replace(r, (_, M, m, p, pr) => {
+    debug('caret', comp, _, M, m, p, pr)
+    let ret
+
+    if (isX(M)) {
+      ret = ''
+    } else if (isX(m)) {
+      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`
+    } else if (isX(p)) {
+      if (M === '0') {
+        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`
+      } else {
+        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`
+      }
+    } else if (pr) {
+      debug('replaceCaret pr', pr)
+      if (M === '0') {
+        if (m === '0') {
+          ret = `>=${M}.${m}.${p}-${pr
+          } <${M}.${m}.${+p + 1}-0`
+        } else {
+          ret = `>=${M}.${m}.${p}-${pr
+          } <${M}.${+m + 1}.0-0`
+        }
+      } else {
+        ret = `>=${M}.${m}.${p}-${pr
+        } <${+M + 1}.0.0-0`
+      }
+    } else {
+      debug('no pr')
+      if (M === '0') {
+        if (m === '0') {
+          ret = `>=${M}.${m}.${p
+          }${z} <${M}.${m}.${+p + 1}-0`
+        } else {
+          ret = `>=${M}.${m}.${p
+          }${z} <${M}.${+m + 1}.0-0`
+        }
+      } else {
+        ret = `>=${M}.${m}.${p
+        } <${+M + 1}.0.0-0`
+      }
+    }
+
+    debug('caret return', ret)
+    return ret
+  })
+}
+
+const replaceXRanges = (comp, options) => {
+  debug('replaceXRanges', comp, options)
+  return comp.split(/\s+/).map((c) => {
+    return replaceXRange(c, options)
+  }).join(' ')
+}
+
+const replaceXRange = (comp, options) => {
+  comp = comp.trim()
+  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]
+  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+    debug('xRange', comp, ret, gtlt, M, m, p, pr)
+    const xM = isX(M)
+    const xm = xM || isX(m)
+    const xp = xm || isX(p)
+    const anyX = xp
+
+    if (gtlt === '=' && anyX) {
+      gtlt = ''
+    }
+
+    // if we're including prereleases in the match, then we need
+    // to fix this to -0, the lowest possible prerelease value
+    pr = options.includePrerelease ? '-0' : ''
+
+    if (xM) {
+      if (gtlt === '>' || gtlt === '<') {
+        // nothing is allowed
+        ret = '<0.0.0-0'
+      } else {
+        // nothing is forbidden
+        ret = '*'
+      }
+    } else if (gtlt && anyX) {
+      // we know patch is an x, because we have any x at all.
+      // replace X with 0
+      if (xm) {
+        m = 0
+      }
+      p = 0
+
+      if (gtlt === '>') {
+        // >1 => >=2.0.0
+        // >1.2 => >=1.3.0
+        gtlt = '>='
+        if (xm) {
+          M = +M + 1
+          m = 0
+          p = 0
+        } else {
+          m = +m + 1
+          p = 0
+        }
+      } else if (gtlt === '<=') {
+        // <=0.7.x is actually <0.8.0, since any 0.7.x should
+        // pass.  Similarly, <=7.x is actually <8.0.0, etc.
+        gtlt = '<'
+        if (xm) {
+          M = +M + 1
+        } else {
+          m = +m + 1
+        }
+      }
+
+      if (gtlt === '<') {
+        pr = '-0'
+      }
+
+      ret = `${gtlt + M}.${m}.${p}${pr}`
+    } else if (xm) {
+      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`
+    } else if (xp) {
+      ret = `>=${M}.${m}.0${pr
+      } <${M}.${+m + 1}.0-0`
+    }
+
+    debug('xRange return', ret)
+
+    return ret
+  })
+}
+
+// Because * is AND-ed with everything else in the comparator,
+// and '' means "any version", just remove the *s entirely.
+const replaceStars = (comp, options) => {
+  debug('replaceStars', comp, options)
+  // Looseness is ignored here.  star is always as loose as it gets!
+  return comp.trim().replace(re[t.STAR], '')
+}
+
+const replaceGTE0 = (comp, options) => {
+  debug('replaceGTE0', comp, options)
+  return comp.trim()
+    .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')
+}
+
+// This function is passed to string.replace(re[t.HYPHENRANGE])
+// M, m, patch, prerelease, build
+// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
+// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
+// 1.2 - 3.4 => >=1.2.0 <3.5.0-0
+const hyphenReplace = incPr => ($0,
+  from, fM, fm, fp, fpr, fb,
+  to, tM, tm, tp, tpr, tb) => {
+  if (isX(fM)) {
+    from = ''
+  } else if (isX(fm)) {
+    from = `>=${fM}.0.0${incPr ? '-0' : ''}`
+  } else if (isX(fp)) {
+    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`
+  } else if (fpr) {
+    from = `>=${from}`
+  } else {
+    from = `>=${from}${incPr ? '-0' : ''}`
+  }
+
+  if (isX(tM)) {
+    to = ''
+  } else if (isX(tm)) {
+    to = `<${+tM + 1}.0.0-0`
+  } else if (isX(tp)) {
+    to = `<${tM}.${+tm + 1}.0-0`
+  } else if (tpr) {
+    to = `<=${tM}.${tm}.${tp}-${tpr}`
+  } else if (incPr) {
+    to = `<${tM}.${tm}.${+tp + 1}-0`
+  } else {
+    to = `<=${to}`
+  }
+
+  return (`${from} ${to}`).trim()
+}
+
+const testSet = (set, version, options) => {
+  for (let i = 0; i < set.length; i++) {
+    if (!set[i].test(version)) {
+      return false
+    }
+  }
+
+  if (version.prerelease.length && !options.includePrerelease) {
+    // Find the set of versions that are allowed to have prereleases
+    // For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
+    // That should allow `1.2.3-pr.2` to pass.
+    // However, `1.2.4-alpha.notready` should NOT be allowed,
+    // even though it's within the range set by the comparators.
+    for (let i = 0; i < set.length; i++) {
+      debug(set[i].semver)
+      if (set[i].semver === Comparator.ANY) {
+        continue
+      }
+
+      if (set[i].semver.prerelease.length > 0) {
+        const allowed = set[i].semver
+        if (allowed.major === version.major &&
+            allowed.minor === version.minor &&
+            allowed.patch === version.patch) {
+          return true
+        }
+      }
+    }
+
+    // Version has a -pre, but it's not one of the ones we like.
+    return false
+  }
+
+  return true
+}

node_modules/css-loader/node_modules/semver/classes/semver.js

@@ -0,0 +1,287 @@
+const debug = require('../internal/debug')
+const { MAX_LENGTH, MAX_SAFE_INTEGER } = require('../internal/constants')
+const { re, t } = require('../internal/re')
+
+const parseOptions = require('../internal/parse-options')
+const { compareIdentifiers } = require('../internal/identifiers')
+class SemVer {
+  constructor (version, options) {
+    options = parseOptions(options)
+
+    if (version instanceof SemVer) {
+      if (version.loose === !!options.loose &&
+          version.includePrerelease === !!options.includePrerelease) {
+        return version
+      } else {
+        version = version.version
+      }
+    } else if (typeof version !== 'string') {
+      throw new TypeError(`Invalid Version: ${version}`)
+    }
+
+    if (version.length > MAX_LENGTH) {
+      throw new TypeError(
+        `version is longer than ${MAX_LENGTH} characters`
+      )
+    }
+
+    debug('SemVer', version, options)
+    this.options = options
+    this.loose = !!options.loose
+    // this isn't actually relevant for versions, but keep it so that we
+    // don't run into trouble passing this.options around.
+    this.includePrerelease = !!options.includePrerelease
+
+    const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])
+
+    if (!m) {
+      throw new TypeError(`Invalid Version: ${version}`)
+    }
+
+    this.raw = version
+
+    // these are actually numbers
+    this.major = +m[1]
+    this.minor = +m[2]
+    this.patch = +m[3]
+
+    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+      throw new TypeError('Invalid major version')
+    }
+
+    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+      throw new TypeError('Invalid minor version')
+    }
+
+    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+      throw new TypeError('Invalid patch version')
+    }
+
+    // numberify any prerelease numeric ids
+    if (!m[4]) {
+      this.prerelease = []
+    } else {
+      this.prerelease = m[4].split('.').map((id) => {
+        if (/^[0-9]+$/.test(id)) {
+          const num = +id
+          if (num >= 0 && num < MAX_SAFE_INTEGER) {
+            return num
+          }
+        }
+        return id
+      })
+    }
+
+    this.build = m[5] ? m[5].split('.') : []
+    this.format()
+  }
+
+  format () {
+    this.version = `${this.major}.${this.minor}.${this.patch}`
+    if (this.prerelease.length) {
+      this.version += `-${this.prerelease.join('.')}`
+    }
+    return this.version
+  }
+
+  toString () {
+    return this.version
+  }
+
+  compare (other) {
+    debug('SemVer.compare', this.version, this.options, other)
+    if (!(other instanceof SemVer)) {
+      if (typeof other === 'string' && other === this.version) {
+        return 0
+      }
+      other = new SemVer(other, this.options)
+    }
+
+    if (other.version === this.version) {
+      return 0
+    }
+
+    return this.compareMain(other) || this.comparePre(other)
+  }
+
+  compareMain (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options)
+    }
+
+    return (
+      compareIdentifiers(this.major, other.major) ||
+      compareIdentifiers(this.minor, other.minor) ||
+      compareIdentifiers(this.patch, other.patch)
+    )
+  }
+
+  comparePre (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options)
+    }
+
+    // NOT having a prerelease is > having one
+    if (this.prerelease.length && !other.prerelease.length) {
+      return -1
+    } else if (!this.prerelease.length && other.prerelease.length) {
+      return 1
+    } else if (!this.prerelease.length && !other.prerelease.length) {
+      return 0
+    }
+
+    let i = 0
+    do {
+      const a = this.prerelease[i]
+      const b = other.prerelease[i]
+      debug('prerelease compare', i, a, b)
+      if (a === undefined && b === undefined) {
+        return 0
+      } else if (b === undefined) {
+        return 1
+      } else if (a === undefined) {
+        return -1
+      } else if (a === b) {
+        continue
+      } else {
+        return compareIdentifiers(a, b)
+      }
+    } while (++i)
+  }
+
+  compareBuild (other) {
+    if (!(other instanceof SemVer)) {
+      other = new SemVer(other, this.options)
+    }
+
+    let i = 0
+    do {
+      const a = this.build[i]
+      const b = other.build[i]
+      debug('prerelease compare', i, a, b)
+      if (a === undefined && b === undefined) {
+        return 0
+      } else if (b === undefined) {
+        return 1
+      } else if (a === undefined) {
+        return -1
+      } else if (a === b) {
+        continue
+      } else {
+        return compareIdentifiers(a, b)
+      }
+    } while (++i)
+  }
+
+  // preminor will bump the version up to the next minor release, and immediately
+  // down to pre-release. premajor and prepatch work the same way.
+  inc (release, identifier) {
+    switch (release) {
+      case 'premajor':
+        this.prerelease.length = 0
+        this.patch = 0
+        this.minor = 0
+        this.major++
+        this.inc('pre', identifier)
+        break
+      case 'preminor':
+        this.prerelease.length = 0
+        this.patch = 0
+        this.minor++
+        this.inc('pre', identifier)
+        break
+      case 'prepatch':
+        // If this is already a prerelease, it will bump to the next version
+        // drop any prereleases that might already exist, since they are not
+        // relevant at this point.
+        this.prerelease.length = 0
+        this.inc('patch', identifier)
+        this.inc('pre', identifier)
+        break
+      // If the input is a non-prerelease version, this acts the same as
+      // prepatch.
+      case 'prerelease':
+        if (this.prerelease.length === 0) {
+          this.inc('patch', identifier)
+        }
+        this.inc('pre', identifier)
+        break
+
+      case 'major':
+        // If this is a pre-major version, bump up to the same major version.
+        // Otherwise increment major.
+        // 1.0.0-5 bumps to 1.0.0
+        // 1.1.0 bumps to 2.0.0
+        if (
+          this.minor !== 0 ||
+          this.patch !== 0 ||
+          this.prerelease.length === 0
+        ) {
+          this.major++
+        }
+        this.minor = 0
+        this.patch = 0
+        this.prerelease = []
+        break
+      case 'minor':
+        // If this is a pre-minor version, bump up to the same minor version.
+        // Otherwise increment minor.
+        // 1.2.0-5 bumps to 1.2.0
+        // 1.2.1 bumps to 1.3.0
+        if (this.patch !== 0 || this.prerelease.length === 0) {
+          this.minor++
+        }
+        this.patch = 0
+        this.prerelease = []
+        break
+      case 'patch':
+        // If this is not a pre-release version, it will increment the patch.
+        // If it is a pre-release it will bump up to the same patch version.
+        // 1.2.0-5 patches to 1.2.0
+        // 1.2.0 patches to 1.2.1
+        if (this.prerelease.length === 0) {
+          this.patch++
+        }
+        this.prerelease = []
+        break
+      // This probably shouldn't be used publicly.
+      // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+      case 'pre':
+        if (this.prerelease.length === 0) {
+          this.prerelease = [0]
+        } else {
+          let i = this.prerelease.length
+          while (--i >= 0) {
+            if (typeof this.prerelease[i] === 'number') {
+              this.prerelease[i]++
+              i = -2
+            }
+          }
+          if (i === -1) {
+            // didn't increment anything
+            this.prerelease.push(0)
+          }
+        }
+        if (identifier) {
+          // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+          // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+            if (isNaN(this.prerelease[1])) {
+              this.prerelease = [identifier, 0]
+            }
+          } else {
+            this.prerelease = [identifier, 0]
+          }
+        }
+        break
+
+      default:
+        throw new Error(`invalid increment argument: ${release}`)
+    }
+    this.format()
+    this.raw = this.version
+    return this
+  }
+}
+
+module.exports = SemVer

node_modules/css-loader/node_modules/semver/functions/clean.js

@@ -0,0 +1,6 @@
+const parse = require('./parse')
+const clean = (version, options) => {
+  const s = parse(version.trim().replace(/^[=v]+/, ''), options)
+  return s ? s.version : null
+}
+module.exports = clean

node_modules/css-loader/node_modules/semver/functions/cmp.js

@@ -0,0 +1,52 @@
+const eq = require('./eq')
+const neq = require('./neq')
+const gt = require('./gt')
+const gte = require('./gte')
+const lt = require('./lt')
+const lte = require('./lte')
+
+const cmp = (a, op, b, loose) => {
+  switch (op) {
+    case '===':
+      if (typeof a === 'object') {
+        a = a.version
+      }
+      if (typeof b === 'object') {
+        b = b.version
+      }
+      return a === b
+
+    case '!==':
+      if (typeof a === 'object') {
+        a = a.version
+      }
+      if (typeof b === 'object') {
+        b = b.version
+      }
+      return a !== b
+
+    case '':
+    case '=':
+    case '==':
+      return eq(a, b, loose)
+
+    case '!=':
+      return neq(a, b, loose)
+
+    case '>':
+      return gt(a, b, loose)
+
+    case '>=':
+      return gte(a, b, loose)
+
+    case '<':
+      return lt(a, b, loose)
+
+    case '<=':
+      return lte(a, b, loose)
+
+    default:
+      throw new TypeError(`Invalid operator: ${op}`)
+  }
+}
+module.exports = cmp

node_modules/css-loader/node_modules/semver/functions/coerce.js

@@ -0,0 +1,52 @@
+const SemVer = require('../classes/semver')
+const parse = require('./parse')
+const { re, t } = require('../internal/re')
+
+const coerce = (version, options) => {
+  if (version instanceof SemVer) {
+    return version
+  }
+
+  if (typeof version === 'number') {
+    version = String(version)
+  }
+
+  if (typeof version !== 'string') {
+    return null
+  }
+
+  options = options || {}
+
+  let match = null
+  if (!options.rtl) {
+    match = version.match(re[t.COERCE])
+  } else {
+    // Find the right-most coercible string that does not share
+    // a terminus with a more left-ward coercible string.
+    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
+    //
+    // Walk through the string checking with a /g regexp
+    // Manually set the index so as to pick up overlapping matches.
+    // Stop when we get a match that ends at the string end, since no
+    // coercible string can be more right-ward without the same terminus.
+    let next
+    while ((next = re[t.COERCERTL].exec(version)) &&
+        (!match || match.index + match[0].length !== version.length)
+    ) {
+      if (!match ||
+            next.index + next[0].length !== match.index + match[0].length) {
+        match = next
+      }
+      re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length
+    }
+    // leave it in a clean state
+    re[t.COERCERTL].lastIndex = -1
+  }
+
+  if (match === null) {
+    return null
+  }
+
+  return parse(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options)
+}
+module.exports = coerce

node_modules/css-loader/node_modules/semver/functions/compare-build.js

@@ -0,0 +1,7 @@
+const SemVer = require('../classes/semver')
+const compareBuild = (a, b, loose) => {
+  const versionA = new SemVer(a, loose)
+  const versionB = new SemVer(b, loose)
+  return versionA.compare(versionB) || versionA.compareBuild(versionB)
+}
+module.exports = compareBuild

node_modules/css-loader/node_modules/semver/functions/compare-loose.js

@@ -0,0 +1,3 @@
+const compare = require('./compare')
+const compareLoose = (a, b) => compare(a, b, true)
+module.exports = compareLoose

node_modules/css-loader/node_modules/semver/functions/compare.js

@@ -0,0 +1,5 @@
+const SemVer = require('../classes/semver')
+const compare = (a, b, loose) =>
+  new SemVer(a, loose).compare(new SemVer(b, loose))
+
+module.exports = compare

node_modules/css-loader/node_modules/semver/functions/diff.js

@@ -0,0 +1,23 @@
+const parse = require('./parse')
+const eq = require('./eq')
+
+const diff = (version1, version2) => {
+  if (eq(version1, version2)) {
+    return null
+  } else {
+    const v1 = parse(version1)
+    const v2 = parse(version2)
+    const hasPre = v1.prerelease.length || v2.prerelease.length
+    const prefix = hasPre ? 'pre' : ''
+    const defaultResult = hasPre ? 'prerelease' : ''
+    for (const key in v1) {
+      if (key === 'major' || key === 'minor' || key === 'patch') {
+        if (v1[key] !== v2[key]) {
+          return prefix + key
+        }
+      }
+    }
+    return defaultResult // may be undefined
+  }
+}
+module.exports = diff

node_modules/css-loader/node_modules/semver/functions/eq.js

@@ -0,0 +1,3 @@
+const compare = require('./compare')
+const eq = (a, b, loose) => compare(a, b, loose) === 0
+module.exports = eq

node_modules/css-loader/node_modules/semver/functions/gt.js

@@ -0,0 +1,3 @@
+const compare = require('./compare')
+const gt = (a, b, loose) => compare(a, b, loose) > 0
+module.exports = gt

node_modules/css-loader/node_modules/semver/functions/gte.js

@@ -0,0 +1,3 @@
+const compare = require('./compare')
+const gte = (a, b, loose) => compare(a, b, loose) >= 0
+module.exports = gte

node_modules/css-loader/node_modules/semver/functions/inc.js

@@ -0,0 +1,18 @@
+const SemVer = require('../classes/semver')
+
+const inc = (version, release, options, identifier) => {
+  if (typeof (options) === 'string') {
+    identifier = options
+    options = undefined
+  }
+
+  try {
+    return new SemVer(
+      version instanceof SemVer ? version.version : version,
+      options
+    ).inc(release, identifier).version
+  } catch (er) {
+    return null
+  }
+}
+module.exports = inc

node_modules/css-loader/node_modules/semver/functions/lt.js

@@ -0,0 +1,3 @@
+const compare = require('./compare')
+const lt = (a, b, loose) => compare(a, b, loose) < 0
+module.exports = lt

node_modules/css-loader/node_modules/semver/functions/lte.js

@@ -0,0 +1,3 @@
+const compare = require('./compare')
+const lte = (a, b, loose) => compare(a, b, loose) <= 0
+module.exports = lte

node_modules/css-loader/node_modules/semver/functions/major.js

@@ -0,0 +1,3 @@
+const SemVer = require('../classes/semver')
+const major = (a, loose) => new SemVer(a, loose).major
+module.exports = major

node_modules/css-loader/node_modules/semver/functions/minor.js

@@ -0,0 +1,3 @@
+const SemVer = require('../classes/semver')
+const minor = (a, loose) => new SemVer(a, loose).minor
+module.exports = minor

node_modules/css-loader/node_modules/semver/functions/neq.js

@@ -0,0 +1,3 @@
+const compare = require('./compare')
+const neq = (a, b, loose) => compare(a, b, loose) !== 0
+module.exports = neq

node_modules/css-loader/node_modules/semver/functions/parse.js

@@ -0,0 +1,33 @@
+const { MAX_LENGTH } = require('../internal/constants')
+const { re, t } = require('../internal/re')
+const SemVer = require('../classes/semver')
+
+const parseOptions = require('../internal/parse-options')
+const parse = (version, options) => {
+  options = parseOptions(options)
+
+  if (version instanceof SemVer) {
+    return version
+  }
+
+  if (typeof version !== 'string') {
+    return null
+  }
+
+  if (version.length > MAX_LENGTH) {
+    return null
+  }
+
+  const r = options.loose ? re[t.LOOSE] : re[t.FULL]
+  if (!r.test(version)) {
+    return null
+  }
+
+  try {
+    return new SemVer(version, options)
+  } catch (er) {
+    return null
+  }
+}
+
+module.exports = parse

node_modules/css-loader/node_modules/semver/functions/patch.js

@@ -0,0 +1,3 @@
+const SemVer = require('../classes/semver')
+const patch = (a, loose) => new SemVer(a, loose).patch
+module.exports = patch

node_modules/css-loader/node_modules/semver/functions/prerelease.js

@@ -0,0 +1,6 @@
+const parse = require('./parse')
+const prerelease = (version, options) => {
+  const parsed = parse(version, options)
+  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
+}
+module.exports = prerelease

node_modules/css-loader/node_modules/semver/functions/rcompare.js

@@ -0,0 +1,3 @@
+const compare = require('./compare')
+const rcompare = (a, b, loose) => compare(b, a, loose)
+module.exports = rcompare

node_modules/css-loader/node_modules/semver/functions/rsort.js

@@ -0,0 +1,3 @@
+const compareBuild = require('./compare-build')
+const rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose))
+module.exports = rsort

node_modules/css-loader/node_modules/semver/functions/satisfies.js

@@ -0,0 +1,10 @@
+const Range = require('../classes/range')
+const satisfies = (version, range, options) => {
+  try {
+    range = new Range(range, options)
+  } catch (er) {
+    return false
+  }
+  return range.test(version)
+}
+module.exports = satisfies

node_modules/css-loader/node_modules/semver/functions/sort.js

@@ -0,0 +1,3 @@
+const compareBuild = require('./compare-build')
+const sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose))
+module.exports = sort

node_modules/css-loader/node_modules/semver/functions/valid.js

@@ -0,0 +1,6 @@
+const parse = require('./parse')
+const valid = (version, options) => {
+  const v = parse(version, options)
+  return v ? v.version : null
+}
+module.exports = valid

node_modules/css-loader/node_modules/semver/index.js

@@ -0,0 +1,48 @@
+// just pre-load all the stuff that index.js lazily exports
+const internalRe = require('./internal/re')
+module.exports = {
+  re: internalRe.re,
+  src: internalRe.src,
+  tokens: internalRe.t,
+  SEMVER_SPEC_VERSION: require('./internal/constants').SEMVER_SPEC_VERSION,
+  SemVer: require('./classes/semver'),
+  compareIdentifiers: require('./internal/identifiers').compareIdentifiers,
+  rcompareIdentifiers: require('./internal/identifiers').rcompareIdentifiers,
+  parse: require('./functions/parse'),
+  valid: require('./functions/valid'),
+  clean: require('./functions/clean'),
+  inc: require('./functions/inc'),
+  diff: require('./functions/diff'),
+  major: require('./functions/major'),
+  minor: require('./functions/minor'),
+  patch: require('./functions/patch'),
+  prerelease: require('./functions/prerelease'),
+  compare: require('./functions/compare'),
+  rcompare: require('./functions/rcompare'),
+  compareLoose: require('./functions/compare-loose'),
+  compareBuild: require('./functions/compare-build'),
+  sort: require('./functions/sort'),
+  rsort: require('./functions/rsort'),
+  gt: require('./functions/gt'),
+  lt: require('./functions/lt'),
+  eq: require('./functions/eq'),
+  neq: require('./functions/neq'),
+  gte: require('./functions/gte'),
+  lte: require('./functions/lte'),
+  cmp: require('./functions/cmp'),
+  coerce: require('./functions/coerce'),
+  Comparator: require('./classes/comparator'),
+  Range: require('./classes/range'),
+  satisfies: require('./functions/satisfies'),
+  toComparators: require('./ranges/to-comparators'),
+  maxSatisfying: require('./ranges/max-satisfying'),
+  minSatisfying: require('./ranges/min-satisfying'),
+  minVersion: require('./ranges/min-version'),
+  validRange: require('./ranges/valid'),
+  outside: require('./ranges/outside'),
+  gtr: require('./ranges/gtr'),
+  ltr: require('./ranges/ltr'),
+  intersects: require('./ranges/intersects'),
+  simplifyRange: require('./ranges/simplify'),
+  subset: require('./ranges/subset'),
+}

node_modules/css-loader/node_modules/semver/internal/constants.js

@@ -0,0 +1,17 @@
+// Note: this is the semver.org version of the spec that it implements
+// Not necessarily the package version of this code.
+const SEMVER_SPEC_VERSION = '2.0.0'
+
+const MAX_LENGTH = 256
+const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER ||
+/* istanbul ignore next */ 9007199254740991
+
+// Max safe segment length for coercion.
+const MAX_SAFE_COMPONENT_LENGTH = 16
+
+module.exports = {
+  SEMVER_SPEC_VERSION,
+  MAX_LENGTH,
+  MAX_SAFE_INTEGER,
+  MAX_SAFE_COMPONENT_LENGTH,
+}

node_modules/css-loader/node_modules/semver/internal/debug.js

@@ -0,0 +1,9 @@
+const debug = (
+  typeof process === 'object' &&
+  process.env &&
+  process.env.NODE_DEBUG &&
+  /\bsemver\b/i.test(process.env.NODE_DEBUG)
+) ? (...args) => console.error('SEMVER', ...args)
+  : () => {}
+
+module.exports = debug

node_modules/css-loader/node_modules/semver/internal/identifiers.js

@@ -0,0 +1,23 @@
+const numeric = /^[0-9]+$/
+const compareIdentifiers = (a, b) => {
+  const anum = numeric.test(a)
+  const bnum = numeric.test(b)
+
+  if (anum && bnum) {
+    a = +a
+    b = +b
+  }
+
+  return a === b ? 0
+    : (anum && !bnum) ? -1
+    : (bnum && !anum) ? 1
+    : a < b ? -1
+    : 1
+}
+
+const rcompareIdentifiers = (a, b) => compareIdentifiers(b, a)
+
+module.exports = {
+  compareIdentifiers,
+  rcompareIdentifiers,
+}

node_modules/css-loader/node_modules/semver/internal/parse-options.js

@@ -0,0 +1,11 @@
+// parse out just the options we care about so we always get a consistent
+// obj with keys in a consistent order.
+const opts = ['includePrerelease', 'loose', 'rtl']
+const parseOptions = options =>
+  !options ? {}
+  : typeof options !== 'object' ? { loose: true }
+  : opts.filter(k => options[k]).reduce((o, k) => {
+    o[k] = true
+    return o
+  }, {})
+module.exports = parseOptions

node_modules/css-loader/node_modules/semver/internal/re.js

@@ -0,0 +1,182 @@
+const { MAX_SAFE_COMPONENT_LENGTH } = require('./constants')
+const debug = require('./debug')
+exports = module.exports = {}
+
+// The actual regexps go on exports.re
+const re = exports.re = []
+const src = exports.src = []
+const t = exports.t = {}
+let R = 0
+
+const createToken = (name, value, isGlobal) => {
+  const index = R++
+  debug(name, index, value)
+  t[name] = index
+  src[index] = value
+  re[index] = new RegExp(value, isGlobal ? 'g' : undefined)
+}
+
+// The following Regular Expressions can be used for tokenizing,
+// validating, and parsing SemVer version strings.
+
+// ## Numeric Identifier
+// A single `0`, or a non-zero digit followed by zero or more digits.
+
+createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*')
+createToken('NUMERICIDENTIFIERLOOSE', '[0-9]+')
+
+// ## Non-numeric Identifier
+// Zero or more digits, followed by a letter or hyphen, and then zero or
+// more letters, digits, or hyphens.
+
+createToken('NONNUMERICIDENTIFIER', '\\d*[a-zA-Z-][a-zA-Z0-9-]*')
+
+// ## Main Version
+// Three dot-separated numeric identifiers.
+
+createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` +
+                   `(${src[t.NUMERICIDENTIFIER]})\\.` +
+                   `(${src[t.NUMERICIDENTIFIER]})`)
+
+createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
+                        `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
+                        `(${src[t.NUMERICIDENTIFIERLOOSE]})`)
+
+// ## Pre-release Version Identifier
+// A numeric identifier, or a non-numeric identifier.
+
+createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]
+}|${src[t.NONNUMERICIDENTIFIER]})`)
+
+createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]
+}|${src[t.NONNUMERICIDENTIFIER]})`)
+
+// ## Pre-release Version
+// Hyphen, followed by one or more dot-separated pre-release version
+// identifiers.
+
+createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]
+}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`)
+
+createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]
+}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`)
+
+// ## Build Metadata Identifier
+// Any combination of digits, letters, or hyphens.
+
+createToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+')
+
+// ## Build Metadata
+// Plus sign, followed by one or more period-separated build metadata
+// identifiers.
+
+createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]
+}(?:\\.${src[t.BUILDIDENTIFIER]})*))`)
+
+// ## Full Version String
+// A main version, followed optionally by a pre-release version and
+// build metadata.
+
+// Note that the only major, minor, patch, and pre-release sections of
+// the version string are capturing groups.  The build metadata is not a
+// capturing group, because it should not ever be used in version
+// comparison.
+
+createToken('FULLPLAIN', `v?${src[t.MAINVERSION]
+}${src[t.PRERELEASE]}?${
+  src[t.BUILD]}?`)
+
+createToken('FULL', `^${src[t.FULLPLAIN]}$`)
+
+// like full, but allows v1.2.3 and =1.2.3, which people do sometimes.
+// also, 1.0.0alpha1 (prerelease without the hyphen) which is pretty
+// common in the npm registry.
+createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]
+}${src[t.PRERELEASELOOSE]}?${
+  src[t.BUILD]}?`)
+
+createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`)
+
+createToken('GTLT', '((?:<|>)?=?)')
+
+// Something like "2.*" or "1.2.x".
+// Note that "x.x" is a valid xRange identifer, meaning "any version"
+// Only the first item is strictly required.
+createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`)
+createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`)
+
+createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` +
+                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
+                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
+                   `(?:${src[t.PRERELEASE]})?${
+                     src[t.BUILD]}?` +
+                   `)?)?`)
+
+createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
+                        `(?:${src[t.PRERELEASELOOSE]})?${
+                          src[t.BUILD]}?` +
+                        `)?)?`)
+
+createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`)
+createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`)
+
+// Coercion.
+// Extract anything that could conceivably be a part of a valid semver
+createToken('COERCE', `${'(^|[^\\d])' +
+              '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
+              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
+              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
+              `(?:$|[^\\d])`)
+createToken('COERCERTL', src[t.COERCE], true)
+
+// Tilde ranges.
+// Meaning is "reasonably at or greater than"
+createToken('LONETILDE', '(?:~>?)')
+
+createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true)
+exports.tildeTrimReplace = '$1~'
+
+createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`)
+createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`)
+
+// Caret ranges.
+// Meaning is "at least and backwards compatible with"
+createToken('LONECARET', '(?:\\^)')
+
+createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true)
+exports.caretTrimReplace = '$1^'
+
+createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`)
+createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`)
+
+// A simple gt/lt/eq thing, or just "" to indicate "any version"
+createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`)
+createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`)
+
+// An expression to strip any whitespace between the gtlt and the thing
+// it modifies, so that `> 1.2.3` ==> `>1.2.3`
+createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
+}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true)
+exports.comparatorTrimReplace = '$1$2$3'
+
+// Something like `1.2.3 - 1.2.4`
+// Note that these all use the loose form, because they'll be
+// checked against either the strict or loose comparator form
+// later.
+createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` +
+                   `\\s+-\\s+` +
+                   `(${src[t.XRANGEPLAIN]})` +
+                   `\\s*$`)
+
+createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
+                        `\\s+-\\s+` +
+                        `(${src[t.XRANGEPLAINLOOSE]})` +
+                        `\\s*$`)
+
+// Star ranges basically just allow anything at all.
+createToken('STAR', '(<|>)?=?\\s*\\*')
+// >=0.0.0 is like a star
+createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$')
+createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$')

node_modules/css-loader/node_modules/semver/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "semver",
+  "version": "7.3.7",
+  "description": "The semantic version parser used by npm.",
+  "main": "index.js",
+  "scripts": {
+    "test": "tap",
+    "snap": "tap",
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "postpublish": "git push origin --follow-tags",
+    "lint": "eslint \"**/*.js\"",
+    "postlint": "template-oss-check",
+    "lintfix": "npm run lint -- --fix",
+    "prepublishOnly": "git push origin --follow-tags",
+    "posttest": "npm run lint",
+    "template-oss-apply": "template-oss-apply --force"
+  },
+  "devDependencies": {
+    "@npmcli/eslint-config": "^3.0.1",
+    "@npmcli/template-oss": "3.3.2",
+    "tap": "^16.0.0"
+  },
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/npm/node-semver.git"
+  },
+  "bin": {
+    "semver": "bin/semver.js"
+  },
+  "files": [
+    "bin/",
+    "classes/",
+    "functions/",
+    "internal/",
+    "ranges/",
+    "index.js",
+    "preload.js",
+    "range.bnf"
+  ],
+  "tap": {
+    "check-coverage": true,
+    "coverage-map": "map.js"
+  },
+  "engines": {
+    "node": ">=10"
+  },
+  "dependencies": {
+    "lru-cache": "^6.0.0"
+  },
+  "author": "GitHub Inc.",
+  "templateOSS": {
+    "//@npmcli/template-oss": "This file is partially managed by @npmcli/template-oss. Edits may be overwritten.",
+    "version": "3.3.2",
+    "engines": ">=10",
+    "ciVersions": [
+      "10.0.0",
+      "10.x",
+      "12.x",
+      "14.x",
+      "16.x"
+    ],
+    "distPaths": [
+      "bin/",
+      "classes/",
+      "functions/",
+      "internal/",
+      "ranges/",
+      "index.js",
+      "preload.js",
+      "range.bnf"
+    ]
+  }
+}

node_modules/css-loader/node_modules/semver/preload.js

@@ -0,0 +1,2 @@
+// XXX remove in v8 or beyond
+module.exports = require('./index.js')

node_modules/css-loader/node_modules/semver/range.bnf

@@ -0,0 +1,16 @@
+range-set  ::= range ( logical-or range ) *
+logical-or ::= ( ' ' ) * '||' ( ' ' ) *
+range      ::= hyphen | simple ( ' ' simple ) * | ''
+hyphen     ::= partial ' - ' partial
+simple     ::= primitive | partial | tilde | caret
+primitive  ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
+partial    ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
+xr         ::= 'x' | 'X' | '*' | nr
+nr         ::= '0' | [1-9] ( [0-9] ) *
+tilde      ::= '~' partial
+caret      ::= '^' partial
+qualifier  ::= ( '-' pre )? ( '+' build )?
+pre        ::= parts
+build      ::= parts
+parts      ::= part ( '.' part ) *
+part       ::= nr | [-0-9A-Za-z]+

node_modules/css-loader/node_modules/semver/ranges/gtr.js

@@ -0,0 +1,4 @@
+// Determine if version is greater than all the versions possible in the range.
+const outside = require('./outside')
+const gtr = (version, range, options) => outside(version, range, '>', options)
+module.exports = gtr

node_modules/css-loader/node_modules/semver/ranges/intersects.js

@@ -0,0 +1,7 @@
+const Range = require('../classes/range')
+const intersects = (r1, r2, options) => {
+  r1 = new Range(r1, options)
+  r2 = new Range(r2, options)
+  return r1.intersects(r2)
+}
+module.exports = intersects

node_modules/css-loader/node_modules/semver/ranges/ltr.js

@@ -0,0 +1,4 @@
+const outside = require('./outside')
+// Determine if version is less than all the versions possible in the range
+const ltr = (version, range, options) => outside(version, range, '<', options)
+module.exports = ltr

node_modules/css-loader/node_modules/semver/ranges/max-satisfying.js

@@ -0,0 +1,25 @@
+const SemVer = require('../classes/semver')
+const Range = require('../classes/range')
+
+const maxSatisfying = (versions, range, options) => {
+  let max = null
+  let maxSV = null
+  let rangeObj = null
+  try {
+    rangeObj = new Range(range, options)
+  } catch (er) {
+    return null
+  }
+  versions.forEach((v) => {
+    if (rangeObj.test(v)) {
+      // satisfies(v, range, options)
+      if (!max || maxSV.compare(v) === -1) {
+        // compare(max, v, true)
+        max = v
+        maxSV = new SemVer(max, options)
+      }
+    }
+  })
+  return max
+}
+module.exports = maxSatisfying

node_modules/css-loader/node_modules/semver/ranges/min-satisfying.js

@@ -0,0 +1,24 @@
+const SemVer = require('../classes/semver')
+const Range = require('../classes/range')
+const minSatisfying = (versions, range, options) => {
+  let min = null
+  let minSV = null
+  let rangeObj = null
+  try {
+    rangeObj = new Range(range, options)
+  } catch (er) {
+    return null
+  }
+  versions.forEach((v) => {
+    if (rangeObj.test(v)) {
+      // satisfies(v, range, options)
+      if (!min || minSV.compare(v) === 1) {
+        // compare(min, v, true)
+        min = v
+        minSV = new SemVer(min, options)
+      }
+    }
+  })
+  return min
+}
+module.exports = minSatisfying

node_modules/css-loader/node_modules/semver/ranges/min-version.js

@@ -0,0 +1,61 @@
+const SemVer = require('../classes/semver')
+const Range = require('../classes/range')
+const gt = require('../functions/gt')
+
+const minVersion = (range, loose) => {
+  range = new Range(range, loose)
+
+  let minver = new SemVer('0.0.0')
+  if (range.test(minver)) {
+    return minver
+  }
+
+  minver = new SemVer('0.0.0-0')
+  if (range.test(minver)) {
+    return minver
+  }
+
+  minver = null
+  for (let i = 0; i < range.set.length; ++i) {
+    const comparators = range.set[i]
+
+    let setMin = null
+    comparators.forEach((comparator) => {
+      // Clone to avoid manipulating the comparator's semver object.
+      const compver = new SemVer(comparator.semver.version)
+      switch (comparator.operator) {
+        case '>':
+          if (compver.prerelease.length === 0) {
+            compver.patch++
+          } else {
+            compver.prerelease.push(0)
+          }
+          compver.raw = compver.format()
+          /* fallthrough */
+        case '':
+        case '>=':
+          if (!setMin || gt(compver, setMin)) {
+            setMin = compver
+          }
+          break
+        case '<':
+        case '<=':
+          /* Ignore maximum versions */
+          break
+        /* istanbul ignore next */
+        default:
+          throw new Error(`Unexpected operation: ${comparator.operator}`)
+      }
+    })
+    if (setMin && (!minver || gt(minver, setMin))) {
+      minver = setMin
+    }
+  }
+
+  if (minver && range.test(minver)) {
+    return minver
+  }
+
+  return null
+}
+module.exports = minVersion

node_modules/css-loader/node_modules/semver/ranges/outside.js

@@ -0,0 +1,80 @@
+const SemVer = require('../classes/semver')
+const Comparator = require('../classes/comparator')
+const { ANY } = Comparator
+const Range = require('../classes/range')
+const satisfies = require('../functions/satisfies')
+const gt = require('../functions/gt')
+const lt = require('../functions/lt')
+const lte = require('../functions/lte')
+const gte = require('../functions/gte')
+
+const outside = (version, range, hilo, options) => {
+  version = new SemVer(version, options)
+  range = new Range(range, options)
+
+  let gtfn, ltefn, ltfn, comp, ecomp
+  switch (hilo) {
+    case '>':
+      gtfn = gt
+      ltefn = lte
+      ltfn = lt
+      comp = '>'
+      ecomp = '>='
+      break
+    case '<':
+      gtfn = lt
+      ltefn = gte
+      ltfn = gt
+      comp = '<'
+      ecomp = '<='
+      break
+    default:
+      throw new TypeError('Must provide a hilo val of "<" or ">"')
+  }
+
+  // If it satisfies the range it is not outside
+  if (satisfies(version, range, options)) {
+    return false
+  }
+
+  // From now on, variable terms are as if we're in "gtr" mode.
+  // but note that everything is flipped for the "ltr" function.
+
+  for (let i = 0; i < range.set.length; ++i) {
+    const comparators = range.set[i]
+
+    let high = null
+    let low = null
+
+    comparators.forEach((comparator) => {
+      if (comparator.semver === ANY) {
+        comparator = new Comparator('>=0.0.0')
+      }
+      high = high || comparator
+      low = low || comparator
+      if (gtfn(comparator.semver, high.semver, options)) {
+        high = comparator
+      } else if (ltfn(comparator.semver, low.semver, options)) {
+        low = comparator
+      }
+    })
+
+    // If the edge version comparator has a operator then our version
+    // isn't outside it
+    if (high.operator === comp || high.operator === ecomp) {
+      return false
+    }
+
+    // If the lowest version comparator has an operator and our version
+    // is less than it then it isn't higher than the range
+    if ((!low.operator || low.operator === comp) &&
+        ltefn(version, low.semver)) {
+      return false
+    } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+      return false
+    }
+  }
+  return true
+}
+
+module.exports = outside

node_modules/css-loader/node_modules/semver/ranges/simplify.js

@@ -0,0 +1,47 @@
+// given a set of versions and a range, create a "simplified" range
+// that includes the same versions that the original range does
+// If the original range is shorter than the simplified one, return that.
+const satisfies = require('../functions/satisfies.js')
+const compare = require('../functions/compare.js')
+module.exports = (versions, range, options) => {
+  const set = []
+  let first = null
+  let prev = null
+  const v = versions.sort((a, b) => compare(a, b, options))
+  for (const version of v) {
+    const included = satisfies(version, range, options)
+    if (included) {
+      prev = version
+      if (!first) {
+        first = version
+      }
+    } else {
+      if (prev) {
+        set.push([first, prev])
+      }
+      prev = null
+      first = null
+    }
+  }
+  if (first) {
+    set.push([first, null])
+  }
+
+  const ranges = []
+  for (const [min, max] of set) {
+    if (min === max) {
+      ranges.push(min)
+    } else if (!max && min === v[0]) {
+      ranges.push('*')
+    } else if (!max) {
+      ranges.push(`>=${min}`)
+    } else if (min === v[0]) {
+      ranges.push(`<=${max}`)
+    } else {
+      ranges.push(`${min} - ${max}`)
+    }
+  }
+  const simplified = ranges.join(' || ')
+  const original = typeof range.raw === 'string' ? range.raw : String(range)
+  return simplified.length < original.length ? simplified : range
+}

node_modules/css-loader/node_modules/semver/ranges/subset.js

@@ -0,0 +1,244 @@
+const Range = require('../classes/range.js')
+const Comparator = require('../classes/comparator.js')
+const { ANY } = Comparator
+const satisfies = require('../functions/satisfies.js')
+const compare = require('../functions/compare.js')
+
+// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:
+// - Every simple range `r1, r2, ...` is a null set, OR
+// - Every simple range `r1, r2, ...` which is not a null set is a subset of
+//   some `R1, R2, ...`
+//
+// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:
+// - If c is only the ANY comparator
+//   - If C is only the ANY comparator, return true
+//   - Else if in prerelease mode, return false
+//   - else replace c with `[>=0.0.0]`
+// - If C is only the ANY comparator
+//   - if in prerelease mode, return true
+//   - else replace C with `[>=0.0.0]`
+// - Let EQ be the set of = comparators in c
+// - If EQ is more than one, return true (null set)
+// - Let GT be the highest > or >= comparator in c
+// - Let LT be the lowest < or <= comparator in c
+// - If GT and LT, and GT.semver > LT.semver, return true (null set)
+// - If any C is a = range, and GT or LT are set, return false
+// - If EQ
+//   - If GT, and EQ does not satisfy GT, return true (null set)
+//   - If LT, and EQ does not satisfy LT, return true (null set)
+//   - If EQ satisfies every C, return true
+//   - Else return false
+// - If GT
+//   - If GT.semver is lower than any > or >= comp in C, return false
+//   - If GT is >=, and GT.semver does not satisfy every C, return false
+//   - If GT.semver has a prerelease, and not in prerelease mode
+//     - If no C has a prerelease and the GT.semver tuple, return false
+// - If LT
+//   - If LT.semver is greater than any < or <= comp in C, return false
+//   - If LT is <=, and LT.semver does not satisfy every C, return false
+//   - If GT.semver has a prerelease, and not in prerelease mode
+//     - If no C has a prerelease and the LT.semver tuple, return false
+// - Else return true
+
+const subset = (sub, dom, options = {}) => {
+  if (sub === dom) {
+    return true
+  }
+
+  sub = new Range(sub, options)
+  dom = new Range(dom, options)
+  let sawNonNull = false
+
+  OUTER: for (const simpleSub of sub.set) {
+    for (const simpleDom of dom.set) {
+      const isSub = simpleSubset(simpleSub, simpleDom, options)
+      sawNonNull = sawNonNull || isSub !== null
+      if (isSub) {
+        continue OUTER
+      }
+    }
+    // the null set is a subset of everything, but null simple ranges in
+    // a complex range should be ignored.  so if we saw a non-null range,
+    // then we know this isn't a subset, but if EVERY simple range was null,
+    // then it is a subset.
+    if (sawNonNull) {
+      return false
+    }
+  }
+  return true
+}
+
+const simpleSubset = (sub, dom, options) => {
+  if (sub === dom) {
+    return true
+  }
+
+  if (sub.length === 1 && sub[0].semver === ANY) {
+    if (dom.length === 1 && dom[0].semver === ANY) {
+      return true
+    } else if (options.includePrerelease) {
+      sub = [new Comparator('>=0.0.0-0')]
+    } else {
+      sub = [new Comparator('>=0.0.0')]
+    }
+  }
+
+  if (dom.length === 1 && dom[0].semver === ANY) {
+    if (options.includePrerelease) {
+      return true
+    } else {
+      dom = [new Comparator('>=0.0.0')]
+    }
+  }
+
+  const eqSet = new Set()
+  let gt, lt
+  for (const c of sub) {
+    if (c.operator === '>' || c.operator === '>=') {
+      gt = higherGT(gt, c, options)
+    } else if (c.operator === '<' || c.operator === '<=') {
+      lt = lowerLT(lt, c, options)
+    } else {
+      eqSet.add(c.semver)
+    }
+  }
+
+  if (eqSet.size > 1) {
+    return null
+  }
+
+  let gtltComp
+  if (gt && lt) {
+    gtltComp = compare(gt.semver, lt.semver, options)
+    if (gtltComp > 0) {
+      return null
+    } else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) {
+      return null
+    }
+  }
+
+  // will iterate one or zero times
+  for (const eq of eqSet) {
+    if (gt && !satisfies(eq, String(gt), options)) {
+      return null
+    }
+
+    if (lt && !satisfies(eq, String(lt), options)) {
+      return null
+    }
+
+    for (const c of dom) {
+      if (!satisfies(eq, String(c), options)) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  let higher, lower
+  let hasDomLT, hasDomGT
+  // if the subset has a prerelease, we need a comparator in the superset
+  // with the same tuple and a prerelease, or it's not a subset
+  let needDomLTPre = lt &&
+    !options.includePrerelease &&
+    lt.semver.prerelease.length ? lt.semver : false
+  let needDomGTPre = gt &&
+    !options.includePrerelease &&
+    gt.semver.prerelease.length ? gt.semver : false
+  // exception: <1.2.3-0 is the same as <1.2.3
+  if (needDomLTPre && needDomLTPre.prerelease.length === 1 &&
+      lt.operator === '<' && needDomLTPre.prerelease[0] === 0) {
+    needDomLTPre = false
+  }
+
+  for (const c of dom) {
+    hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>='
+    hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<='
+    if (gt) {
+      if (needDomGTPre) {
+        if (c.semver.prerelease && c.semver.prerelease.length &&
+            c.semver.major === needDomGTPre.major &&
+            c.semver.minor === needDomGTPre.minor &&
+            c.semver.patch === needDomGTPre.patch) {
+          needDomGTPre = false
+        }
+      }
+      if (c.operator === '>' || c.operator === '>=') {
+        higher = higherGT(gt, c, options)
+        if (higher === c && higher !== gt) {
+          return false
+        }
+      } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options)) {
+        return false
+      }
+    }
+    if (lt) {
+      if (needDomLTPre) {
+        if (c.semver.prerelease && c.semver.prerelease.length &&
+            c.semver.major === needDomLTPre.major &&
+            c.semver.minor === needDomLTPre.minor &&
+            c.semver.patch === needDomLTPre.patch) {
+          needDomLTPre = false
+        }
+      }
+      if (c.operator === '<' || c.operator === '<=') {
+        lower = lowerLT(lt, c, options)
+        if (lower === c && lower !== lt) {
+          return false
+        }
+      } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options)) {
+        return false
+      }
+    }
+    if (!c.operator && (lt || gt) && gtltComp !== 0) {
+      return false
+    }
+  }
+
+  // if there was a < or >, and nothing in the dom, then must be false
+  // UNLESS it was limited by another range in the other direction.
+  // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0
+  if (gt && hasDomLT && !lt && gtltComp !== 0) {
+    return false
+  }
+
+  if (lt && hasDomGT && !gt && gtltComp !== 0) {
+    return false
+  }
+
+  // we needed a prerelease range in a specific tuple, but didn't get one
+  // then this isn't a subset.  eg >=1.2.3-pre is not a subset of >=1.0.0,
+  // because it includes prereleases in the 1.2.3 tuple
+  if (needDomGTPre || needDomLTPre) {
+    return false
+  }
+
+  return true
+}
+
+// >=1.2.3 is lower than >1.2.3
+const higherGT = (a, b, options) => {
+  if (!a) {
+    return b
+  }
+  const comp = compare(a.semver, b.semver, options)
+  return comp > 0 ? a
+    : comp < 0 ? b
+    : b.operator === '>' && a.operator === '>=' ? b
+    : a
+}
+
+// <=1.2.3 is higher than <1.2.3
+const lowerLT = (a, b, options) => {
+  if (!a) {
+    return b
+  }
+  const comp = compare(a.semver, b.semver, options)
+  return comp < 0 ? a
+    : comp > 0 ? b
+    : b.operator === '<' && a.operator === '<=' ? b
+    : a
+}
+
+module.exports = subset

node_modules/css-loader/node_modules/semver/ranges/to-comparators.js

@@ -0,0 +1,8 @@
+const Range = require('../classes/range')
+
+// Mostly just for testing and legacy API reasons
+const toComparators = (range, options) =>
+  new Range(range, options).set
+    .map(comp => comp.map(c => c.value).join(' ').trim().split(' '))
+
+module.exports = toComparators

node_modules/css-loader/node_modules/semver/ranges/valid.js

@@ -0,0 +1,11 @@
+const Range = require('../classes/range')
+const validRange = (range, options) => {
+  try {
+    // Return '*' instead of '' so that truthiness works.
+    // This will throw if it's invalid anyway
+    return new Range(range, options).range || '*'
+  } catch (er) {
+    return null
+  }
+}
+module.exports = validRange

node_modules/css-loader/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "css-loader",
+  "version": "6.7.1",
+  "description": "css loader module for webpack",
+  "license": "MIT",
+  "repository": "webpack-contrib/css-loader",
+  "author": "Tobias Koppers @sokra",
+  "homepage": "https://github.com/webpack-contrib/css-loader",
+  "bugs": "https://github.com/webpack-contrib/css-loader/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/webpack"
+  },
+  "main": "dist/cjs.js",
+  "engines": {
+    "node": ">= 12.13.0"
+  },
+  "scripts": {
+    "start": "npm run build -- -w",
+    "clean": "del-cli dist",
+    "validate:runtime": "es-check es5 \"dist/runtime/**/*.js\"",
+    "prebuild": "npm run clean",
+    "build": "cross-env NODE_ENV=production babel src -d dist --copy-files",
+    "postbuild": "npm run validate:runtime",
+    "commitlint": "commitlint --from=master",
+    "security": "npm audit --production",
+    "lint:prettier": "prettier --list-different .",
+    "lint:js": "eslint --cache .",
+    "lint": "npm-run-all -l -p \"lint:**\"",
+    "test:only": "cross-env NODE_ENV=test jest",
+    "test:watch": "npm run test:only -- --watch",
+    "test:coverage": "npm run test:only -- --collectCoverageFrom=\"src/**/*.js\" --coverage",
+    "pretest": "npm run lint",
+    "test": "npm run test:coverage",
+    "prepare": "husky install && npm run build",
+    "release": "standard-version"
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "webpack": "^5.0.0"
+  },
+  "dependencies": {
+    "icss-utils": "^5.1.0",
+    "postcss": "^8.4.7",
+    "postcss-modules-extract-imports": "^3.0.0",
+    "postcss-modules-local-by-default": "^4.0.0",
+    "postcss-modules-scope": "^3.0.0",
+    "postcss-modules-values": "^4.0.0",
+    "postcss-value-parser": "^4.2.0",
+    "semver": "^7.3.5"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.17.6",
+    "@babel/core": "^7.17.5",
+    "@babel/preset-env": "^7.16.11",
+    "@commitlint/cli": "^16.2.1",
+    "@commitlint/config-conventional": "^16.2.1",
+    "@webpack-contrib/eslint-config-webpack": "^3.0.0",
+    "babel-jest": "^27.5.1",
+    "cross-env": "^7.0.3",
+    "del": "^6.0.0",
+    "del-cli": "^4.0.1",
+    "es-check": "^6.2.1",
+    "eslint": "^8.10.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.25.4",
+    "file-loader": "^6.2.0",
+    "husky": "^7.0.1",
+    "jest": "^27.5.1",
+    "less": "^4.1.1",
+    "less-loader": "^10.0.1",
+    "lint-staged": "^12.3.4",
+    "memfs": "^3.4.1",
+    "mini-css-extract-plugin": "^2.6.0",
+    "npm-run-all": "^4.1.5",
+    "postcss-loader": "^6.2.1",
+    "postcss-preset-env": "^7.4.2",
+    "prettier": "^2.5.1",
+    "sass": "^1.49.9",
+    "sass-loader": "^12.6.0",
+    "standard-version": "^9.3.1",
+    "strip-ansi": "^6.0.0",
+    "style-loader": "^3.1.0",
+    "stylus": "^0.56.0",
+    "stylus-loader": "^6.1.0",
+    "url-loader": "^4.1.1",
+    "webpack": "^5.70.0"
+  },
+  "keywords": [
+    "webpack",
+    "css",
+    "loader",
+    "url",
+    "import"
+  ]
+}

node_modules/css-minimizer-webpack-plugin/LICENSE

@@ -0,0 +1,20 @@
+Copyright JS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/css-minimizer-webpack-plugin/README.md

@@ -0,0 +1,588 @@
+<div align="center">
+  <a href="https://github.com/webpack/webpack">
+    <img width="200" height="200" src="https://webpack.js.org/assets/icon-square-big.svg">
+  </a>
+</div>
+
+[![npm][npm]][npm-url]
+[![node][node]][node-url]
+[![deps][deps]][deps-url]
+[![tests][tests]][tests-url]
+[![cover][cover]][cover-url]
+[![chat][chat]][chat-url]
+[![size][size]][size-url]
+
+# css-minimizer-webpack-plugin
+
+This plugin uses [cssnano](https://cssnano.co) to optimize and minify your CSS.
+
+Just like [optimize-css-assets-webpack-plugin](https://github.com/NMFR/optimize-css-assets-webpack-plugin) but more accurate with source maps and assets using query string, allows caching and works in parallel mode.
+
+## Getting Started
+
+To begin, you'll need to install `css-minimizer-webpack-plugin`:
+
+```console
+$ npm install css-minimizer-webpack-plugin --save-dev
+```
+
+Then add the plugin to your `webpack` configuration. For example:
+
+**webpack.config.js**
+
+```js
+const MiniCssExtractPlugin = require("mini-css-extract-plugin");
+const CssMinimizerPlugin = require("css-minimizer-webpack-plugin");
+
+module.exports = {
+  module: {
+    rules: [
+      {
+        test: /.s?css$/,
+        use: [MiniCssExtractPlugin.loader, "css-loader", "sass-loader"],
+      },
+    ],
+  },
+  optimization: {
+    minimizer: [
+      // For webpack@5 you can use the `...` syntax to extend existing minimizers (i.e. `terser-webpack-plugin`), uncomment the next line
+      // `...`,
+      new CssMinimizerPlugin(),
+    ],
+  },
+  plugins: [new MiniCssExtractPlugin()],
+};
+```
+
+This will enable CSS optimization only in production mode.
+
+If you want to run it also in development set the `optimization.minimize` option to `true`:
+
+**webpack.config.js**
+
+```js
+// [...]
+module.exports = {
+  optimization: {
+    // [...]
+    minimize: true,
+  },
+};
+```
+
+And run `webpack` via your preferred method.
+
+## Note about source maps
+
+**Works only with `source-map`, `inline-source-map`, `hidden-source-map` and `nosources-source-map` values for the [`devtool`](https://webpack.js.org/configuration/devtool/) option.**
+
+Why? Because CSS support only these source map types.
+
+The plugin respect the [`devtool`](https://webpack.js.org/configuration/devtool/) and using the `SourceMapDevToolPlugin` plugin.
+Using supported `devtool` values enable source map generation.
+Using `SourceMapDevToolPlugin` with enabled the `columns` option enables source map generation.
+
+Use source maps to map error message locations to modules (this slows down the compilation).
+If you use your own `minify` function please read the `minify` section for handling source maps correctly.
+
+## Options
+
+|                    Name                     |                      Type                      |              Default               | Description                                                             |
+| :-----------------------------------------: | :--------------------------------------------: | :--------------------------------: | :---------------------------------------------------------------------- |
+|             **[`test`](#test)**             |    `String\|RegExp\|Array<String\|RegExp>`     |         `/\.css(\?.*)?$/i`         | Test to match files against.                                            |
+|          **[`include`](#include)**          |    `String\|RegExp\|Array<String\|RegExp>`     |            `undefined`             | Files to include.                                                       |
+|          **[`exclude`](#exclude)**          |    `String\|RegExp\|Array<String\|RegExp>`     |            `undefined`             | Files to exclude.                                                       |
+|         **[`parallel`](#parallel)**         |               `Boolean\|Number`                |               `true`               | Enable/disable multi-process parallel running.                          |
+|           **[`minify`](#minify)**           |          `Function\|Array<Function>`           | `CssMinimizerPlugin.cssnanoMinify` | Allows to override default minify function.                             |
+| **[`minimizerOptions`](#minimizeroptions)** |            `Object\|Array<Object>`             |      `{ preset: 'default' }`       | Cssnano optimisations [options](https://cssnano.co/docs/optimisations). |
+|   **[`warningsFilter`](#warningsfilter)**   | `Function<(warning, file, source) -> Boolean>` |            `() => true`            | Allow to filter css-minimizer warnings.                                 |
+
+### `test`
+
+Type: `String|RegExp|Array<String|RegExp>` - default: `/\.css(\?.*)?$/i`
+
+Test to match files against.
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new CssMinimizerPlugin({
+        test: /\.foo\.css$/i,
+      }),
+    ],
+  },
+};
+```
+
+### `include`
+
+Type: `String|RegExp|Array<String|RegExp>`
+Default: `undefined`
+
+Files to include.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new CssMinimizerPlugin({
+        include: /\/includes/,
+      }),
+    ],
+  },
+};
+```
+
+### `exclude`
+
+Type: `String|RegExp|Array<String|RegExp>`
+Default: `undefined`
+
+Files to exclude.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new CssMinimizerPlugin({
+        exclude: /\/excludes/,
+      }),
+    ],
+  },
+};
+```
+
+### `parallel`
+
+Type: `Boolean|Number`
+Default: `true`
+
+Use multi-process parallel running to improve the build speed.
+Default number of concurrent runs: `os.cpus().length - 1`.
+
+> ℹ️ Parallelization can speed up your build significantly and is therefore **highly recommended**.
+> If a parallelization is enabled, the packages in `minimizerOptions` must be required via strings (`packageName` or `require.resolve(packageName)`). Read more in [`minimizerOptions`](#minimizeroptions)
+
+#### `Boolean`
+
+Enable/disable multi-process parallel running.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new CssMinimizerPlugin({
+        parallel: true,
+      }),
+    ],
+  },
+};
+```
+
+#### `Number`
+
+Enable multi-process parallel running and set number of concurrent runs.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new CssMinimizerPlugin({
+        parallel: 4,
+      }),
+    ],
+  },
+};
+```
+
+### `minify`
+
+Type: `Function|Array<Function>`
+Default: `CssMinimizerPlugin.cssnanoMinify`
+
+Allows overriding default minify function.
+By default, plugin uses [cssnano](https://github.com/cssnano/cssnano) package.
+Useful for using and testing unpublished versions or forks.
+
+Possible options:
+
+- CssMinimizerPlugin.cssnanoMinify
+- CssMinimizerPlugin.cssoMinify
+- CssMinimizerPlugin.cleanCssMinify
+- CssMinimizerPlugin.esbuildMinify
+- CssMinimizerPlugin.parcelCssMinify
+- `async (data, inputMap, minimizerOptions) => {return {code: "a{color: red}", map: "...", warnings: [], errors: []}}`
+
+> ⚠️ **Always use `require` inside `minify` function when `parallel` option enabled**.
+
+#### `Function`
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new CssMinimizerPlugin({
+        minimizerOptions: {
+          level: {
+            1: {
+              roundingPrecision: "all=3,px=5",
+            },
+          },
+        },
+        minify: CssMinimizerPlugin.cleanCssMinify,
+      }),
+    ],
+  },
+};
+```
+
+#### `Array`
+
+If an array of functions is passed to the `minify` option, the `minimizerOptions` must also be an array.
+The function index in the `minify` array corresponds to the options object with the same index in the `minimizerOptions` array.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new CssMinimizerPlugin({
+        minimizerOptions: [
+          {}, // Options for the first function (CssMinimizerPlugin.cssnanoMinify)
+          {}, // Options for the second function (CssMinimizerPlugin.cleanCssMinify)
+          {}, // Options for the third function
+        ],
+        minify: [
+          CssMinimizerPlugin.cssnanoMinify,
+          CssMinimizerPlugin.cleanCssMinify,
+          async (data, inputMap, minimizerOptions) => {
+            // To do something
+            return {
+              code: `a{color: red}`,
+              map: `{"version": "3", ...}`,
+              warnings: [],
+              errors: [],
+            };
+          },
+        ],
+      }),
+    ],
+  },
+};
+```
+
+### `minimizerOptions`
+
+Type: `Object|Array<Object>`
+Default: `{ preset: 'default' }`
+
+Cssnano optimisations [options](https://cssnano.co/docs/optimisations).
+
+#### `Object`
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new CssMinimizerPlugin({
+        minimizerOptions: {
+          preset: [
+            "default",
+            {
+              discardComments: { removeAll: true },
+            },
+          ],
+        },
+      }),
+    ],
+  },
+};
+```
+
+#### `Array`
+
+The function index in the `minify` array corresponds to the options object with the same index in the `minimizerOptions` array.
+If you use `minimizerOptions` like object, all `minify` function accept it.
+
+> If a parallelization is enabled, the packages in `minimizerOptions` must be required via strings (`packageName` or `require.resolve(packageName)`). In this case, we shouldn't use `require`/`import`.
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new CssMinimizerPlugin({
+        minimizerOptions: {
+          preset: require.resolve("cssnano-preset-simple"),
+        },
+      }),
+    ],
+  },
+};
+```
+
+##### `processorOptions` (⚠ only cssnano)
+
+Type: `Object`
+Default: `{ from: assetName }`
+
+Allows filtering options [`processoptions`](https://postcss.org/api/#processoptions) for the cssnano.
+The `parser`,` stringifier` and `syntax` can be either a function or a string indicating the module that will be imported.
+
+> ⚠️ **If a function is passed, the `parallel` option must be disabled.**.
+
+```js
+import sugarss from "sugarss";
+
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new CssMinimizerPlugin({
+        parallel: false,
+        minimizerOptions: {
+          processorOptions: {
+            parser: sugarss,
+          },
+        },
+      }),
+    ],
+  },
+};
+```
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new CssMinimizerPlugin({
+        minimizerOptions: {
+          processorOptions: {
+            parser: "sugarss",
+          },
+        },
+      }),
+    ],
+  },
+};
+```
+
+### `warningsFilter`
+
+Type: `Function<(warning, file, source) -> Boolean>`
+Default: `() => true`
+
+Allow filtering css-minimizer warnings (By default [cssnano](https://github.com/cssnano/cssnano)).
+Return `true` to keep the warning, a falsy value (`false`/`null`/`undefined`) otherwise.
+
+> ⚠️ The `source` argument will contain `undefined` if you don't use source maps.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new CssMinimizerPlugin({
+        warningsFilter: (warning, file, source) => {
+          if (/Dropping unreachable code/i.test(warning)) {
+            return true;
+          }
+
+          if (/file\.css/i.test(file)) {
+            return true;
+          }
+
+          if (/source\.css/i.test(source)) {
+            return true;
+          }
+
+          return false;
+        },
+      }),
+    ],
+  },
+};
+```
+
+## Examples
+
+### Use sourcemaps
+
+Don't forget to enable `sourceMap` options for all loaders.
+
+```js
+const CssMinimizerPlugin = require("css-minimizer-webpack-plugin");
+
+module.exports = {
+  devtool: "source-map",
+  module: {
+    rules: [
+      {
+        test: /.s?css$/,
+        use: [
+          MiniCssExtractPlugin.loader,
+          { loader: "css-loader", options: { sourceMap: true } },
+          { loader: "sass-loader", options: { sourceMap: true } },
+        ],
+      },
+    ],
+  },
+  optimization: {
+    minimizer: [new CssMinimizerPlugin()],
+  },
+  plugins: [new MiniCssExtractPlugin()],
+};
+```
+
+### Remove all comments
+
+Remove all comments (including comments starting with `/*!`).
+
+```js
+module.exports = {
+  optimization: {
+    minimizer: [
+      new CssMinimizerPlugin({
+        minimizerOptions: {
+          preset: [
+            "default",
+            {
+              discardComments: { removeAll: true },
+            },
+          ],
+        },
+      }),
+    ],
+  },
+};
+```
+
+### Using custom minifier [csso](https://github.com/css/csso)
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  // Uncomment if you need source maps
+  // devtool: "source-map",
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new CssMinimizerPlugin({
+        minify: CssMinimizerPlugin.cssoMinify,
+        // Uncomment this line for options
+        // minimizerOptions: { restructure: false },
+      }),
+    ],
+  },
+};
+```
+
+### Using custom minifier [clean-css](https://github.com/jakubpawlowicz/clean-css)
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  // Uncomment if you need source maps
+  // devtool: "source-map",
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new CssMinimizerPlugin({
+        minify: CssMinimizerPlugin.cleanCssMinify,
+        // Uncomment this line for options
+        // minimizerOptions: { compatibility: 'ie11,-properties.merging' },
+      }),
+    ],
+  },
+};
+```
+
+### Using custom minifier [esbuild](https://github.com/evanw/esbuild)
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  // Uncomment if you need source maps
+  // devtool: "source-map",
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new CssMinimizerPlugin({
+        minify: CssMinimizerPlugin.esbuildMinify,
+      }),
+    ],
+  },
+};
+```
+
+### Using custom minifier [@parcel/css](https://github.com/parcel-bundler/parcel-css)
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  // Uncomment if you need source maps
+  // devtool: "source-map",
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new CssMinimizerPlugin({
+        minify: CssMinimizerPlugin.parcelCssMinify,
+        // Uncomment this line for options
+        // minimizerOptions: { targets: { ie: 11 }, drafts: { nesting: true } },
+      }),
+    ],
+  },
+};
+```
+
+## Contributing
+
+Please take a moment to read our contributing guidelines if you haven't yet done so.
+
+[CONTRIBUTING](./.github/CONTRIBUTING.md)
+
+## License
+
+[MIT](./LICENSE)
+
+[npm]: https://img.shields.io/npm/v/css-minimizer-webpack-plugin.svg
+[npm-url]: https://npmjs.com/package/css-minimizer-webpack-plugin
+[node]: https://img.shields.io/node/v/css-minimizer-webpack-plugin.svg
+[node-url]: https://nodejs.org
+[deps]: https://david-dm.org/webpack-contrib/css-minimizer-webpack-plugin.svg
+[deps-url]: https://david-dm.org/webpack-contrib/css-minimizer-webpack-plugin
+[tests]: https://github.com/webpack-contrib/css-minimizer-webpack-plugin/workflows/css-minimizer-webpack-plugin/badge.svg
+[tests-url]: https://github.com/webpack-contrib/css-minimizer-webpack-plugin/actions
+[cover]: https://codecov.io/gh/webpack-contrib/css-minimizer-webpack-plugin/branch/master/graph/badge.svg
+[cover-url]: https://codecov.io/gh/webpack-contrib/css-minimizer-webpack-plugin
+[chat]: https://img.shields.io/badge/gitter-webpack%2Fwebpack-brightgreen.svg
+[chat-url]: https://gitter.im/webpack/webpack
+[size]: https://packagephobia.now.sh/badge?p=css-minimizer-webpack-plugin
+[size-url]: https://packagephobia.now.sh/result?p=css-minimizer-webpack-plugin

node_modules/css-minimizer-webpack-plugin/dist/index.js

@@ -0,0 +1,685 @@
+"use strict";
+
+const os = require("os");
+
+const {
+  SourceMapConsumer
+} = require("source-map");
+
+const {
+  validate
+} = require("schema-utils");
+
+const serialize = require("serialize-javascript");
+
+const {
+  Worker
+} = require("jest-worker");
+
+const {
+  throttleAll,
+  cssnanoMinify,
+  cssoMinify,
+  cleanCssMinify,
+  esbuildMinify,
+  parcelCssMinify
+} = require("./utils");
+
+const schema = require("./options.json");
+
+const {
+  minify
+} = require("./minify");
+/** @typedef {import("schema-utils/declarations/validate").Schema} Schema */
+
+/** @typedef {import("webpack").Compiler} Compiler */
+
+/** @typedef {import("webpack").Compilation} Compilation */
+
+/** @typedef {import("webpack").WebpackError} WebpackError */
+
+/** @typedef {import("jest-worker").Worker} JestWorker */
+
+/** @typedef {import("source-map").RawSourceMap} RawSourceMap */
+
+/** @typedef {import("webpack").Asset} Asset */
+
+/** @typedef {import("postcss").ProcessOptions} ProcessOptions */
+
+/** @typedef {import("postcss").Syntax} Syntax */
+
+/** @typedef {import("postcss").Parser} Parser */
+
+/** @typedef {import("postcss").Stringifier} Stringifier */
+
+/**
+ * @typedef {Object} CssNanoOptions
+ * @property {string} [configFile]
+ * @property {[string, object] | string | undefined} [preset]
+ */
+
+/** @typedef {Error & { plugin?: string, text?: string, source?: string } | string} Warning */
+
+/**
+ * @typedef {Object} WarningObject
+ * @property {string} message
+ * @property {string} [plugin]
+ * @property {string} [text]
+ * @property {number} [line]
+ * @property {number} [column]
+ */
+
+/**
+ * @typedef {Object} ErrorObject
+ * @property {string} message
+ * @property {number} [line]
+ * @property {number} [column]
+ * @property {string} [stack]
+ */
+
+/**
+ * @typedef {Object} MinimizedResult
+ * @property {string} code
+ * @property {RawSourceMap} [map]
+ * @property {Array<Error | ErrorObject| string>} [errors]
+ * @property {Array<Warning | WarningObject | string>} [warnings]
+ */
+
+/**
+ * @typedef {{ [file: string]: string }} Input
+ */
+
+/**
+ * @typedef {{ [key: string]: any }} CustomOptions
+ */
+
+/**
+ * @template T
+ * @typedef {T extends infer U ? U : CustomOptions} InferDefaultType
+ */
+
+/**
+ * @template T
+ * @callback BasicMinimizerImplementation
+ * @param {Input} input
+ * @param {RawSourceMap | undefined} sourceMap
+ * @param {InferDefaultType<T>} minifyOptions
+ * @returns {Promise<MinimizedResult>}
+ */
+
+/**
+ * @template T
+ * @typedef {T extends any[] ? { [P in keyof T]: BasicMinimizerImplementation<T[P]>; } : BasicMinimizerImplementation<T>} MinimizerImplementation
+ */
+
+/**
+ * @template T
+ * @typedef {T extends any[] ? { [P in keyof T]?: InferDefaultType<T[P]> } : InferDefaultType<T>} MinimizerOptions
+ */
+
+/**
+ * @template T
+ * @typedef {Object} InternalOptions
+ * @property {string} name
+ * @property {string} input
+ * @property {RawSourceMap | undefined} inputSourceMap
+ * @property {{ implementation: MinimizerImplementation<T>, options: MinimizerOptions<T> }} minimizer
+ */
+
+/**
+ * @typedef InternalResult
+ * @property {Array<{ code: string, map: RawSourceMap | undefined }>} outputs
+ * @property {Array<Warning | WarningObject | string>} warnings
+ * @property {Array<Error | ErrorObject | string>} errors
+ */
+
+/** @typedef {undefined | boolean | number} Parallel */
+
+/** @typedef {RegExp | string} Rule */
+
+/** @typedef {Rule[] | Rule} Rules */
+
+/** @typedef {(warning: Warning | WarningObject | string, file: string, source?: string) => boolean} WarningsFilter */
+
+/**
+ * @typedef {Object} BasePluginOptions
+ * @property {Rules} [test]
+ * @property {Rules} [include]
+ * @property {Rules} [exclude]
+ * @property {WarningsFilter} [warningsFilter]
+ * @property {Parallel} [parallel]
+ */
+
+/**
+ * @template T
+ * @typedef {JestWorker & { transform: (options: string) => InternalResult, minify: (options: InternalOptions<T>) => InternalResult }} MinimizerWorker
+ */
+
+/**
+ * @typedef{ProcessOptions | { from?: string,  to?: string, parser?: string | Syntax | Parser, stringifier?: string | Syntax | Stringifier, syntax?: string | Syntax } } ProcessOptionsExtender
+ */
+
+/**
+ * @typedef {CssNanoOptions & { processorOptions?: ProcessOptionsExtender }} CssNanoOptionsExtended
+ */
+
+/**
+ * @template T
+ * @typedef {T extends CssNanoOptionsExtended ? { minify?: MinimizerImplementation<T> | undefined, minimizerOptions?: MinimizerOptions<T> | undefined } : { minify: MinimizerImplementation<T>, minimizerOptions?: MinimizerOptions<T> | undefined }} DefinedDefaultMinimizerAndOptions
+ */
+
+/**
+ * @template T
+ * @typedef {BasePluginOptions & { minimizer: { implementation: MinimizerImplementation<T>, options: MinimizerOptions<T> } }} InternalPluginOptions
+ */
+
+
+const warningRegex = /\s.+:+([0-9]+):+([0-9]+)/;
+/**
+ * @template [T=CssNanoOptionsExtended]
+ */
+
+class CssMinimizerPlugin {
+  /**
+   * @param {BasePluginOptions & DefinedDefaultMinimizerAndOptions<T>} [options]
+   */
+  constructor(options) {
+    validate(
+    /** @type {Schema} */
+    schema, options || {}, {
+      name: "Css Minimizer Plugin",
+      baseDataPath: "options"
+    });
+    const {
+      minify =
+      /** @type {BasicMinimizerImplementation<T>} */
+      cssnanoMinify,
+      minimizerOptions =
+      /** @type {MinimizerOptions<T>} */
+      {},
+      test = /\.css(\?.*)?$/i,
+      warningsFilter = () => true,
+      parallel = true,
+      include,
+      exclude
+    } = options || {};
+    /**
+     * @private
+     * @type {InternalPluginOptions<T>}
+     */
+
+    this.options = {
+      test,
+      warningsFilter,
+      parallel,
+      include,
+      exclude,
+      minimizer: {
+        implementation:
+        /** @type {MinimizerImplementation<T>} */
+        minify,
+        options: minimizerOptions
+      }
+    };
+  }
+  /**
+   * @private
+   * @param {any} input
+   * @returns {boolean}
+   */
+
+
+  static isSourceMap(input) {
+    // All required options for `new SourceMapConsumer(...options)`
+    // https://github.com/mozilla/source-map#new-sourcemapconsumerrawsourcemap
+    return Boolean(input && input.version && input.sources && Array.isArray(input.sources) && typeof input.mappings === "string");
+  }
+  /**
+   * @private
+   * @param {Warning | WarningObject | string} warning
+   * @param {string} file
+   * @param {WarningsFilter} [warningsFilter]
+   * @param {SourceMapConsumer} [sourceMap]
+   * @param {Compilation["requestShortener"]} [requestShortener]
+   * @returns {Error & { hideStack?: boolean, file?: string } | undefined}
+   */
+
+
+  static buildWarning(warning, file, warningsFilter, sourceMap, requestShortener) {
+    let warningMessage = typeof warning === "string" ? warning : `${warning.plugin ? `[${warning.plugin}] ` : ""}${warning.text || warning.message}`;
+    let locationMessage = "";
+    let source;
+
+    if (sourceMap) {
+      let line;
+      let column;
+
+      if (typeof warning === "string") {
+        const match = warningRegex.exec(warning);
+
+        if (match) {
+          line = +match[1];
+          column = +match[2];
+        }
+      } else {
+        ({
+          line,
+          column
+        } =
+        /** @type {WarningObject} */
+        warning);
+      }
+
+      if (line && column) {
+        const original = sourceMap.originalPositionFor({
+          line,
+          column
+        });
+
+        if (original && original.source && original.source !== file && requestShortener) {
+          ({
+            source
+          } = original);
+          warningMessage = `${warningMessage.replace(warningRegex, "")}`;
+          locationMessage = `${requestShortener.shorten(original.source)}:${original.line}:${original.column}`;
+        }
+      }
+    }
+
+    if (warningsFilter && !warningsFilter(warning, file, source)) {
+      return;
+    }
+    /**
+     * @type {Error & { hideStack?: boolean, file?: string }}
+     */
+
+
+    const builtWarning = new Error(`${file} from Css Minimizer plugin\n${warningMessage}${locationMessage ? ` ${locationMessage}` : ""}`);
+    builtWarning.name = "Warning";
+    builtWarning.hideStack = true;
+    builtWarning.file = file; // eslint-disable-next-line consistent-return
+
+    return builtWarning;
+  }
+  /**
+   * @private
+   * @param {Error | ErrorObject | string} error
+   * @param {string} file
+   * @param {SourceMapConsumer} [sourceMap]
+   * @param {Compilation["requestShortener"]} [requestShortener]
+   * @returns {Error}
+   */
+
+
+  static buildError(error, file, sourceMap, requestShortener) {
+    /**
+     * @type {Error & { file?: string }}
+     */
+    let builtError;
+
+    if (typeof error === "string") {
+      builtError = new Error(`${file} from Css Minimizer plugin\n${error}`);
+      builtError.file = file;
+      return builtError;
+    }
+
+    if (
+    /** @type {ErrorObject} */
+    error.line &&
+    /** @type {ErrorObject} */
+    error.column) {
+      const {
+        line,
+        column
+      } =
+      /** @type {ErrorObject & { line: number, column: number }} */
+      error;
+      const original = sourceMap && sourceMap.originalPositionFor({
+        line,
+        column
+      });
+
+      if (original && original.source && requestShortener) {
+        builtError = new Error(`${file} from Css Minimizer plugin\n${error.message} [${requestShortener.shorten(original.source)}:${original.line},${original.column}][${file}:${line},${column}]${error.stack ? `\n${error.stack.split("\n").slice(1).join("\n")}` : ""}`);
+        builtError.file = file;
+        return builtError;
+      }
+
+      builtError = new Error(`${file} from Css Minimizer plugin\n${error.message} [${file}:${line},${column}]${error.stack ? `\n${error.stack.split("\n").slice(1).join("\n")}` : ""}`);
+      builtError.file = file;
+      return builtError;
+    }
+
+    if (error.stack) {
+      builtError = new Error(`${file} from Css Minimizer plugin\n${error.stack}`);
+      builtError.file = file;
+      return builtError;
+    }
+
+    builtError = new Error(`${file} from Css Minimizer plugin\n${error.message}`);
+    builtError.file = file;
+    return builtError;
+  }
+  /**
+   * @private
+   * @param {Parallel} parallel
+   * @returns {number}
+   */
+
+
+  static getAvailableNumberOfCores(parallel) {
+    // In some cases cpus() returns undefined
+    // https://github.com/nodejs/node/issues/19022
+    const cpus = os.cpus() || {
+      length: 1
+    };
+    return parallel === true ? cpus.length - 1 : Math.min(Number(parallel) || 0, cpus.length - 1);
+  }
+  /**
+   * @private
+   * @param {Compiler} compiler
+   * @param {Compilation} compilation
+   * @param {Record<string, import("webpack").sources.Source>} assets
+   * @param {{availableNumberOfCores: number}} optimizeOptions
+   * @returns {Promise<void>}
+   */
+
+
+  async optimize(compiler, compilation, assets, optimizeOptions) {
+    const cache = compilation.getCache("CssMinimizerWebpackPlugin");
+    let numberOfAssetsForMinify = 0;
+    const assetsForMinify = await Promise.all(Object.keys(typeof assets === "undefined" ? compilation.assets : assets).filter(name => {
+      const {
+        info
+      } =
+      /** @type {Asset} */
+      compilation.getAsset(name);
+
+      if ( // Skip double minimize assets from child compilation
+      info.minimized) {
+        return false;
+      }
+
+      if (!compiler.webpack.ModuleFilenameHelpers.matchObject.bind( // eslint-disable-next-line no-undefined
+      undefined, this.options)(name)) {
+        return false;
+      }
+
+      return true;
+    }).map(async name => {
+      const {
+        info,
+        source
+      } =
+      /** @type {Asset} */
+      compilation.getAsset(name);
+      const eTag = cache.getLazyHashedEtag(source);
+      const cacheItem = cache.getItemCache(name, eTag);
+      const output = await cacheItem.getPromise();
+
+      if (!output) {
+        numberOfAssetsForMinify += 1;
+      }
+
+      return {
+        name,
+        info,
+        inputSource: source,
+        output,
+        cacheItem
+      };
+    }));
+
+    if (assetsForMinify.length === 0) {
+      return;
+    }
+    /** @type {undefined | (() => MinimizerWorker<T>)} */
+
+
+    let getWorker;
+    /** @type {undefined | MinimizerWorker<T>} */
+
+    let initializedWorker;
+    /** @type {undefined | number} */
+
+    let numberOfWorkers;
+
+    if (optimizeOptions.availableNumberOfCores > 0) {
+      // Do not create unnecessary workers when the number of files is less than the available cores, it saves memory
+      numberOfWorkers = Math.min(numberOfAssetsForMinify, optimizeOptions.availableNumberOfCores);
+
+      getWorker = () => {
+        if (initializedWorker) {
+          return initializedWorker;
+        }
+
+        initializedWorker =
+        /** @type {MinimizerWorker<T>} */
+        new Worker(require.resolve("./minify"), {
+          numWorkers: numberOfWorkers,
+          enableWorkerThreads: true
+        }); // https://github.com/facebook/jest/issues/8872#issuecomment-524822081
+
+        const workerStdout = initializedWorker.getStdout();
+
+        if (workerStdout) {
+          workerStdout.on("data", chunk => process.stdout.write(chunk));
+        }
+
+        const workerStderr = initializedWorker.getStderr();
+
+        if (workerStderr) {
+          workerStderr.on("data", chunk => process.stderr.write(chunk));
+        }
+
+        return initializedWorker;
+      };
+    }
+
+    const {
+      SourceMapSource,
+      RawSource
+    } = compiler.webpack.sources;
+    const scheduledTasks = [];
+
+    for (const asset of assetsForMinify) {
+      scheduledTasks.push(async () => {
+        const {
+          name,
+          inputSource,
+          cacheItem
+        } = asset;
+        let {
+          output
+        } = asset;
+
+        if (!output) {
+          let input;
+          /** @type {RawSourceMap | undefined} */
+
+          let inputSourceMap;
+          const {
+            source: sourceFromInputSource,
+            map
+          } = inputSource.sourceAndMap();
+          input = sourceFromInputSource;
+
+          if (map) {
+            if (!CssMinimizerPlugin.isSourceMap(map)) {
+              compilation.warnings.push(
+              /** @type {WebpackError} */
+              new Error(`${name} contains invalid source map`));
+            } else {
+              inputSourceMap =
+              /** @type {RawSourceMap} */
+              map;
+            }
+          }
+
+          if (Buffer.isBuffer(input)) {
+            input = input.toString();
+          }
+          /**
+           * @type {InternalOptions<T>}
+           */
+
+
+          const options = {
+            name,
+            input,
+            inputSourceMap,
+            minimizer: {
+              implementation: this.options.minimizer.implementation,
+              options: this.options.minimizer.options
+            }
+          };
+          let result;
+
+          try {
+            result = await (getWorker ? getWorker().transform(serialize(options)) : minify(options));
+          } catch (error) {
+            const hasSourceMap = inputSourceMap && CssMinimizerPlugin.isSourceMap(inputSourceMap);
+            compilation.errors.push(
+            /** @type {WebpackError} */
+            CssMinimizerPlugin.buildError(
+            /** @type {any} */
+            error, name, hasSourceMap ? new SourceMapConsumer(
+            /** @type {RawSourceMap} */
+            inputSourceMap) : // eslint-disable-next-line no-undefined
+            undefined, // eslint-disable-next-line no-undefined
+            hasSourceMap ? compilation.requestShortener : undefined));
+            return;
+          }
+
+          output = {
+            warnings: [],
+            errors: []
+          };
+
+          for (const item of result.outputs) {
+            if (item.map) {
+              let originalSource;
+              let innerSourceMap;
+
+              if (output.source) {
+                ({
+                  source: originalSource,
+                  map: innerSourceMap
+                } = output.source.sourceAndMap());
+              } else {
+                originalSource = input;
+                innerSourceMap = inputSourceMap;
+              } // TODO need API for merging source maps in `webpack-source`
+
+
+              output.source = new SourceMapSource(item.code, name, item.map, originalSource, innerSourceMap, true);
+            } else {
+              output.source = new RawSource(item.code);
+            }
+          }
+
+          if (result.errors && result.errors.length > 0) {
+            const hasSourceMap = inputSourceMap && CssMinimizerPlugin.isSourceMap(inputSourceMap);
+
+            for (const error of result.errors) {
+              output.warnings.push(CssMinimizerPlugin.buildError(error, name, hasSourceMap ? new SourceMapConsumer(
+              /** @type {RawSourceMap} */
+              inputSourceMap) : // eslint-disable-next-line no-undefined
+              undefined, // eslint-disable-next-line no-undefined
+              hasSourceMap ? compilation.requestShortener : undefined));
+            }
+          }
+
+          if (result.warnings && result.warnings.length > 0) {
+            const hasSourceMap = inputSourceMap && CssMinimizerPlugin.isSourceMap(inputSourceMap);
+
+            for (const warning of result.warnings) {
+              const buildWarning = CssMinimizerPlugin.buildWarning(warning, name, this.options.warningsFilter, hasSourceMap ? new SourceMapConsumer(
+              /** @type {RawSourceMap} */
+              inputSourceMap) : // eslint-disable-next-line no-undefined
+              undefined, // eslint-disable-next-line no-undefined
+              hasSourceMap ? compilation.requestShortener : undefined);
+
+              if (buildWarning) {
+                output.warnings.push(buildWarning);
+              }
+            }
+          }
+
+          await cacheItem.storePromise({
+            source: output.source,
+            warnings: output.warnings,
+            errors: output.errors
+          });
+        }
+
+        if (output.warnings && output.warnings.length > 0) {
+          for (const warning of output.warnings) {
+            compilation.warnings.push(warning);
+          }
+        }
+
+        if (output.errors && output.errors.length > 0) {
+          for (const error of output.errors) {
+            compilation.errors.push(error);
+          }
+        }
+
+        const newInfo = {
+          minimized: true
+        };
+        const {
+          source
+        } = output;
+        compilation.updateAsset(name, source, newInfo);
+      });
+    }
+
+    const limit = getWorker && numberOfAssetsForMinify > 0 ?
+    /** @type {number} */
+    numberOfWorkers : scheduledTasks.length;
+    await throttleAll(limit, scheduledTasks);
+
+    if (initializedWorker) {
+      await initializedWorker.end();
+    }
+  }
+  /**
+   * @param {Compiler} compiler
+   * @returns {void}
+   */
+
+
+  apply(compiler) {
+    const pluginName = this.constructor.name;
+    const availableNumberOfCores = CssMinimizerPlugin.getAvailableNumberOfCores(this.options.parallel);
+    compiler.hooks.compilation.tap(pluginName, compilation => {
+      compilation.hooks.processAssets.tapPromise({
+        name: pluginName,
+        stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE,
+        additionalAssets: true
+      }, assets => this.optimize(compiler, compilation, assets, {
+        availableNumberOfCores
+      }));
+      compilation.hooks.statsPrinter.tap(pluginName, stats => {
+        stats.hooks.print.for("asset.info.minimized").tap("css-minimizer-webpack-plugin", (minimized, {
+          green,
+          formatFlag
+        }) => // eslint-disable-next-line no-undefined
+        minimized ?
+        /** @type {Function} */
+        green(
+        /** @type {Function} */
+        formatFlag("minimized")) : "");
+      });
+    });
+  }
+
+}
+
+CssMinimizerPlugin.cssnanoMinify = cssnanoMinify;
+CssMinimizerPlugin.cssoMinify = cssoMinify;
+CssMinimizerPlugin.cleanCssMinify = cleanCssMinify;
+CssMinimizerPlugin.esbuildMinify = esbuildMinify;
+CssMinimizerPlugin.parcelCssMinify = parcelCssMinify;
+module.exports = CssMinimizerPlugin;

node_modules/css-minimizer-webpack-plugin/dist/minify.js

@@ -0,0 +1,86 @@
+"use strict";
+
+/** @typedef {import("./index.js").MinimizedResult} MinimizedResult */
+
+/** @typedef {import("source-map").RawSourceMap} RawSourceMap */
+
+/** @typedef {import("./index.js").InternalResult} InternalResult */
+
+/**
+ * @template T
+ * @param {import("./index.js").InternalOptions<T>} options
+ * @returns {Promise<InternalResult>}
+ */
+const minify = async options => {
+  const minifyFns = Array.isArray(options.minimizer.implementation) ? options.minimizer.implementation : [options.minimizer.implementation];
+  /** @type {InternalResult} */
+
+  const result = {
+    outputs: [],
+    warnings: [],
+    errors: []
+  };
+  let needSourceMap = false;
+
+  for (let i = 0; i <= minifyFns.length - 1; i++) {
+    const minifyFn = minifyFns[i];
+    const minifyOptions = Array.isArray(options.minimizer.options) ? options.minimizer.options[i] : options.minimizer.options;
+    const prevResult = result.outputs.length > 0 ? result.outputs[result.outputs.length - 1] : {
+      code: options.input,
+      map: options.inputSourceMap
+    };
+    const {
+      code,
+      map
+    } = prevResult; // eslint-disable-next-line no-await-in-loop
+
+    const minifyResult = await minifyFn({
+      [options.name]: code
+    }, map, minifyOptions);
+
+    if (typeof minifyResult.code !== "string") {
+      throw new Error("minimizer function doesn't return the 'code' property or result is not a string value");
+    }
+
+    if (minifyResult.map) {
+      needSourceMap = true;
+    }
+
+    if (minifyResult.errors) {
+      result.errors = result.errors.concat(minifyResult.errors);
+    }
+
+    if (minifyResult.warnings) {
+      result.warnings = result.warnings.concat(minifyResult.warnings);
+    }
+
+    result.outputs.push({
+      code: minifyResult.code,
+      map: minifyResult.map
+    });
+  }
+
+  if (!needSourceMap) {
+    result.outputs = [result.outputs[result.outputs.length - 1]];
+  }
+
+  return result;
+};
+/**
+ * @param {string} options
+ * @returns {Promise<InternalResult>}
+ */
+
+
+async function transform(options) {
+  // 'use strict' => this === undefined (Clean Scope)
+  // Safer for possible security issues, albeit not critical at all here
+  // eslint-disable-next-line no-new-func, no-param-reassign
+  const evaluatedOptions = new Function("exports", "require", "module", "__filename", "__dirname", `'use strict'\nreturn ${options}`)(exports, require, module, __filename, __dirname);
+  return minify(evaluatedOptions);
+}
+
+module.exports = {
+  minify,
+  transform
+};

node_modules/css-minimizer-webpack-plugin/dist/options.json

@@ -0,0 +1,121 @@
+{
+  "definitions": {
+    "Rule": {
+      "description": "Filtering rule as regex or string.",
+      "anyOf": [
+        {
+          "instanceof": "RegExp",
+          "tsType": "RegExp"
+        },
+        {
+          "type": "string",
+          "minLength": 1
+        }
+      ]
+    },
+    "Rules": {
+      "description": "Filtering rules.",
+      "anyOf": [
+        {
+          "type": "array",
+          "items": {
+            "description": "A rule condition.",
+            "oneOf": [
+              {
+                "$ref": "#/definitions/Rule"
+              }
+            ]
+          }
+        },
+        {
+          "$ref": "#/definitions/Rule"
+        }
+      ]
+    },
+    "MinimizerOptions": {
+      "additionalProperties": true,
+      "type": "object"
+    }
+  },
+  "title": "CssMinimizerWebpackPluginOptions",
+  "type": "object",
+  "properties": {
+    "test": {
+      "description": "Include all modules that pass test assertion.",
+      "link": "https://github.com/webpack-contrib/css-minimizer-webpack-plugin/#test",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/Rules"
+        }
+      ]
+    },
+    "include": {
+      "description": "Include all modules matching any of these conditions.",
+      "link": "https://github.com/webpack-contrib/css-minimizer-webpack-plugin/#include",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/Rules"
+        }
+      ]
+    },
+    "exclude": {
+      "description": "Exclude all modules matching any of these conditions.",
+      "link": "https://github.com/webpack-contrib/css-minimizer-webpack-plugin/#exclude",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/Rules"
+        }
+      ]
+    },
+    "minimizerOptions": {
+      "description": "Options for `cssMinimizerOptions`.",
+      "link": "https://github.com/webpack-contrib/css-minimizer-webpack-plugin/#minimizeroptions",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/MinimizerOptions"
+        },
+        {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "$ref": "#/definitions/MinimizerOptions"
+          }
+        }
+      ]
+    },
+    "parallel": {
+      "description": "Use multi-process parallel running to improve the build speed.",
+      "link": "https://github.com/webpack-contrib/css-minimizer-webpack-plugin/#parallel",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "integer"
+        }
+      ]
+    },
+    "warningsFilter": {
+      "description": "Allow to filter `css minimizer` warnings.",
+      "link": "https://github.com/webpack-contrib/css-minimizer-webpack-plugin/#warningsfilter",
+      "instanceof": "Function"
+    },
+    "minify": {
+      "description": "Allows you to override default minify function.",
+      "link": "https://github.com/webpack-contrib/css-minimizer-webpack-plugin/#minify",
+      "anyOf": [
+        {
+          "instanceof": "Function"
+        },
+        {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "instanceof": "Function"
+          }
+        }
+      ]
+    }
+  },
+  "additionalProperties": false
+}

node_modules/css-minimizer-webpack-plugin/dist/utils.js

@@ -0,0 +1,363 @@
+"use strict";
+
+/** @typedef {import("./index.js").Input} Input */
+
+/** @typedef {import("source-map").RawSourceMap} RawSourceMap */
+
+/** @typedef {import("source-map").SourceMapGenerator} SourceMapGenerator */
+
+/** @typedef {import("./index.js").MinimizedResult} MinimizedResult */
+
+/** @typedef {import("./index.js").CustomOptions} CustomOptions */
+
+/** @typedef {import("postcss").ProcessOptions} ProcessOptions */
+
+/** @typedef {import("postcss").Postcss} Postcss */
+const notSettled = Symbol(`not-settled`);
+/**
+ * @template T
+ * @typedef {() => Promise<T>} Task
+ */
+
+/**
+ * Run tasks with limited concurency.
+ * @template T
+ * @param {number} limit - Limit of tasks that run at once.
+ * @param {Task<T>[]} tasks - List of tasks to run.
+ * @returns {Promise<T[]>} A promise that fulfills to an array of the results
+ */
+
+function throttleAll(limit, tasks) {
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new TypeError(`Expected \`limit\` to be a finite number > 0, got \`${limit}\` (${typeof limit})`);
+  }
+
+  if (!Array.isArray(tasks) || !tasks.every(task => typeof task === `function`)) {
+    throw new TypeError(`Expected \`tasks\` to be a list of functions returning a promise`);
+  }
+
+  return new Promise((resolve, reject) => {
+    const result = Array(tasks.length).fill(notSettled);
+    const entries = tasks.entries();
+
+    const next = () => {
+      const {
+        done,
+        value
+      } = entries.next();
+
+      if (done) {
+        const isLast = !result.includes(notSettled);
+        if (isLast) resolve(result);
+        return;
+      }
+
+      const [index, task] = value;
+      /**
+       * @param {T} x
+       */
+
+      const onFulfilled = x => {
+        result[index] = x;
+        next();
+      };
+
+      task().then(onFulfilled, reject);
+    };
+
+    Array(limit).fill(0).forEach(next);
+  });
+}
+/* istanbul ignore next */
+
+/**
+ * @param {Input} input
+ * @param {RawSourceMap | undefined} sourceMap
+ * @param {CustomOptions} minimizerOptions
+ * @return {Promise<MinimizedResult>}
+ */
+
+
+async function cssnanoMinify(input, sourceMap, minimizerOptions = {
+  preset: "default"
+}) {
+  /**
+   * @template T
+   * @param {string} module
+   * @returns {Promise<T>}
+   */
+  const load = async module => {
+    let exports;
+
+    try {
+      // eslint-disable-next-line import/no-dynamic-require, global-require
+      exports = require(module);
+      return exports;
+    } catch (requireError) {
+      let importESM;
+
+      try {
+        // eslint-disable-next-line no-new-func
+        importESM = new Function("id", "return import(id);");
+      } catch (e) {
+        importESM = null;
+      }
+
+      if (
+      /** @type {Error & {code: string}} */
+      requireError.code === "ERR_REQUIRE_ESM" && importESM) {
+        exports = await importESM(module);
+        return exports.default;
+      }
+
+      throw requireError;
+    }
+  };
+
+  const [[name, code]] = Object.entries(input);
+  /** @type {ProcessOptions} */
+
+  const postcssOptions = {
+    from: name,
+    ...minimizerOptions.processorOptions
+  };
+
+  if (typeof postcssOptions.parser === "string") {
+    try {
+      postcssOptions.parser = await load(postcssOptions.parser);
+    } catch (error) {
+      throw new Error(`Loading PostCSS "${postcssOptions.parser}" parser failed: ${
+      /** @type {Error} */
+      error.message}\n\n(@${name})`);
+    }
+  }
+
+  if (typeof postcssOptions.stringifier === "string") {
+    try {
+      postcssOptions.stringifier = await load(postcssOptions.stringifier);
+    } catch (error) {
+      throw new Error(`Loading PostCSS "${postcssOptions.stringifier}" stringifier failed: ${
+      /** @type {Error} */
+      error.message}\n\n(@${name})`);
+    }
+  }
+
+  if (typeof postcssOptions.syntax === "string") {
+    try {
+      postcssOptions.syntax = await load(postcssOptions.syntax);
+    } catch (error) {
+      throw new Error(`Loading PostCSS "${postcssOptions.syntax}" syntax failed: ${
+      /** @type {Error} */
+      error.message}\n\n(@${name})`);
+    }
+  }
+
+  if (sourceMap) {
+    postcssOptions.map = {
+      annotation: false
+    };
+  }
+  /** @type {Postcss} */
+  // eslint-disable-next-line global-require
+
+
+  const postcss = require("postcss").default; // @ts-ignore
+  // eslint-disable-next-line global-require
+
+
+  const cssnano = require("cssnano"); // @ts-ignore
+  // Types are broken
+
+
+  const result = await postcss([cssnano(minimizerOptions)]).process(code, postcssOptions);
+  return {
+    code: result.css,
+    map: result.map ? result.map.toJSON() : // eslint-disable-next-line no-undefined
+    undefined,
+    warnings: result.warnings().map(String)
+  };
+}
+/* istanbul ignore next */
+
+/**
+ * @param {Input} input
+ * @param {RawSourceMap | undefined} sourceMap
+ * @param {CustomOptions} minimizerOptions
+ * @return {Promise<MinimizedResult>}
+ */
+
+
+async function cssoMinify(input, sourceMap, minimizerOptions) {
+  // eslint-disable-next-line global-require,import/no-extraneous-dependencies
+  const csso = require("csso");
+
+  const [[filename, code]] = Object.entries(input);
+  const result = csso.minify(code, {
+    filename,
+    sourceMap: Boolean(sourceMap),
+    ...minimizerOptions
+  });
+  return {
+    code: result.css,
+    map: result.map ?
+    /** @type {SourceMapGenerator & { toJSON(): RawSourceMap }} */
+    result.map.toJSON() : // eslint-disable-next-line no-undefined
+    undefined
+  };
+}
+/* istanbul ignore next */
+
+/**
+ * @param {Input} input
+ * @param {RawSourceMap | undefined} sourceMap
+ * @param {CustomOptions} minimizerOptions
+ * @return {Promise<MinimizedResult>}
+ */
+
+
+async function cleanCssMinify(input, sourceMap, minimizerOptions) {
+  // eslint-disable-next-line global-require,import/no-extraneous-dependencies
+  const CleanCSS = require("clean-css");
+
+  const [[name, code]] = Object.entries(input);
+  const result = await new CleanCSS({
+    sourceMap: Boolean(sourceMap),
+    ...minimizerOptions,
+    returnPromise: true
+  }).minify({
+    [name]: {
+      styles: code
+    }
+  });
+  const generatedSourceMap = result.sourceMap &&
+  /** @type {SourceMapGenerator & { toJSON(): RawSourceMap }} */
+  result.sourceMap.toJSON(); // workaround for source maps on windows
+
+  if (generatedSourceMap) {
+    // eslint-disable-next-line global-require
+    const isWindowsPathSep = require("path").sep === "\\";
+    generatedSourceMap.sources = generatedSourceMap.sources.map(
+    /**
+     * @param {string} item
+     * @returns {string}
+     */
+    item => isWindowsPathSep ? item.replace(/\\/g, "/") : item);
+  }
+
+  return {
+    code: result.styles,
+    map: generatedSourceMap,
+    warnings: result.warnings
+  };
+}
+/* istanbul ignore next */
+
+/**
+ * @param {Input} input
+ * @param {RawSourceMap | undefined} sourceMap
+ * @param {CustomOptions} minimizerOptions
+ * @return {Promise<MinimizedResult>}
+ */
+
+
+async function esbuildMinify(input, sourceMap, minimizerOptions) {
+  /**
+   * @param {import("esbuild").TransformOptions} [esbuildOptions={}]
+   * @returns {import("esbuild").TransformOptions}
+   */
+  const buildEsbuildOptions = (esbuildOptions = {}) => {
+    // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+    return {
+      loader: "css",
+      minify: true,
+      legalComments: "inline",
+      ...esbuildOptions,
+      sourcemap: false
+    };
+  }; // eslint-disable-next-line import/no-extraneous-dependencies, global-require
+
+
+  const esbuild = require("esbuild"); // Copy `esbuild` options
+
+
+  const esbuildOptions = buildEsbuildOptions(minimizerOptions); // Let `esbuild` generate a SourceMap
+
+  if (sourceMap) {
+    esbuildOptions.sourcemap = true;
+    esbuildOptions.sourcesContent = false;
+  }
+
+  const [[filename, code]] = Object.entries(input);
+  esbuildOptions.sourcefile = filename;
+  const result = await esbuild.transform(code, esbuildOptions);
+  return {
+    code: result.code,
+    // eslint-disable-next-line no-undefined
+    map: result.map ? JSON.parse(result.map) : undefined,
+    warnings: result.warnings.length > 0 ? result.warnings.map(item => {
+      return {
+        source: item.location && item.location.file,
+        // eslint-disable-next-line no-undefined
+        line: item.location && item.location.line ? item.location.line : undefined,
+        // eslint-disable-next-line no-undefined
+        column: item.location && item.location.column ? item.location.column : undefined,
+        plugin: item.pluginName,
+        message: `${item.text}${item.detail ? `\nDetails:\n${item.detail}` : ""}${item.notes.length > 0 ? `\n\nNotes:\n${item.notes.map(note => `${note.location ? `[${note.location.file}:${note.location.line}:${note.location.column}] ` : ""}${note.text}${note.location ? `\nSuggestion: ${note.location.suggestion}` : ""}${note.location ? `\nLine text:\n${note.location.lineText}\n` : ""}`).join("\n")}` : ""}`
+      };
+    }) : []
+  };
+}
+/* istanbul ignore next */
+
+/**
+ * @param {Input} input
+ * @param {RawSourceMap | undefined} sourceMap
+ * @param {CustomOptions} minimizerOptions
+ * @return {Promise<MinimizedResult>}
+ */
+
+
+async function parcelCssMinify(input, sourceMap, minimizerOptions) {
+  const [[filename, code]] = Object.entries(input);
+  /**
+   * @param {Partial<import("@parcel/css").TransformOptions>} [parcelCssOptions={}]
+   * @returns {import("@parcel/css").TransformOptions}
+   */
+
+  const buildParcelCssOptions = (parcelCssOptions = {}) => {
+    // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+    return {
+      minify: true,
+      ...parcelCssOptions,
+      sourceMap: false,
+      filename,
+      code: Buffer.from(code)
+    };
+  }; // eslint-disable-next-line import/no-extraneous-dependencies, global-require
+
+
+  const parcelCss = require("@parcel/css"); // Copy `esbuild` options
+
+
+  const parcelCssOptions = buildParcelCssOptions(minimizerOptions); // Let `esbuild` generate a SourceMap
+
+  if (sourceMap) {
+    parcelCssOptions.sourceMap = true;
+  }
+
+  const result = await parcelCss.transform(parcelCssOptions);
+  return {
+    code: result.code.toString(),
+    // eslint-disable-next-line no-undefined
+    map: result.map ? JSON.parse(result.map.toString()) : undefined
+  };
+}
+
+module.exports = {
+  throttleAll,
+  cssnanoMinify,
+  cssoMinify,
+  cleanCssMinify,
+  esbuildMinify,
+  parcelCssMinify
+};

node_modules/css-minimizer-webpack-plugin/node_modules/ajv-keywords/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Evgeny Poberezkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/css-minimizer-webpack-plugin/node_modules/ajv-keywords/README.md

@@ -0,0 +1,745 @@
+# ajv-keywords
+
+Custom JSON-Schema keywords for [Ajv](https://github.com/epoberezkin/ajv) validator
+
+[![build](https://github.com/ajv-validator/ajv-keywords/workflows/build/badge.svg)](https://github.com/ajv-validator/ajv-keywords/actions?query=workflow%3Abuild)
+[![npm](https://img.shields.io/npm/v/ajv-keywords.svg)](https://www.npmjs.com/package/ajv-keywords)
+[![npm downloads](https://img.shields.io/npm/dm/ajv-keywords.svg)](https://www.npmjs.com/package/ajv-keywords)
+[![coverage](https://coveralls.io/repos/github/ajv-validator/ajv-keywords/badge.svg?branch=master)](https://coveralls.io/github/ajv-validator/ajv-keywords?branch=master)
+[![gitter](https://img.shields.io/gitter/room/ajv-validator/ajv.svg)](https://gitter.im/ajv-validator/ajv)
+
+**Please note**: This readme file is for [ajv-keywords v5.0.0](https://github.com/ajv-validator/ajv-keywords/releases/tag/v5.0.0) that should be used with [ajv v8](https://github.com/ajv-validator/ajv).
+
+[ajv-keywords v3](https://github.com/ajv-validator/ajv-keywords/tree/v3) should be used with [ajv v6](https://github.com/ajv-validator/ajv/tree/v6).
+
+## Contents
+
+- [Install](#install)
+- [Usage](#usage)
+- [Keywords](#keywords)
+  - [Types](#types)
+    - [typeof](#typeof)
+    - [instanceof](#instanceof)<sup>\+</sup>
+  - [Keywords for numbers](#keywords-for-numbers)
+    - [range and exclusiveRange](#range-and-exclusiverange)
+  - [Keywords for strings](#keywords-for-strings)
+    - [regexp](#regexp)
+    - [transform](#transform)<sup>\*</sup>
+  - [Keywords for arrays](#keywords-for-arrays)
+    - [uniqueItemProperties](#uniqueitemproperties)<sup>\+</sup>
+  - [Keywords for objects](#keywords-for-objects)
+    - [allRequired](#allrequired)
+    - [anyRequired](#anyrequired)
+    - [oneRequired](#onerequired)
+    - [patternRequired](#patternrequired)
+    - [prohibited](#prohibited)
+    - [deepProperties](#deepproperties)
+    - [deepRequired](#deeprequired)
+    - [dynamicDefaults](#dynamicdefaults)<sup>\*</sup><sup>\+</sup>
+  - [Keywords for all types](#keywords-for-all-types)
+    - [select/selectCases/selectDefault](#selectselectcasesselectdefault)
+- [Security contact](#security-contact)
+- [Open-source software support](#open-source-software-support)
+- [License](#license)
+
+<sup>\*</sup> - keywords that modify data
+<sup>\+</sup> - keywords that are not supported in [standalone validation code](https://github.com/ajv-validator/ajv/blob/master/docs/standalone.md)
+
+## Install
+
+To install version 4 to use with [Ajv v7](https://github.com/ajv-validator/ajv):
+
+```
+npm install ajv-keywords
+```
+
+## Usage
+
+To add all available keywords:
+
+```javascript
+const Ajv = require("ajv")
+const ajv = new Ajv()
+require("ajv-keywords")(ajv)
+
+ajv.validate({instanceof: "RegExp"}, /.*/) // true
+ajv.validate({instanceof: "RegExp"}, ".*") // false
+```
+
+To add a single keyword:
+
+```javascript
+require("ajv-keywords")(ajv, "instanceof")
+```
+
+To add multiple keywords:
+
+```javascript
+require("ajv-keywords")(ajv, ["typeof", "instanceof"])
+```
+
+To add a single keyword directly (to avoid adding unused code):
+
+```javascript
+require("ajv-keywords/dist/keywords/select")(ajv, opts)
+```
+
+To add all keywords via Ajv options:
+
+```javascript
+const ajv = new Ajv({keywords: require("ajv-keywords/dist/definitions")(opts)})
+```
+
+To add one or several keywords via options:
+
+```javascript
+const ajv = new Ajv({
+  keywords: [
+    require("ajv-keywords/dist/definitions/typeof")(),
+    require("ajv-keywords/dist/definitions/instanceof")(),
+    // select exports an array of 3 definitions - see "select" in docs
+    ...require("ajv-keywords/dist/definitions/select")(opts),
+  ],
+})
+```
+
+`opts` is an optional object with a property `defaultMeta` - URI of meta-schema to use for keywords that use subschemas (`select` and `deepProperties`). The default is `"http://json-schema.org/schema"`.
+
+## Keywords
+
+### Types
+
+#### `typeof`
+
+Based on JavaScript `typeof` operation.
+
+The value of the keyword should be a string (`"undefined"`, `"string"`, `"number"`, `"object"`, `"function"`, `"boolean"` or `"symbol"`) or an array of strings.
+
+To pass validation the result of `typeof` operation on the value should be equal to the string (or one of the strings in the array).
+
+```javascript
+ajv.validate({typeof: "undefined"}, undefined) // true
+ajv.validate({typeof: "undefined"}, null) // false
+ajv.validate({typeof: ["undefined", "object"]}, null) // true
+```
+
+#### `instanceof`
+
+Based on JavaScript `instanceof` operation.
+
+The value of the keyword should be a string (`"Object"`, `"Array"`, `"Function"`, `"Number"`, `"String"`, `"Date"`, `"RegExp"` or `"Promise"`) or an array of strings.
+
+To pass validation the result of `data instanceof ...` operation on the value should be true:
+
+```javascript
+ajv.validate({instanceof: "Array"}, []) // true
+ajv.validate({instanceof: "Array"}, {}) // false
+ajv.validate({instanceof: ["Array", "Function"]}, function () {}) // true
+```
+
+You can add your own constructor function to be recognised by this keyword:
+
+```javascript
+class MyClass {}
+const instanceofDef = require("ajv-keywords/dist/definitions/instanceof")
+instanceofDef.CONSTRUCTORS.MyClass = MyClass
+ajv.validate({instanceof: "MyClass"}, new MyClass()) // true
+```
+
+**Please note**: currently `instanceof` is not supported in [standalone validation code](https://github.com/ajv-validator/ajv/blob/master/docs/standalone.md) - it has to be implemented as [`code` keyword](https://github.com/ajv-validator/ajv/blob/master/docs/keywords.md#define-keyword-with-code-generation-function) to support it (PR is welcome).
+
+### Keywords for numbers
+
+#### `range` and `exclusiveRange`
+
+Syntax sugar for the combination of minimum and maximum keywords (or exclusiveMinimum and exclusiveMaximum), also fails schema compilation if there are no numbers in the range.
+
+The value of these keywords must be an array consisting of two numbers, the second must be greater or equal than the first one.
+
+If the validated value is not a number the validation passes, otherwise to pass validation the value should be greater (or equal) than the first number and smaller (or equal) than the second number in the array.
+
+```javascript
+const schema = {type: "number", range: [1, 3]}
+ajv.validate(schema, 1) // true
+ajv.validate(schema, 2) // true
+ajv.validate(schema, 3) // true
+ajv.validate(schema, 0.99) // false
+ajv.validate(schema, 3.01) // false
+
+const schema = {type: "number", exclusiveRange: [1, 3]}
+ajv.validate(schema, 1.01) // true
+ajv.validate(schema, 2) // true
+ajv.validate(schema, 2.99) // true
+ajv.validate(schema, 1) // false
+ajv.validate(schema, 3) // false
+```
+
+### Keywords for strings
+
+#### `regexp`
+
+This keyword allows to use regular expressions with flags in schemas, and also without `"u"` flag when needed (the standard `pattern` keyword does not support flags and implies the presence of `"u"` flag).
+
+This keyword applies only to strings. If the data is not a string, the validation succeeds.
+
+The value of this keyword can be either a string (the result of `regexp.toString()`) or an object with the properties `pattern` and `flags` (the same strings that should be passed to RegExp constructor).
+
+```javascript
+const schema = {
+  type: "object",
+  properties: {
+    foo: {type: "string", regexp: "/foo/i"},
+    bar: {type: "string", regexp: {pattern: "bar", flags: "i"}},
+  },
+}
+
+const validData = {
+  foo: "Food",
+  bar: "Barmen",
+}
+
+const invalidData = {
+  foo: "fog",
+  bar: "bad",
+}
+```
+
+#### `transform`
+
+This keyword allows a string to be modified during validation.
+
+This keyword applies only to strings. If the data is not a string, the `transform` keyword is ignored.
+
+A standalone string cannot be modified, i.e. `data = 'a'; ajv.validate(schema, data);`, because strings are passed by value
+
+**Supported transformations:**
+
+- `trim`: remove whitespace from start and end
+- `trimStart`/`trimLeft`: remove whitespace from start
+- `trimEnd`/`trimRight`: remove whitespace from end
+- `toLowerCase`: convert to lower case
+- `toUpperCase`: convert to upper case
+- `toEnumCase`: change string case to be equal to one of `enum` values in the schema
+
+Transformations are applied in the order they are listed.
+
+Note: `toEnumCase` requires that all allowed values are unique when case insensitive.
+
+**Example: multiple transformations**
+
+```javascript
+require("ajv-keywords")(ajv, "transform")
+
+const schema = {
+  type: "array",
+  items: {
+    type: "string",
+    transform: ["trim", "toLowerCase"],
+  },
+}
+
+const data = ["  MixCase  "]
+ajv.validate(schema, data)
+console.log(data) // ['mixcase']
+```
+
+**Example: `enumcase`**
+
+```javascript
+require("ajv-keywords")(ajv, ["transform"])
+
+const schema = {
+  type: "array",
+  items: {
+    type: "string",
+    transform: ["trim", "toEnumCase"],
+    enum: ["pH"],
+  },
+}
+
+const data = ["ph", " Ph", "PH", "pH "]
+ajv.validate(schema, data)
+console.log(data) // ['pH','pH','pH','pH']
+```
+
+### Keywords for arrays
+
+#### `uniqueItemProperties`
+
+The keyword allows to check that some properties in array items are unique.
+
+This keyword applies only to arrays. If the data is not an array, the validation succeeds.
+
+The value of this keyword must be an array of strings - property names that should have unique values across all items.
+
+```javascript
+const schema = {
+  type: "array",
+  uniqueItemProperties: ["id", "name"],
+}
+
+const validData = [{id: 1}, {id: 2}, {id: 3}]
+
+const invalidData1 = [
+  {id: 1},
+  {id: 1}, // duplicate "id"
+  {id: 3},
+]
+
+const invalidData2 = [
+  {id: 1, name: "taco"},
+  {id: 2, name: "taco"}, // duplicate "name"
+  {id: 3, name: "salsa"},
+]
+```
+
+This keyword is contributed by [@blainesch](https://github.com/blainesch).
+
+**Please note**: currently `uniqueItemProperties` is not supported in [standalone validation code](https://github.com/ajv-validator/ajv/blob/master/docs/standalone.md) - it has to be implemented as [`code` keyword](https://github.com/ajv-validator/ajv/blob/master/docs/keywords.md#define-keyword-with-code-generation-function) to support it (PR is welcome).
+
+### Keywords for objects
+
+#### `allRequired`
+
+This keyword allows to require the presence of all properties used in `properties` keyword in the same schema object.
+
+This keyword applies only to objects. If the data is not an object, the validation succeeds.
+
+The value of this keyword must be boolean.
+
+If the value of the keyword is `false`, the validation succeeds.
+
+If the value of the keyword is `true`, the validation succeeds if the data contains all properties defined in `properties` keyword (in the same schema object).
+
+If the `properties` keyword is not present in the same schema object, schema compilation will throw exception.
+
+```javascript
+const schema = {
+  type: "object",
+  properties: {
+    foo: {type: "number"},
+    bar: {type: "number"},
+  },
+  allRequired: true,
+}
+
+const validData = {foo: 1, bar: 2}
+const alsoValidData = {foo: 1, bar: 2, baz: 3}
+
+const invalidDataList = [{}, {foo: 1}, {bar: 2}]
+```
+
+#### `anyRequired`
+
+This keyword allows to require the presence of any (at least one) property from the list.
+
+This keyword applies only to objects. If the data is not an object, the validation succeeds.
+
+The value of this keyword must be an array of strings, each string being a property name. For data object to be valid at least one of the properties in this array should be present in the object.
+
+```javascript
+const schema = {
+  type: "object",
+  anyRequired: ["foo", "bar"],
+}
+
+const validData = {foo: 1}
+const alsoValidData = {foo: 1, bar: 2}
+
+const invalidDataList = [{}, {baz: 3}]
+```
+
+#### `oneRequired`
+
+This keyword allows to require the presence of only one property from the list.
+
+This keyword applies only to objects. If the data is not an object, the validation succeeds.
+
+The value of this keyword must be an array of strings, each string being a property name. For data object to be valid exactly one of the properties in this array should be present in the object.
+
+```javascript
+const schema = {
+  type: "object",
+  oneRequired: ["foo", "bar"],
+}
+
+const validData = {foo: 1}
+const alsoValidData = {bar: 2, baz: 3}
+
+const invalidDataList = [{}, {baz: 3}, {foo: 1, bar: 2}]
+```
+
+#### `patternRequired`
+
+This keyword allows to require the presence of properties that match some pattern(s).
+
+This keyword applies only to objects. If the data is not an object, the validation succeeds.
+
+The value of this keyword should be an array of strings, each string being a regular expression. For data object to be valid each regular expression in this array should match at least one property name in the data object.
+
+If the array contains multiple regular expressions, more than one expression can match the same property name.
+
+```javascript
+const schema = {
+  type: "object",
+  patternRequired: ["f.*o", "b.*r"],
+}
+
+const validData = {foo: 1, bar: 2}
+const alsoValidData = {foobar: 3}
+
+const invalidDataList = [{}, {foo: 1}, {bar: 2}]
+```
+
+#### `prohibited`
+
+This keyword allows to prohibit that any of the properties in the list is present in the object.
+
+This keyword applies only to objects. If the data is not an object, the validation succeeds.
+
+The value of this keyword should be an array of strings, each string being a property name. For data object to be valid none of the properties in this array should be present in the object.
+
+```javascript
+const schema = {
+  type: "object",
+  prohibited: ["foo", "bar"],
+}
+
+const validData = {baz: 1}
+const alsoValidData = {}
+
+const invalidDataList = [{foo: 1}, {bar: 2}, {foo: 1, bar: 2}]
+```
+
+**Please note**: `{prohibited: ['foo', 'bar']}` is equivalent to `{not: {anyRequired: ['foo', 'bar']}}` (i.e. it has the same validation result for any data).
+
+#### `deepProperties`
+
+This keyword allows to validate deep properties (identified by JSON pointers).
+
+This keyword applies only to objects. If the data is not an object, the validation succeeds.
+
+The value should be an object, where keys are JSON pointers to the data, starting from the current position in data, and the values are JSON schemas. For data object to be valid the value of each JSON pointer should be valid according to the corresponding schema.
+
+```javascript
+const schema = {
+  type: "object",
+  deepProperties: {
+    "/users/1/role": {enum: ["admin"]},
+  },
+}
+
+const validData = {
+  users: [
+    {},
+    {
+      id: 123,
+      role: "admin",
+    },
+  ],
+}
+
+const alsoValidData = {
+  users: {
+    1: {
+      id: 123,
+      role: "admin",
+    },
+  },
+}
+
+const invalidData = {
+  users: [
+    {},
+    {
+      id: 123,
+      role: "user",
+    },
+  ],
+}
+
+const alsoInvalidData = {
+  users: {
+    1: {
+      id: 123,
+      role: "user",
+    },
+  },
+}
+```
+
+#### `deepRequired`
+
+This keyword allows to check that some deep properties (identified by JSON pointers) are available.
+
+This keyword applies only to objects. If the data is not an object, the validation succeeds.
+
+The value should be an array of JSON pointers to the data, starting from the current position in data. For data object to be valid each JSON pointer should be some existing part of the data.
+
+```javascript
+const schema = {
+  type: "object",
+  deepRequired: ["/users/1/role"],
+}
+
+const validData = {
+  users: [
+    {},
+    {
+      id: 123,
+      role: "admin",
+    },
+  ],
+}
+
+const invalidData = {
+  users: [
+    {},
+    {
+      id: 123,
+    },
+  ],
+}
+```
+
+See [json-schema-org/json-schema-spec#203](https://github.com/json-schema-org/json-schema-spec/issues/203#issue-197211916) for an example of the equivalent schema without `deepRequired` keyword.
+
+### Keywords for all types
+
+#### `select`/`selectCases`/`selectDefault`
+
+**Please note**: these keywords are deprecated. It is recommended to use OpenAPI [discriminator](https://ajv.js.org/json-schema.html#discriminator) keyword supported by Ajv v8 instead of `select`.
+
+These keywords allow to choose the schema to validate the data based on the value of some property in the validated data.
+
+These keywords must be present in the same schema object (`selectDefault` is optional).
+
+The value of `select` keyword should be a [\$data reference](https://github.com/ajv-validator/ajv/blob/master/docs/validation.md#data-reference) that points to any primitive JSON type (string, number, boolean or null) in the data that is validated. You can also use a constant of primitive type as the value of this keyword (e.g., for debugging purposes).
+
+The value of `selectCases` keyword must be an object where each property name is a possible string representation of the value of `select` keyword and each property value is a corresponding schema (from draft-06 it can be boolean) that must be used to validate the data.
+
+The value of `selectDefault` keyword is a schema (also can be boolean) that must be used to validate the data in case `selectCases` has no key equal to the stringified value of `select` keyword.
+
+The validation succeeds in one of the following cases:
+
+- the validation of data using selected schema succeeds,
+- none of the schemas is selected for validation,
+- the value of select is undefined (no property in the data that the data reference points to).
+
+If `select` value (in data) is not a primitive type the validation fails.
+
+This keyword correctly tracks evaluated properties and items to work with `unevaluatedProperties` and `unevaluatedItems` keywords - only properties and items from the subschema that was used (one of `selectCases` subschemas or `selectDefault` subschema) are marked as evaluated.
+
+**Please note**: these keywords require Ajv `$data` option to support [\$data reference](https://github.com/ajv-validator/ajv/blob/master/docs/validation.md#data-reference).
+
+```javascript
+require("ajv-keywords")(ajv, "select")
+
+const schema = {
+  type: "object",
+  required: ["kind"],
+  properties: {
+    kind: {type: "string"},
+  },
+  select: {$data: "0/kind"},
+  selectCases: {
+    foo: {
+      required: ["foo"],
+      properties: {
+        kind: {},
+        foo: {type: "string"},
+      },
+      additionalProperties: false,
+    },
+    bar: {
+      required: ["bar"],
+      properties: {
+        kind: {},
+        bar: {type: "number"},
+      },
+      additionalProperties: false,
+    },
+  },
+  selectDefault: {
+    propertyNames: {
+      not: {enum: ["foo", "bar"]},
+    },
+  },
+}
+
+const validDataList = [
+  {kind: "foo", foo: "any"},
+  {kind: "bar", bar: 1},
+  {kind: "anything_else", not_bar_or_foo: "any value"},
+]
+
+const invalidDataList = [
+  {kind: "foo"}, // no property foo
+  {kind: "bar"}, // no property bar
+  {kind: "foo", foo: "any", another: "any value"}, // additional property
+  {kind: "bar", bar: 1, another: "any value"}, // additional property
+  {kind: "anything_else", foo: "any"}, // property foo not allowed
+  {kind: "anything_else", bar: 1}, // property bar not allowed
+]
+```
+
+#### `dynamicDefaults`
+
+This keyword allows to assign dynamic defaults to properties, such as timestamps, unique IDs etc.
+
+This keyword only works if `useDefaults` options is used and not inside `anyOf` keywords etc., in the same way as [default keyword treated by Ajv](https://github.com/epoberezkin/ajv#assigning-defaults).
+
+The keyword should be added on the object level. Its value should be an object with each property corresponding to a property name, in the same way as in standard `properties` keyword. The value of each property can be:
+
+- an identifier of dynamic default function (a string)
+- an object with properties `func` (an identifier) and `args` (an object with parameters that will be passed to this function during schema compilation - see examples).
+
+The properties used in `dynamicDefaults` should not be added to `required` keyword in the same schema (or validation will fail), because unlike `default` this keyword is processed after validation.
+
+There are several predefined dynamic default functions:
+
+- `"timestamp"` - current timestamp in milliseconds
+- `"datetime"` - current date and time as string (ISO, valid according to `date-time` format)
+- `"date"` - current date as string (ISO, valid according to `date` format)
+- `"time"` - current time as string (ISO, valid according to `time` format)
+- `"random"` - pseudo-random number in [0, 1) interval
+- `"randomint"` - pseudo-random integer number. If string is used as a property value, the function will randomly return 0 or 1. If object `{ func: 'randomint', args: { max: N } }` is used then the default will be an integer number in [0, N) interval.
+- `"seq"` - sequential integer number starting from 0. If string is used as a property value, the default sequence will be used. If object `{ func: 'seq', args: { name: 'foo'} }` is used then the sequence with name `"foo"` will be used. Sequences are global, even if different ajv instances are used.
+
+```javascript
+const schema = {
+  type: "object",
+  dynamicDefaults: {
+    ts: "datetime",
+    r: {func: "randomint", args: {max: 100}},
+    id: {func: "seq", args: {name: "id"}},
+  },
+  properties: {
+    ts: {
+      type: "string",
+      format: "date-time",
+    },
+    r: {
+      type: "integer",
+      minimum: 0,
+      exclusiveMaximum: 100,
+    },
+    id: {
+      type: "integer",
+      minimum: 0,
+    },
+  },
+}
+
+const data = {}
+ajv.validate(data) // true
+data // { ts: '2016-12-01T22:07:28.829Z', r: 25, id: 0 }
+
+const data1 = {}
+ajv.validate(data1) // true
+data1 // { ts: '2016-12-01T22:07:29.832Z', r: 68, id: 1 }
+
+ajv.validate(data1) // true
+data1 // didn't change, as all properties were defined
+```
+
+When using the `useDefaults` option value `"empty"`, properties and items equal to `null` or `""` (empty string) will be considered missing and assigned defaults. Use `allOf` [compound keyword](https://github.com/epoberezkin/ajv/blob/master/KEYWORDS.md#compound-keywords) to execute `dynamicDefaults` before validation.
+
+```javascript
+const schema = {
+  type: "object",
+  allOf: [
+    {
+      dynamicDefaults: {
+        ts: "datetime",
+        r: {func: "randomint", args: {min: 5, max: 100}},
+        id: {func: "seq", args: {name: "id"}},
+      },
+    },
+    {
+      properties: {
+        ts: {
+          type: "string",
+        },
+        r: {
+          type: "number",
+          minimum: 5,
+          exclusiveMaximum: 100,
+        },
+        id: {
+          type: "integer",
+          minimum: 0,
+        },
+      },
+    },
+  ],
+}
+
+const data = {ts: "", r: null}
+ajv.validate(data) // true
+data // { ts: '2016-12-01T22:07:28.829Z', r: 25, id: 0 }
+```
+
+You can add your own dynamic default function to be recognised by this keyword:
+
+```javascript
+const uuid = require("uuid")
+
+const def = require("ajv-keywords/dist/definitions/dynamicDefaults")
+def.DEFAULTS.uuid = () => uuid.v4
+
+const schema = {
+  dynamicDefaults: {id: "uuid"},
+  properties: {id: {type: "string", format: "uuid"}},
+}
+
+const data = {}
+ajv.validate(schema, data) // true
+data // { id: 'a1183fbe-697b-4030-9bcc-cfeb282a9150' };
+
+const data1 = {}
+ajv.validate(schema, data1) // true
+data1 // { id: '5b008de7-1669-467a-a5c6-70fa244d7209' }
+```
+
+You also can define dynamic default that accept parameters, e.g. version of uuid:
+
+```javascript
+const uuid = require("uuid")
+
+function getUuid(args) {
+  const version = "v" + ((arvs && args.v) || "4")
+  return uuid[version]
+}
+
+const def = require("ajv-keywords/dist/definitions/dynamicDefaults")
+def.DEFAULTS.uuid = getUuid
+
+const schema = {
+  dynamicDefaults: {
+    id1: "uuid", // v4
+    id2: {func: "uuid", v: 4}, // v4
+    id3: {func: "uuid", v: 1}, // v1
+  },
+}
+```
+
+**Please note**: dynamic default functions are differentiated by the number of parameters they have (`function.length`). Functions that do not expect default must have one non-optional argument so that `function.length` > 0.
+
+`dynamicDefaults` is not supported in [standalone validation code](https://github.com/ajv-validator/ajv/blob/master/docs/standalone.md).
+
+## Security contact
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.
+
+Please do NOT report security vulnerabilities via GitHub issues.
+
+## Open-source software support
+
+Ajv-keywords is a part of [Tidelift subscription](https://tidelift.com/subscription/pkg/npm-ajv-keywords?utm_source=npm-ajv-keywords&utm_medium=referral&utm_campaign=readme) - it provides a centralised support to open-source software users, in addition to the support provided by software maintainers.
+
+## License
+
+[MIT](https://github.com/epoberezkin/ajv-keywords/blob/master/LICENSE)

node_modules/css-minimizer-webpack-plugin/node_modules/ajv-keywords/dist/definitions/_range.d.ts

@@ -0,0 +1,5 @@
+import type { MacroKeywordDefinition } from "ajv";
+import type { GetDefinition } from "./_types";
+declare type RangeKwd = "range" | "exclusiveRange";
+export default function getRangeDef(keyword: RangeKwd): GetDefinition<MacroKeywordDefinition>;
+export {};

node_modules/css-minimizer-webpack-plugin/node_modules/ajv-keywords/dist/definitions/_range.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getRangeDef(keyword) {
+    return () => ({
+        keyword,
+        type: "number",
+        schemaType: "array",
+        macro: function ([min, max]) {
+            validateRangeSchema(min, max);
+            return keyword === "range"
+                ? { minimum: min, maximum: max }
+                : { exclusiveMinimum: min, exclusiveMaximum: max };
+        },
+        metaSchema: {
+            type: "array",
+            minItems: 2,
+            maxItems: 2,
+            items: { type: "number" },
+        },
+    });
+    function validateRangeSchema(min, max) {
+        if (min > max || (keyword === "exclusiveRange" && min === max)) {
+            throw new Error("There are no numbers in range");
+        }
+    }
+}
+exports.default = getRangeDef;
+//# sourceMappingURL=_range.js.map

node_modules/css-minimizer-webpack-plugin/node_modules/ajv-keywords/dist/definitions/_range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_range.js","sourceRoot":"","sources":["../../src/definitions/_range.ts"],"names":[],"mappings":";;AAKA,SAAwB,WAAW,CAAC,OAAiB;IACnD,OAAO,GAAG,EAAE,CAAC,CAAC;QACZ,OAAO;QACP,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE,OAAO;QACnB,KAAK,EAAE,UAAU,CAAC,GAAG,EAAE,GAAG,CAAmB;YAC3C,mBAAmB,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;YAC7B,OAAO,OAAO,KAAK,OAAO;gBACxB,CAAC,CAAC,EAAC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,EAAC;gBAC9B,CAAC,CAAC,EAAC,gBAAgB,EAAE,GAAG,EAAE,gBAAgB,EAAE,GAAG,EAAC,CAAA;QACpD,CAAC;QACD,UAAU,EAAE;YACV,IAAI,EAAE,OAAO;YACb,QAAQ,EAAE,CAAC;YACX,QAAQ,EAAE,CAAC;YACX,KAAK,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAC;SACxB;KACF,CAAC,CAAA;IAEF,SAAS,mBAAmB,CAAC,GAAW,EAAE,GAAW;QACnD,IAAI,GAAG,GAAG,GAAG,IAAI,CAAC,OAAO,KAAK,gBAAgB,IAAI,GAAG,KAAK,GAAG,CAAC,EAAE;YAC9D,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAA;SACjD;IACH,CAAC;AACH,CAAC;AAxBD,8BAwBC"}

node_modules/css-minimizer-webpack-plugin/node_modules/ajv-keywords/dist/definitions/_required.d.ts

@@ -0,0 +1,5 @@
+import type { MacroKeywordDefinition } from "ajv";
+import type { GetDefinition } from "./_types";
+declare type RequiredKwd = "anyRequired" | "oneRequired";
+export default function getRequiredDef(keyword: RequiredKwd): GetDefinition<MacroKeywordDefinition>;
+export {};

node_modules/css-minimizer-webpack-plugin/node_modules/ajv-keywords/dist/definitions/_required.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function getRequiredDef(keyword) {
+    return () => ({
+        keyword,
+        type: "object",
+        schemaType: "array",
+        macro(schema) {
+            if (schema.length === 0)
+                return true;
+            if (schema.length === 1)
+                return { required: schema };
+            const comb = keyword === "anyRequired" ? "anyOf" : "oneOf";
+            return { [comb]: schema.map((p) => ({ required: [p] })) };
+        },
+        metaSchema: {
+            type: "array",
+            items: { type: "string" },
+        },
+    });
+}
+exports.default = getRequiredDef;
+//# sourceMappingURL=_required.js.map

node_modules/css-minimizer-webpack-plugin/node_modules/ajv-keywords/dist/definitions/_required.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_required.js","sourceRoot":"","sources":["../../src/definitions/_required.ts"],"names":[],"mappings":";;AAKA,SAAwB,cAAc,CACpC,OAAoB;IAEpB,OAAO,GAAG,EAAE,CAAC,CAAC;QACZ,OAAO;QACP,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE,OAAO;QACnB,KAAK,CAAC,MAAgB;YACpB,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,IAAI,CAAA;YACpC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,EAAC,QAAQ,EAAE,MAAM,EAAC,CAAA;YAClD,MAAM,IAAI,GAAG,OAAO,KAAK,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAA;YAC1D,OAAO,EAAC,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAC,CAAC,CAAC,EAAC,CAAA;QACvD,CAAC;QACD,UAAU,EAAE;YACV,IAAI,EAAE,OAAO;YACb,KAAK,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAC;SACxB;KACF,CAAC,CAAA;AACJ,CAAC;AAlBD,iCAkBC"}

node_modules/css-minimizer-webpack-plugin/node_modules/ajv-keywords/dist/definitions/_types.d.ts

@@ -0,0 +1,5 @@
+import type { KeywordDefinition } from "ajv";
+export interface DefinitionOptions {
+    defaultMeta?: string | boolean;
+}
+export declare type GetDefinition<T extends KeywordDefinition> = (opts?: DefinitionOptions) => T;

node_modules/css-minimizer-webpack-plugin/node_modules/ajv-keywords/dist/definitions/_types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=_types.js.map

node_modules/css-minimizer-webpack-plugin/node_modules/ajv-keywords/dist/definitions/_types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_types.js","sourceRoot":"","sources":["../../src/definitions/_types.ts"],"names":[],"mappings":""}

node_modules/css-minimizer-webpack-plugin/node_modules/ajv-keywords/dist/definitions/_util.d.ts

@@ -0,0 +1,4 @@
+import type { DefinitionOptions } from "./_types";
+import type { SchemaObject, KeywordCxt, Name } from "ajv";
+export declare function metaSchemaRef({ defaultMeta }?: DefinitionOptions): SchemaObject;
+export declare function usePattern({ gen, it: { opts } }: KeywordCxt, pattern: string, flags?: string): Name;

node_modules/css-minimizer-webpack-plugin/node_modules/ajv-keywords/dist/definitions/_util.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePattern = exports.metaSchemaRef = void 0;
+const codegen_1 = require("ajv/dist/compile/codegen");
+const META_SCHEMA_ID = "http://json-schema.org/schema";
+function metaSchemaRef({ defaultMeta } = {}) {
+    return defaultMeta === false ? {} : { $ref: defaultMeta || META_SCHEMA_ID };
+}
+exports.metaSchemaRef = metaSchemaRef;
+function usePattern({ gen, it: { opts } }, pattern, flags = opts.unicodeRegExp ? "u" : "") {
+    const rx = new RegExp(pattern, flags);
+    return gen.scopeValue("pattern", {
+        key: rx.toString(),
+        ref: rx,
+        code: (0, codegen_1._) `new RegExp(${pattern}, ${flags})`,
+    });
+}
+exports.usePattern = usePattern;
+//# sourceMappingURL=_util.js.map

node_modules/css-minimizer-webpack-plugin/node_modules/ajv-keywords/dist/definitions/_util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_util.js","sourceRoot":"","sources":["../../src/definitions/_util.ts"],"names":[],"mappings":";;;AAEA,sDAA0C;AAE1C,MAAM,cAAc,GAAG,+BAA+B,CAAA;AAEtD,SAAgB,aAAa,CAAC,EAAC,WAAW,KAAuB,EAAE;IACjE,OAAO,WAAW,KAAK,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAC,IAAI,EAAE,WAAW,IAAI,cAAc,EAAC,CAAA;AAC3E,CAAC;AAFD,sCAEC;AAED,SAAgB,UAAU,CACxB,EAAC,GAAG,EAAE,EAAE,EAAE,EAAC,IAAI,EAAC,EAAa,EAC7B,OAAe,EACf,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE;IAErC,MAAM,EAAE,GAAG,IAAI,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,CAAA;IACrC,OAAO,GAAG,CAAC,UAAU,CAAC,SAAS,EAAE;QAC/B,GAAG,EAAE,EAAE,CAAC,QAAQ,EAAE;QAClB,GAAG,EAAE,EAAE;QACP,IAAI,EAAE,IAAA,WAAC,EAAA,cAAc,OAAO,KAAK,KAAK,GAAG;KAC1C,CAAC,CAAA;AACJ,CAAC;AAXD,gCAWC"}