@posthog/rrweb-snapshot 0.0.30 → 0.0.32

package/dist/replay.umd.cjs

@@ -0,0 +1,4962 @@
+(function (g, f) {
+    if ("object" == typeof exports && "object" == typeof module) {
+      module.exports = f();
+    } else if ("function" == typeof define && define.amd) {
+      define("rrwebSnapshotReplay", [], f);
+    } else if ("object" == typeof exports) {
+      exports["rrwebSnapshotReplay"] = f();
+    } else {
+      g["rrwebSnapshotReplay"] = f();
+    }
+  }(this, () => {
+var exports = {};
+var module = { exports };
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// dist/types-pLXhbZlp.cjs
+var require_types_pLXhbZlp = __commonJS({
+  "dist/types-pLXhbZlp.cjs"(exports2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+    var __publicField = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+    var NodeType$1 = /* @__PURE__ */ ((NodeType2) => {
+      NodeType2[NodeType2["Document"] = 0] = "Document";
+      NodeType2[NodeType2["DocumentType"] = 1] = "DocumentType";
+      NodeType2[NodeType2["Element"] = 2] = "Element";
+      NodeType2[NodeType2["Text"] = 3] = "Text";
+      NodeType2[NodeType2["CDATA"] = 4] = "CDATA";
+      NodeType2[NodeType2["Comment"] = 5] = "Comment";
+      return NodeType2;
+    })(NodeType$1 || {});
+    var testableAccessors = {
+      Node: ["childNodes", "parentNode", "parentElement", "textContent"],
+      ShadowRoot: ["host", "styleSheets"],
+      Element: ["shadowRoot", "querySelector", "querySelectorAll"],
+      MutationObserver: []
+    };
+    var testableMethods = {
+      Node: ["contains", "getRootNode"],
+      ShadowRoot: ["getSelection"],
+      Element: [],
+      MutationObserver: ["constructor"]
+    };
+    var untaintedBasePrototype = {};
+    function angularZoneUnpatchedAlternative(key) {
+      var _a, _b;
+      const angularUnpatchedVersionSymbol = (_b = (_a = globalThis == null ? void 0 : globalThis.Zone) == null ? void 0 : _a.__symbol__) == null ? void 0 : _b.call(_a, key);
+      if (angularUnpatchedVersionSymbol && globalThis[angularUnpatchedVersionSymbol]) {
+        return globalThis[angularUnpatchedVersionSymbol];
+      } else {
+        return void 0;
+      }
+    }
+    function getUntaintedPrototype(key) {
+      if (untaintedBasePrototype[key])
+        return untaintedBasePrototype[key];
+      const candidate = angularZoneUnpatchedAlternative(key) || globalThis[key];
+      const defaultPrototype = candidate.prototype;
+      const accessorNames = key in testableAccessors ? testableAccessors[key] : void 0;
+      const isUntaintedAccessors = Boolean(
+        accessorNames && // @ts-expect-error 2345
+        accessorNames.every(
+          (accessor) => {
+            var _a, _b;
+            return Boolean(
+              (_b = (_a = Object.getOwnPropertyDescriptor(defaultPrototype, accessor)) == null ? void 0 : _a.get) == null ? void 0 : _b.toString().includes("[native code]")
+            );
+          }
+        )
+      );
+      const methodNames = key in testableMethods ? testableMethods[key] : void 0;
+      const isUntaintedMethods = Boolean(
+        methodNames && methodNames.every(
+          // @ts-expect-error 2345
+          (method) => {
+            var _a;
+            return typeof defaultPrototype[method] === "function" && ((_a = defaultPrototype[method]) == null ? void 0 : _a.toString().includes("[native code]"));
+          }
+        )
+      );
+      if (isUntaintedAccessors && isUntaintedMethods) {
+        untaintedBasePrototype[key] = candidate.prototype;
+        return candidate.prototype;
+      }
+      try {
+        const iframeEl = document.createElement("iframe");
+        document.body.appendChild(iframeEl);
+        const win = iframeEl.contentWindow;
+        if (!win) return candidate.prototype;
+        const untaintedObject = win[key].prototype;
+        document.body.removeChild(iframeEl);
+        if (!untaintedObject) return defaultPrototype;
+        return untaintedBasePrototype[key] = untaintedObject;
+      } catch (e) {
+        return defaultPrototype;
+      }
+    }
+    var untaintedAccessorCache = {};
+    function getUntaintedAccessor(key, instance, accessor) {
+      var _a;
+      const cacheKey = `${key}.${String(accessor)}`;
+      if (untaintedAccessorCache[cacheKey])
+        return untaintedAccessorCache[cacheKey].call(
+          instance
+        );
+      const untaintedPrototype = getUntaintedPrototype(key);
+      const untaintedAccessor = (_a = Object.getOwnPropertyDescriptor(
+        untaintedPrototype,
+        accessor
+      )) == null ? void 0 : _a.get;
+      if (!untaintedAccessor) return instance[accessor];
+      untaintedAccessorCache[cacheKey] = untaintedAccessor;
+      return untaintedAccessor.call(instance);
+    }
+    var untaintedMethodCache = {};
+    function getUntaintedMethod(key, instance, method) {
+      const cacheKey = `${key}.${String(method)}`;
+      if (untaintedMethodCache[cacheKey])
+        return untaintedMethodCache[cacheKey].bind(
+          instance
+        );
+      const untaintedPrototype = getUntaintedPrototype(key);
+      const untaintedMethod = untaintedPrototype[method];
+      if (typeof untaintedMethod !== "function") return instance[method];
+      untaintedMethodCache[cacheKey] = untaintedMethod;
+      return untaintedMethod.bind(instance);
+    }
+    function childNodes(n) {
+      return getUntaintedAccessor("Node", n, "childNodes");
+    }
+    function parentNode(n) {
+      return getUntaintedAccessor("Node", n, "parentNode");
+    }
+    function parentElement(n) {
+      return getUntaintedAccessor("Node", n, "parentElement");
+    }
+    function textContent(n) {
+      return getUntaintedAccessor("Node", n, "textContent");
+    }
+    function contains(n, other) {
+      return getUntaintedMethod("Node", n, "contains")(other);
+    }
+    function getRootNode(n) {
+      return getUntaintedMethod("Node", n, "getRootNode")();
+    }
+    function host(n) {
+      if (!n || !("host" in n)) return null;
+      return getUntaintedAccessor("ShadowRoot", n, "host");
+    }
+    function styleSheets(n) {
+      return n.styleSheets;
+    }
+    function shadowRoot(n) {
+      if (!n || !("shadowRoot" in n)) return null;
+      return getUntaintedAccessor("Element", n, "shadowRoot");
+    }
+    function querySelector(n, selectors) {
+      return getUntaintedAccessor("Element", n, "querySelector")(selectors);
+    }
+    function querySelectorAll(n, selectors) {
+      return getUntaintedAccessor("Element", n, "querySelectorAll")(selectors);
+    }
+    function mutationObserverCtor() {
+      return getUntaintedPrototype("MutationObserver").constructor;
+    }
+    function patch(source, name, replacement) {
+      try {
+        if (!(name in source)) {
+          return () => {
+          };
+        }
+        const original = source[name];
+        const wrapped = replacement(original);
+        if (typeof wrapped === "function") {
+          wrapped.prototype = wrapped.prototype || {};
+          Object.defineProperties(wrapped, {
+            __rrweb_original__: {
+              enumerable: false,
+              value: original
+            }
+          });
+        }
+        source[name] = wrapped;
+        return () => {
+          source[name] = original;
+        };
+      } catch (e) {
+        return () => {
+        };
+      }
+    }
+    var index = {
+      childNodes,
+      parentNode,
+      parentElement,
+      textContent,
+      contains,
+      getRootNode,
+      host,
+      styleSheets,
+      shadowRoot,
+      querySelector,
+      querySelectorAll,
+      mutationObserver: mutationObserverCtor,
+      patch
+    };
+    function isElement(n) {
+      return n.nodeType === n.ELEMENT_NODE;
+    }
+    function isShadowRoot(n) {
+      const hostEl = (
+        // anchor and textarea elements also have a `host` property
+        // but only shadow roots have a `mode` property
+        n && "host" in n && "mode" in n && index.host(n) || null
+      );
+      return Boolean(
+        hostEl && "shadowRoot" in hostEl && index.shadowRoot(hostEl) === n
+      );
+    }
+    function isNativeShadowDom(shadowRoot2) {
+      return Object.prototype.toString.call(shadowRoot2) === "[object ShadowRoot]";
+    }
+    function fixBrowserCompatibilityIssuesInCSS(cssText) {
+      if (cssText.includes(" background-clip: text;") && !cssText.includes(" -webkit-background-clip: text;")) {
+        cssText = cssText.replace(
+          /\sbackground-clip:\s*text;/g,
+          " -webkit-background-clip: text; background-clip: text;"
+        );
+      }
+      return cssText;
+    }
+    function escapeImportStatement(rule2) {
+      const { cssText } = rule2;
+      if (cssText.split('"').length < 3) return cssText;
+      const statement = ["@import", `url(${JSON.stringify(rule2.href)})`];
+      if (rule2.layerName === "") {
+        statement.push(`layer`);
+      } else if (rule2.layerName) {
+        statement.push(`layer(${rule2.layerName})`);
+      }
+      if (rule2.supportsText) {
+        statement.push(`supports(${rule2.supportsText})`);
+      }
+      if (rule2.media.length) {
+        statement.push(rule2.media.mediaText);
+      }
+      return statement.join(" ") + ";";
+    }
+    function stringifyStylesheet(s) {
+      try {
+        const rules = s.rules || s.cssRules;
+        if (!rules) {
+          return null;
+        }
+        let sheetHref = s.href;
+        if (!sheetHref && s.ownerNode) {
+          sheetHref = s.ownerNode.baseURI;
+        }
+        const stringifiedRules = Array.from(
+          rules,
+          (rule2) => stringifyRule(rule2, sheetHref)
+        ).join("");
+        return fixBrowserCompatibilityIssuesInCSS(stringifiedRules);
+      } catch (error) {
+        return null;
+      }
+    }
+    function stringifyRule(rule2, sheetHref) {
+      var _a;
+      if (isCSSImportRule(rule2)) {
+        let importStringified;
+        try {
+          importStringified = // for same-origin stylesheets,
+          // we can access the imported stylesheet rules directly
+          stringifyStylesheet(rule2.styleSheet) || // work around browser issues with the raw string `@import url(...)` statement
+          escapeImportStatement(rule2);
+        } catch (error) {
+          importStringified = rule2.cssText;
+        }
+        try {
+          if (importStringified && ((_a = rule2.styleSheet) == null ? void 0 : _a.href)) {
+            return absolutifyURLs(importStringified, rule2.styleSheet.href);
+          }
+        } catch (e) {
+        }
+        return importStringified;
+      } else {
+        let ruleStringified = rule2.cssText;
+        if (isCSSStyleRule(rule2) && rule2.selectorText.includes(":")) {
+          ruleStringified = fixSafariColons(ruleStringified);
+        }
+        if (sheetHref) {
+          return absolutifyURLs(ruleStringified, sheetHref);
+        }
+        return ruleStringified;
+      }
+    }
+    function fixSafariColons(cssStringified) {
+      const regex = /(\[(?:[\w-]+)[^\\])(:(?:[\w-]+)\])/gm;
+      return cssStringified.replace(regex, "$1\\$2");
+    }
+    function isCSSImportRule(rule2) {
+      return "styleSheet" in rule2;
+    }
+    function isCSSStyleRule(rule2) {
+      return "selectorText" in rule2;
+    }
+    var Mirror = class {
+      constructor() {
+        __publicField(this, "idNodeMap", /* @__PURE__ */ new Map());
+        __publicField(this, "nodeMetaMap", /* @__PURE__ */ new WeakMap());
+      }
+      getId(n) {
+        var _a;
+        if (!n) return -1;
+        const id = (_a = this.getMeta(n)) == null ? void 0 : _a.id;
+        return id != null ? id : -1;
+      }
+      getNode(id) {
+        return this.idNodeMap.get(id) || null;
+      }
+      getIds() {
+        return Array.from(this.idNodeMap.keys());
+      }
+      getMeta(n) {
+        return this.nodeMetaMap.get(n) || null;
+      }
+      // removes the node from idNodeMap
+      // doesn't remove the node from nodeMetaMap
+      removeNodeFromMap(n) {
+        const id = this.getId(n);
+        this.idNodeMap.delete(id);
+        if (n.childNodes) {
+          n.childNodes.forEach(
+            (childNode) => this.removeNodeFromMap(childNode)
+          );
+        }
+      }
+      has(id) {
+        return this.idNodeMap.has(id);
+      }
+      hasNode(node2) {
+        return this.nodeMetaMap.has(node2);
+      }
+      add(n, meta) {
+        const id = meta.id;
+        this.idNodeMap.set(id, n);
+        this.nodeMetaMap.set(n, meta);
+      }
+      replace(id, n) {
+        const oldNode = this.getNode(id);
+        if (oldNode) {
+          const meta = this.nodeMetaMap.get(oldNode);
+          if (meta) this.nodeMetaMap.set(n, meta);
+        }
+        this.idNodeMap.set(id, n);
+      }
+      reset() {
+        this.idNodeMap = /* @__PURE__ */ new Map();
+        this.nodeMetaMap = /* @__PURE__ */ new WeakMap();
+      }
+    };
+    function createMirror() {
+      return new Mirror();
+    }
+    function maskInputValue({
+      element,
+      maskInputOptions,
+      tagName,
+      type,
+      value,
+      maskInputFn
+    }) {
+      let text = value || "";
+      const actualType = type && toLowerCase(type);
+      if (maskInputOptions[tagName.toLowerCase()] || actualType && maskInputOptions[actualType]) {
+        if (maskInputFn) {
+          text = maskInputFn(text, element);
+        } else {
+          text = "*".repeat(text.length);
+        }
+      }
+      return text;
+    }
+    function toLowerCase(str) {
+      return str.toLowerCase();
+    }
+    var ORIGINAL_ATTRIBUTE_NAME = "__rrweb_original__";
+    function is2DCanvasBlank(canvas) {
+      const ctx = canvas.getContext("2d");
+      if (!ctx) return true;
+      const chunkSize = 50;
+      for (let x = 0; x < canvas.width; x += chunkSize) {
+        for (let y = 0; y < canvas.height; y += chunkSize) {
+          const getImageData = ctx.getImageData;
+          const originalGetImageData = ORIGINAL_ATTRIBUTE_NAME in getImageData ? getImageData[ORIGINAL_ATTRIBUTE_NAME] : getImageData;
+          const pixelBuffer = new Uint32Array(
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
+            originalGetImageData.call(
+              ctx,
+              x,
+              y,
+              Math.min(chunkSize, canvas.width - x),
+              Math.min(chunkSize, canvas.height - y)
+            ).data.buffer
+          );
+          if (pixelBuffer.some((pixel) => pixel !== 0)) return false;
+        }
+      }
+      return true;
+    }
+    function isNodeMetaEqual(a, b) {
+      if (!a || !b || a.type !== b.type) return false;
+      if (a.type === NodeType$1.Document)
+        return a.compatMode === b.compatMode;
+      else if (a.type === NodeType$1.DocumentType)
+        return a.name === b.name && a.publicId === b.publicId && a.systemId === b.systemId;
+      else if (a.type === NodeType$1.Comment || a.type === NodeType$1.Text || a.type === NodeType$1.CDATA)
+        return a.textContent === b.textContent;
+      else if (a.type === NodeType$1.Element)
+        return a.tagName === b.tagName && JSON.stringify(a.attributes) === JSON.stringify(b.attributes) && a.isSVG === b.isSVG && a.needBlock === b.needBlock;
+      return false;
+    }
+    function getInputType(element) {
+      const type = element.type;
+      return element.hasAttribute("data-rr-is-password") ? "password" : type ? (
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+        toLowerCase(type)
+      ) : null;
+    }
+    function extractFileExtension(path, baseURL) {
+      var _a;
+      let url;
+      try {
+        url = new URL(path, baseURL != null ? baseURL : window.location.href);
+      } catch (err) {
+        return null;
+      }
+      const regex = /\.([0-9a-z]+)(?:$)/i;
+      const match = url.pathname.match(regex);
+      return (_a = match == null ? void 0 : match[1]) != null ? _a : null;
+    }
+    function extractOrigin(url) {
+      let origin = "";
+      if (url.indexOf("//") > -1) {
+        origin = url.split("/").slice(0, 3).join("/");
+      } else {
+        origin = url.split("/")[0];
+      }
+      origin = origin.split("?")[0];
+      return origin;
+    }
+    var URL_IN_CSS_REF = /url\((?:(')([^']*)'|(")(.*?)"|([^)]*))\)/gm;
+    var URL_PROTOCOL_MATCH = /^(?:[a-z+]+:)?\/\//i;
+    var URL_WWW_MATCH = /^www\..*/i;
+    var DATA_URI = /^(data:)([^,]*),(.*)/i;
+    function absolutifyURLs(cssText, href) {
+      return (cssText || "").replace(
+        URL_IN_CSS_REF,
+        (origin, quote1, path1, quote2, path2, path3) => {
+          const filePath = path1 || path2 || path3;
+          const maybeQuote = quote1 || quote2 || "";
+          if (!filePath) {
+            return origin;
+          }
+          if (URL_PROTOCOL_MATCH.test(filePath) || URL_WWW_MATCH.test(filePath)) {
+            return `url(${maybeQuote}${filePath}${maybeQuote})`;
+          }
+          if (DATA_URI.test(filePath)) {
+            return `url(${maybeQuote}${filePath}${maybeQuote})`;
+          }
+          if (filePath[0] === "/") {
+            return `url(${maybeQuote}${extractOrigin(href) + filePath}${maybeQuote})`;
+          }
+          const stack = href.split("/");
+          const parts = filePath.split("/");
+          stack.pop();
+          for (const part of parts) {
+            if (part === ".") {
+              continue;
+            } else if (part === "..") {
+              stack.pop();
+            } else {
+              stack.push(part);
+            }
+          }
+          return `url(${maybeQuote}${stack.join("/")}${maybeQuote})`;
+        }
+      );
+    }
+    var STRIPED_PLACEHOLDER_SVG = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTAwJSIgaGVpZ2h0PSIxMDAlIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPgogIDxkZWZzPgogICAgPHBhdHRlcm4gaWQ9InN0cmlwZXMiIHBhdHRlcm5Vbml0cz0idXNlclNwYWNlT25Vc2UiIHdpZHRoPSIxNiIgaGVpZ2h0PSIxNiI+CiAgICAgIDxyZWN0IHdpZHRoPSIxNiIgaGVpZ2h0PSIxNiIgZmlsbD0iYmxhY2siLz4KICAgICAgPHBhdGggZD0iTTggMEgxNkwwIDE2VjhMOCAwWiIgZmlsbD0iIzJEMkQyRCIvPgogICAgICA8cGF0aCBkPSJNMTYgOFYxNkg4TDE2IDhaIiBmaWxsPSIjMkQyRDJEIi8+CiAgICA8L3BhdHRlcm4+CiAgPC9kZWZzPgogIDxyZWN0IHdpZHRoPSIxMDAlIiBoZWlnaHQ9IjEwMCUiIGZpbGw9InVybCgjc3RyaXBlcykiLz4KPC9zdmc+Cg==";
+    var MAX_IMAGE_DIMENSION_FOR_RECOMPRESSION = 4096;
+    function recompressBase64Image(img, dataURL, type, quality) {
+      if (!img.complete || img.naturalWidth === 0) {
+        return dataURL;
+      }
+      if (img.naturalWidth > MAX_IMAGE_DIMENSION_FOR_RECOMPRESSION || img.naturalHeight > MAX_IMAGE_DIMENSION_FOR_RECOMPRESSION) {
+        return dataURL;
+      }
+      try {
+        const canvas = document.createElement("canvas");
+        canvas.width = img.naturalWidth;
+        canvas.height = img.naturalHeight;
+        const ctx = canvas.getContext("2d");
+        if (!ctx) {
+          return dataURL;
+        }
+        ctx.drawImage(img, 0, 0);
+        const recompressed = canvas.toDataURL(type || "image/webp", quality != null ? quality : 0.4);
+        return recompressed;
+      } catch (err) {
+        return dataURL;
+      }
+    }
+    function checkDataURLSize(dataURL, maxLength) {
+      if (!maxLength || dataURL.length <= maxLength) {
+        return dataURL;
+      }
+      return STRIPED_PLACEHOLDER_SVG;
+    }
+    var NodeType = /* @__PURE__ */ ((NodeType2) => {
+      NodeType2[NodeType2["Document"] = 0] = "Document";
+      NodeType2[NodeType2["DocumentType"] = 1] = "DocumentType";
+      NodeType2[NodeType2["Element"] = 2] = "Element";
+      NodeType2[NodeType2["Text"] = 3] = "Text";
+      NodeType2[NodeType2["CDATA"] = 4] = "CDATA";
+      NodeType2[NodeType2["Comment"] = 5] = "Comment";
+      return NodeType2;
+    })(NodeType || {});
+    exports2.Mirror = Mirror;
+    exports2.NodeType = NodeType;
+    exports2.NodeType$1 = NodeType$1;
+    exports2.absolutifyURLs = absolutifyURLs;
+    exports2.checkDataURLSize = checkDataURLSize;
+    exports2.createMirror = createMirror;
+    exports2.escapeImportStatement = escapeImportStatement;
+    exports2.extractFileExtension = extractFileExtension;
+    exports2.fixSafariColons = fixSafariColons;
+    exports2.getInputType = getInputType;
+    exports2.index = index;
+    exports2.is2DCanvasBlank = is2DCanvasBlank;
+    exports2.isCSSImportRule = isCSSImportRule;
+    exports2.isCSSStyleRule = isCSSStyleRule;
+    exports2.isElement = isElement;
+    exports2.isNativeShadowDom = isNativeShadowDom;
+    exports2.isNodeMetaEqual = isNodeMetaEqual;
+    exports2.isShadowRoot = isShadowRoot;
+    exports2.maskInputValue = maskInputValue;
+    exports2.recompressBase64Image = recompressBase64Image;
+    exports2.stringifyRule = stringifyRule;
+    exports2.stringifyStylesheet = stringifyStylesheet;
+    exports2.toLowerCase = toLowerCase;
+  }
+});
+
+// dist/replay.cjs
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var types = require_types_pLXhbZlp();
+var MEDIA_SELECTOR = /(max|min)-device-(width|height)/;
+var MEDIA_SELECTOR_GLOBAL = new RegExp(MEDIA_SELECTOR.source, "g");
+var mediaSelectorPlugin = {
+  postcssPlugin: "postcss-custom-selectors",
+  prepare() {
+    return {
+      postcssPlugin: "postcss-custom-selectors",
+      AtRule: function(atrule) {
+        if (atrule.params.match(MEDIA_SELECTOR_GLOBAL)) {
+          atrule.params = atrule.params.replace(MEDIA_SELECTOR_GLOBAL, "$1-$2");
+        }
+      }
+    };
+  }
+};
+var pseudoClassPlugin = {
+  postcssPlugin: "postcss-hover-classes",
+  prepare: function() {
+    const fixed = [];
+    return {
+      Rule: function(rule2) {
+        if (fixed.indexOf(rule2) !== -1) {
+          return;
+        }
+        fixed.push(rule2);
+        rule2.selectors.forEach(function(selector) {
+          if (selector.includes(":hover")) {
+            rule2.selector += ",\n" + selector.replace(/:hover/g, ".\\:hover");
+          }
+        });
+      }
+    };
+  }
+};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+  if (typeof f == "function") {
+    var a = function a2() {
+      if (this instanceof a2) {
+        return Reflect.construct(f, arguments, this.constructor);
+      }
+      return f.apply(this, arguments);
+    };
+    a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, "__esModule", { value: true });
+  Object.keys(n).forEach(function(k) {
+    var d = Object.getOwnPropertyDescriptor(n, k);
+    Object.defineProperty(a, k, d.get ? d : {
+      enumerable: true,
+      get: function() {
+        return n[k];
+      }
+    });
+  });
+  return a;
+}
+var picocolors_browser = { exports: {} };
+var hasRequiredPicocolors_browser;
+function requirePicocolors_browser() {
+  if (hasRequiredPicocolors_browser) return picocolors_browser.exports;
+  hasRequiredPicocolors_browser = 1;
+  var x = String;
+  var create = function() {
+    return { isColorSupported: false, reset: x, bold: x, dim: x, italic: x, underline: x, inverse: x, hidden: x, strikethrough: x, black: x, red: x, green: x, yellow: x, blue: x, magenta: x, cyan: x, white: x, gray: x, bgBlack: x, bgRed: x, bgGreen: x, bgYellow: x, bgBlue: x, bgMagenta: x, bgCyan: x, bgWhite: x, blackBright: x, redBright: x, greenBright: x, yellowBright: x, blueBright: x, magentaBright: x, cyanBright: x, whiteBright: x, bgBlackBright: x, bgRedBright: x, bgGreenBright: x, bgYellowBright: x, bgBlueBright: x, bgMagentaBright: x, bgCyanBright: x, bgWhiteBright: x };
+  };
+  picocolors_browser.exports = create();
+  picocolors_browser.exports.createColors = create;
+  return picocolors_browser.exports;
+}
+var __viteBrowserExternal = {};
+var __viteBrowserExternal$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: __viteBrowserExternal
+}, Symbol.toStringTag, { value: "Module" }));
+var require$$2 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
+var cssSyntaxError;
+var hasRequiredCssSyntaxError;
+function requireCssSyntaxError() {
+  if (hasRequiredCssSyntaxError) return cssSyntaxError;
+  hasRequiredCssSyntaxError = 1;
+  let pico = /* @__PURE__ */ requirePicocolors_browser();
+  let terminalHighlight = require$$2;
+  class CssSyntaxError extends Error {
+    constructor(message, line, column, source, file, plugin) {
+      super(message);
+      this.name = "CssSyntaxError";
+      this.reason = message;
+      if (file) {
+        this.file = file;
+      }
+      if (source) {
+        this.source = source;
+      }
+      if (plugin) {
+        this.plugin = plugin;
+      }
+      if (typeof line !== "undefined" && typeof column !== "undefined") {
+        if (typeof line === "number") {
+          this.line = line;
+          this.column = column;
+        } else {
+          this.line = line.line;
+          this.column = line.column;
+          this.endLine = column.line;
+          this.endColumn = column.column;
+        }
+      }
+      this.setMessage();
+      if (Error.captureStackTrace) {
+        Error.captureStackTrace(this, CssSyntaxError);
+      }
+    }
+    setMessage() {
+      this.message = this.plugin ? this.plugin + ": " : "";
+      this.message += this.file ? this.file : "<css input>";
+      if (typeof this.line !== "undefined") {
+        this.message += ":" + this.line + ":" + this.column;
+      }
+      this.message += ": " + this.reason;
+    }
+    showSourceCode(color) {
+      if (!this.source) return "";
+      let css = this.source;
+      if (color == null) color = pico.isColorSupported;
+      let aside = (text) => text;
+      let mark = (text) => text;
+      let highlight = (text) => text;
+      if (color) {
+        let { bold, gray, red } = pico.createColors(true);
+        mark = (text) => bold(red(text));
+        aside = (text) => gray(text);
+        if (terminalHighlight) {
+          highlight = (text) => terminalHighlight(text);
+        }
+      }
+      let lines = css.split(/\r?\n/);
+      let start = Math.max(this.line - 3, 0);
+      let end = Math.min(this.line + 2, lines.length);
+      let maxWidth = String(end).length;
+      return lines.slice(start, end).map((line, index) => {
+        let number = start + 1 + index;
+        let gutter = " " + (" " + number).slice(-maxWidth) + " | ";
+        if (number === this.line) {
+          if (line.length > 160) {
+            let padding = 20;
+            let subLineStart = Math.max(0, this.column - padding);
+            let subLineEnd = Math.max(
+              this.column + padding,
+              this.endColumn + padding
+            );
+            let subLine = line.slice(subLineStart, subLineEnd);
+            let spacing2 = aside(gutter.replace(/\d/g, " ")) + line.slice(0, Math.min(this.column - 1, padding - 1)).replace(/[^\t]/g, " ");
+            return mark(">") + aside(gutter) + highlight(subLine) + "\n " + spacing2 + mark("^");
+          }
+          let spacing = aside(gutter.replace(/\d/g, " ")) + line.slice(0, this.column - 1).replace(/[^\t]/g, " ");
+          return mark(">") + aside(gutter) + highlight(line) + "\n " + spacing + mark("^");
+        }
+        return " " + aside(gutter) + highlight(line);
+      }).join("\n");
+    }
+    toString() {
+      let code = this.showSourceCode();
+      if (code) {
+        code = "\n\n" + code + "\n";
+      }
+      return this.name + ": " + this.message + code;
+    }
+  }
+  cssSyntaxError = CssSyntaxError;
+  CssSyntaxError.default = CssSyntaxError;
+  return cssSyntaxError;
+}
+var stringifier;
+var hasRequiredStringifier;
+function requireStringifier() {
+  if (hasRequiredStringifier) return stringifier;
+  hasRequiredStringifier = 1;
+  const DEFAULT_RAW = {
+    after: "\n",
+    beforeClose: "\n",
+    beforeComment: "\n",
+    beforeDecl: "\n",
+    beforeOpen: " ",
+    beforeRule: "\n",
+    colon: ": ",
+    commentLeft: " ",
+    commentRight: " ",
+    emptyBody: "",
+    indent: "    ",
+    semicolon: false
+  };
+  function capitalize(str) {
+    return str[0].toUpperCase() + str.slice(1);
+  }
+  class Stringifier {
+    constructor(builder) {
+      this.builder = builder;
+    }
+    atrule(node2, semicolon) {
+      let name = "@" + node2.name;
+      let params = node2.params ? this.rawValue(node2, "params") : "";
+      if (typeof node2.raws.afterName !== "undefined") {
+        name += node2.raws.afterName;
+      } else if (params) {
+        name += " ";
+      }
+      if (node2.nodes) {
+        this.block(node2, name + params);
+      } else {
+        let end = (node2.raws.between || "") + (semicolon ? ";" : "");
+        this.builder(name + params + end, node2);
+      }
+    }
+    beforeAfter(node2, detect) {
+      let value;
+      if (node2.type === "decl") {
+        value = this.raw(node2, null, "beforeDecl");
+      } else if (node2.type === "comment") {
+        value = this.raw(node2, null, "beforeComment");
+      } else if (detect === "before") {
+        value = this.raw(node2, null, "beforeRule");
+      } else {
+        value = this.raw(node2, null, "beforeClose");
+      }
+      let buf = node2.parent;
+      let depth = 0;
+      while (buf && buf.type !== "root") {
+        depth += 1;
+        buf = buf.parent;
+      }
+      if (value.includes("\n")) {
+        let indent = this.raw(node2, null, "indent");
+        if (indent.length) {
+          for (let step = 0; step < depth; step++) value += indent;
+        }
+      }
+      return value;
+    }
+    block(node2, start) {
+      let between = this.raw(node2, "between", "beforeOpen");
+      this.builder(start + between + "{", node2, "start");
+      let after;
+      if (node2.nodes && node2.nodes.length) {
+        this.body(node2);
+        after = this.raw(node2, "after");
+      } else {
+        after = this.raw(node2, "after", "emptyBody");
+      }
+      if (after) this.builder(after);
+      this.builder("}", node2, "end");
+    }
+    body(node2) {
+      let last = node2.nodes.length - 1;
+      while (last > 0) {
+        if (node2.nodes[last].type !== "comment") break;
+        last -= 1;
+      }
+      let semicolon = this.raw(node2, "semicolon");
+      for (let i = 0; i < node2.nodes.length; i++) {
+        let child = node2.nodes[i];
+        let before = this.raw(child, "before");
+        if (before) this.builder(before);
+        this.stringify(child, last !== i || semicolon);
+      }
+    }
+    comment(node2) {
+      let left = this.raw(node2, "left", "commentLeft");
+      let right = this.raw(node2, "right", "commentRight");
+      this.builder("/*" + left + node2.text + right + "*/", node2);
+    }
+    decl(node2, semicolon) {
+      let between = this.raw(node2, "between", "colon");
+      let string = node2.prop + between + this.rawValue(node2, "value");
+      if (node2.important) {
+        string += node2.raws.important || " !important";
+      }
+      if (semicolon) string += ";";
+      this.builder(string, node2);
+    }
+    document(node2) {
+      this.body(node2);
+    }
+    raw(node2, own, detect) {
+      let value;
+      if (!detect) detect = own;
+      if (own) {
+        value = node2.raws[own];
+        if (typeof value !== "undefined") return value;
+      }
+      let parent = node2.parent;
+      if (detect === "before") {
+        if (!parent || parent.type === "root" && parent.first === node2) {
+          return "";
+        }
+        if (parent && parent.type === "document") {
+          return "";
+        }
+      }
+      if (!parent) return DEFAULT_RAW[detect];
+      let root2 = node2.root();
+      if (!root2.rawCache) root2.rawCache = {};
+      if (typeof root2.rawCache[detect] !== "undefined") {
+        return root2.rawCache[detect];
+      }
+      if (detect === "before" || detect === "after") {
+        return this.beforeAfter(node2, detect);
+      } else {
+        let method = "raw" + capitalize(detect);
+        if (this[method]) {
+          value = this[method](root2, node2);
+        } else {
+          root2.walk((i) => {
+            value = i.raws[own];
+            if (typeof value !== "undefined") return false;
+          });
+        }
+      }
+      if (typeof value === "undefined") value = DEFAULT_RAW[detect];
+      root2.rawCache[detect] = value;
+      return value;
+    }
+    rawBeforeClose(root2) {
+      let value;
+      root2.walk((i) => {
+        if (i.nodes && i.nodes.length > 0) {
+          if (typeof i.raws.after !== "undefined") {
+            value = i.raws.after;
+            if (value.includes("\n")) {
+              value = value.replace(/[^\n]+$/, "");
+            }
+            return false;
+          }
+        }
+      });
+      if (value) value = value.replace(/\S/g, "");
+      return value;
+    }
+    rawBeforeComment(root2, node2) {
+      let value;
+      root2.walkComments((i) => {
+        if (typeof i.raws.before !== "undefined") {
+          value = i.raws.before;
+          if (value.includes("\n")) {
+            value = value.replace(/[^\n]+$/, "");
+          }
+          return false;
+        }
+      });
+      if (typeof value === "undefined") {
+        value = this.raw(node2, null, "beforeDecl");
+      } else if (value) {
+        value = value.replace(/\S/g, "");
+      }
+      return value;
+    }
+    rawBeforeDecl(root2, node2) {
+      let value;
+      root2.walkDecls((i) => {
+        if (typeof i.raws.before !== "undefined") {
+          value = i.raws.before;
+          if (value.includes("\n")) {
+            value = value.replace(/[^\n]+$/, "");
+          }
+          return false;
+        }
+      });
+      if (typeof value === "undefined") {
+        value = this.raw(node2, null, "beforeRule");
+      } else if (value) {
+        value = value.replace(/\S/g, "");
+      }
+      return value;
+    }
+    rawBeforeOpen(root2) {
+      let value;
+      root2.walk((i) => {
+        if (i.type !== "decl") {
+          value = i.raws.between;
+          if (typeof value !== "undefined") return false;
+        }
+      });
+      return value;
+    }
+    rawBeforeRule(root2) {
+      let value;
+      root2.walk((i) => {
+        if (i.nodes && (i.parent !== root2 || root2.first !== i)) {
+          if (typeof i.raws.before !== "undefined") {
+            value = i.raws.before;
+            if (value.includes("\n")) {
+              value = value.replace(/[^\n]+$/, "");
+            }
+            return false;
+          }
+        }
+      });
+      if (value) value = value.replace(/\S/g, "");
+      return value;
+    }
+    rawColon(root2) {
+      let value;
+      root2.walkDecls((i) => {
+        if (typeof i.raws.between !== "undefined") {
+          value = i.raws.between.replace(/[^\s:]/g, "");
+          return false;
+        }
+      });
+      return value;
+    }
+    rawEmptyBody(root2) {
+      let value;
+      root2.walk((i) => {
+        if (i.nodes && i.nodes.length === 0) {
+          value = i.raws.after;
+          if (typeof value !== "undefined") return false;
+        }
+      });
+      return value;
+    }
+    rawIndent(root2) {
+      if (root2.raws.indent) return root2.raws.indent;
+      let value;
+      root2.walk((i) => {
+        let p = i.parent;
+        if (p && p !== root2 && p.parent && p.parent === root2) {
+          if (typeof i.raws.before !== "undefined") {
+            let parts = i.raws.before.split("\n");
+            value = parts[parts.length - 1];
+            value = value.replace(/\S/g, "");
+            return false;
+          }
+        }
+      });
+      return value;
+    }
+    rawSemicolon(root2) {
+      let value;
+      root2.walk((i) => {
+        if (i.nodes && i.nodes.length && i.last.type === "decl") {
+          value = i.raws.semicolon;
+          if (typeof value !== "undefined") return false;
+        }
+      });
+      return value;
+    }
+    rawValue(node2, prop) {
+      let value = node2[prop];
+      let raw = node2.raws[prop];
+      if (raw && raw.value === value) {
+        return raw.raw;
+      }
+      return value;
+    }
+    root(node2) {
+      this.body(node2);
+      if (node2.raws.after) this.builder(node2.raws.after);
+    }
+    rule(node2) {
+      this.block(node2, this.rawValue(node2, "selector"));
+      if (node2.raws.ownSemicolon) {
+        this.builder(node2.raws.ownSemicolon, node2, "end");
+      }
+    }
+    stringify(node2, semicolon) {
+      if (!this[node2.type]) {
+        throw new Error(
+          "Unknown AST node type " + node2.type + ". Maybe you need to change PostCSS stringifier."
+        );
+      }
+      this[node2.type](node2, semicolon);
+    }
+  }
+  stringifier = Stringifier;
+  Stringifier.default = Stringifier;
+  return stringifier;
+}
+var stringify_1;
+var hasRequiredStringify;
+function requireStringify() {
+  if (hasRequiredStringify) return stringify_1;
+  hasRequiredStringify = 1;
+  let Stringifier = requireStringifier();
+  function stringify(node2, builder) {
+    let str = new Stringifier(builder);
+    str.stringify(node2);
+  }
+  stringify_1 = stringify;
+  stringify.default = stringify;
+  return stringify_1;
+}
+var symbols = {};
+var hasRequiredSymbols;
+function requireSymbols() {
+  if (hasRequiredSymbols) return symbols;
+  hasRequiredSymbols = 1;
+  symbols.isClean = Symbol("isClean");
+  symbols.my = Symbol("my");
+  return symbols;
+}
+var node;
+var hasRequiredNode;
+function requireNode() {
+  if (hasRequiredNode) return node;
+  hasRequiredNode = 1;
+  let CssSyntaxError = requireCssSyntaxError();
+  let Stringifier = requireStringifier();
+  let stringify = requireStringify();
+  let { isClean, my } = requireSymbols();
+  function cloneNode(obj, parent) {
+    let cloned = new obj.constructor();
+    for (let i in obj) {
+      if (!Object.prototype.hasOwnProperty.call(obj, i)) {
+        continue;
+      }
+      if (i === "proxyCache") continue;
+      let value = obj[i];
+      let type = typeof value;
+      if (i === "parent" && type === "object") {
+        if (parent) cloned[i] = parent;
+      } else if (i === "source") {
+        cloned[i] = value;
+      } else if (Array.isArray(value)) {
+        cloned[i] = value.map((j) => cloneNode(j, cloned));
+      } else {
+        if (type === "object" && value !== null) value = cloneNode(value);
+        cloned[i] = value;
+      }
+    }
+    return cloned;
+  }
+  function sourceOffset(inputCSS, position) {
+    if (position && typeof position.offset !== "undefined") {
+      return position.offset;
+    }
+    let column = 1;
+    let line = 1;
+    let offset = 0;
+    for (let i = 0; i < inputCSS.length; i++) {
+      if (line === position.line && column === position.column) {
+        offset = i;
+        break;
+      }
+      if (inputCSS[i] === "\n") {
+        column = 1;
+        line += 1;
+      } else {
+        column += 1;
+      }
+    }
+    return offset;
+  }
+  class Node {
+    constructor(defaults = {}) {
+      this.raws = {};
+      this[isClean] = false;
+      this[my] = true;
+      for (let name in defaults) {
+        if (name === "nodes") {
+          this.nodes = [];
+          for (let node2 of defaults[name]) {
+            if (typeof node2.clone === "function") {
+              this.append(node2.clone());
+            } else {
+              this.append(node2);
+            }
+          }
+        } else {
+          this[name] = defaults[name];
+        }
+      }
+    }
+    addToError(error) {
+      error.postcssNode = this;
+      if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) {
+        let s = this.source;
+        error.stack = error.stack.replace(
+          /\n\s{4}at /,
+          `$&${s.input.from}:${s.start.line}:${s.start.column}$&`
+        );
+      }
+      return error;
+    }
+    after(add) {
+      this.parent.insertAfter(this, add);
+      return this;
+    }
+    assign(overrides = {}) {
+      for (let name in overrides) {
+        this[name] = overrides[name];
+      }
+      return this;
+    }
+    before(add) {
+      this.parent.insertBefore(this, add);
+      return this;
+    }
+    cleanRaws(keepBetween) {
+      delete this.raws.before;
+      delete this.raws.after;
+      if (!keepBetween) delete this.raws.between;
+    }
+    clone(overrides = {}) {
+      let cloned = cloneNode(this);
+      for (let name in overrides) {
+        cloned[name] = overrides[name];
+      }
+      return cloned;
+    }
+    cloneAfter(overrides = {}) {
+      let cloned = this.clone(overrides);
+      this.parent.insertAfter(this, cloned);
+      return cloned;
+    }
+    cloneBefore(overrides = {}) {
+      let cloned = this.clone(overrides);
+      this.parent.insertBefore(this, cloned);
+      return cloned;
+    }
+    error(message, opts = {}) {
+      if (this.source) {
+        let { end, start } = this.rangeBy(opts);
+        return this.source.input.error(
+          message,
+          { column: start.column, line: start.line },
+          { column: end.column, line: end.line },
+          opts
+        );
+      }
+      return new CssSyntaxError(message);
+    }
+    getProxyProcessor() {
+      return {
+        get(node2, prop) {
+          if (prop === "proxyOf") {
+            return node2;
+          } else if (prop === "root") {
+            return () => node2.root().toProxy();
+          } else {
+            return node2[prop];
+          }
+        },
+        set(node2, prop, value) {
+          if (node2[prop] === value) return true;
+          node2[prop] = value;
+          if (prop === "prop" || prop === "value" || prop === "name" || prop === "params" || prop === "important" || /* c8 ignore next */
+          prop === "text") {
+            node2.markDirty();
+          }
+          return true;
+        }
+      };
+    }
+    /* c8 ignore next 3 */
+    markClean() {
+      this[isClean] = true;
+    }
+    markDirty() {
+      if (this[isClean]) {
+        this[isClean] = false;
+        let next = this;
+        while (next = next.parent) {
+          next[isClean] = false;
+        }
+      }
+    }
+    next() {
+      if (!this.parent) return void 0;
+      let index = this.parent.index(this);
+      return this.parent.nodes[index + 1];
+    }
+    positionBy(opts) {
+      let pos = this.source.start;
+      if (opts.index) {
+        pos = this.positionInside(opts.index);
+      } else if (opts.word) {
+        let inputString = "document" in this.source.input ? this.source.input.document : this.source.input.css;
+        let stringRepresentation = inputString.slice(
+          sourceOffset(inputString, this.source.start),
+          sourceOffset(inputString, this.source.end)
+        );
+        let index = stringRepresentation.indexOf(opts.word);
+        if (index !== -1) pos = this.positionInside(index);
+      }
+      return pos;
+    }
+    positionInside(index) {
+      let column = this.source.start.column;
+      let line = this.source.start.line;
+      let inputString = "document" in this.source.input ? this.source.input.document : this.source.input.css;
+      let offset = sourceOffset(inputString, this.source.start);
+      let end = offset + index;
+      for (let i = offset; i < end; i++) {
+        if (inputString[i] === "\n") {
+          column = 1;
+          line += 1;
+        } else {
+          column += 1;
+        }
+      }
+      return { column, line };
+    }
+    prev() {
+      if (!this.parent) return void 0;
+      let index = this.parent.index(this);
+      return this.parent.nodes[index - 1];
+    }
+    rangeBy(opts) {
+      let start = {
+        column: this.source.start.column,
+        line: this.source.start.line
+      };
+      let end = this.source.end ? {
+        column: this.source.end.column + 1,
+        line: this.source.end.line
+      } : {
+        column: start.column + 1,
+        line: start.line
+      };
+      if (opts.word) {
+        let inputString = "document" in this.source.input ? this.source.input.document : this.source.input.css;
+        let stringRepresentation = inputString.slice(
+          sourceOffset(inputString, this.source.start),
+          sourceOffset(inputString, this.source.end)
+        );
+        let index = stringRepresentation.indexOf(opts.word);
+        if (index !== -1) {
+          start = this.positionInside(index);
+          end = this.positionInside(
+            index + opts.word.length
+          );
+        }
+      } else {
+        if (opts.start) {
+          start = {
+            column: opts.start.column,
+            line: opts.start.line
+          };
+        } else if (opts.index) {
+          start = this.positionInside(opts.index);
+        }
+        if (opts.end) {
+          end = {
+            column: opts.end.column,
+            line: opts.end.line
+          };
+        } else if (typeof opts.endIndex === "number") {
+          end = this.positionInside(opts.endIndex);
+        } else if (opts.index) {
+          end = this.positionInside(opts.index + 1);
+        }
+      }
+      if (end.line < start.line || end.line === start.line && end.column <= start.column) {
+        end = { column: start.column + 1, line: start.line };
+      }
+      return { end, start };
+    }
+    raw(prop, defaultType) {
+      let str = new Stringifier();
+      return str.raw(this, prop, defaultType);
+    }
+    remove() {
+      if (this.parent) {
+        this.parent.removeChild(this);
+      }
+      this.parent = void 0;
+      return this;
+    }
+    replaceWith(...nodes) {
+      if (this.parent) {
+        let bookmark = this;
+        let foundSelf = false;
+        for (let node2 of nodes) {
+          if (node2 === this) {
+            foundSelf = true;
+          } else if (foundSelf) {
+            this.parent.insertAfter(bookmark, node2);
+            bookmark = node2;
+          } else {
+            this.parent.insertBefore(bookmark, node2);
+          }
+        }
+        if (!foundSelf) {
+          this.remove();
+        }
+      }
+      return this;
+    }
+    root() {
+      let result2 = this;
+      while (result2.parent && result2.parent.type !== "document") {
+        result2 = result2.parent;
+      }
+      return result2;
+    }
+    toJSON(_, inputs) {
+      let fixed = {};
+      let emitInputs = inputs == null;
+      inputs = inputs || /* @__PURE__ */ new Map();
+      let inputsNextIndex = 0;
+      for (let name in this) {
+        if (!Object.prototype.hasOwnProperty.call(this, name)) {
+          continue;
+        }
+        if (name === "parent" || name === "proxyCache") continue;
+        let value = this[name];
+        if (Array.isArray(value)) {
+          fixed[name] = value.map((i) => {
+            if (typeof i === "object" && i.toJSON) {
+              return i.toJSON(null, inputs);
+            } else {
+              return i;
+            }
+          });
+        } else if (typeof value === "object" && value.toJSON) {
+          fixed[name] = value.toJSON(null, inputs);
+        } else if (name === "source") {
+          let inputId = inputs.get(value.input);
+          if (inputId == null) {
+            inputId = inputsNextIndex;
+            inputs.set(value.input, inputsNextIndex);
+            inputsNextIndex++;
+          }
+          fixed[name] = {
+            end: value.end,
+            inputId,
+            start: value.start
+          };
+        } else {
+          fixed[name] = value;
+        }
+      }
+      if (emitInputs) {
+        fixed.inputs = [...inputs.keys()].map((input2) => input2.toJSON());
+      }
+      return fixed;
+    }
+    toProxy() {
+      if (!this.proxyCache) {
+        this.proxyCache = new Proxy(this, this.getProxyProcessor());
+      }
+      return this.proxyCache;
+    }
+    toString(stringifier2 = stringify) {
+      if (stringifier2.stringify) stringifier2 = stringifier2.stringify;
+      let result2 = "";
+      stringifier2(this, (i) => {
+        result2 += i;
+      });
+      return result2;
+    }
+    warn(result2, text, opts) {
+      let data = { node: this };
+      for (let i in opts) data[i] = opts[i];
+      return result2.warn(text, data);
+    }
+    get proxyOf() {
+      return this;
+    }
+  }
+  node = Node;
+  Node.default = Node;
+  return node;
+}
+var comment;
+var hasRequiredComment;
+function requireComment() {
+  if (hasRequiredComment) return comment;
+  hasRequiredComment = 1;
+  let Node = requireNode();
+  class Comment extends Node {
+    constructor(defaults) {
+      super(defaults);
+      this.type = "comment";
+    }
+  }
+  comment = Comment;
+  Comment.default = Comment;
+  return comment;
+}
+var declaration;
+var hasRequiredDeclaration;
+function requireDeclaration() {
+  if (hasRequiredDeclaration) return declaration;
+  hasRequiredDeclaration = 1;
+  let Node = requireNode();
+  class Declaration extends Node {
+    constructor(defaults) {
+      if (defaults && typeof defaults.value !== "undefined" && typeof defaults.value !== "string") {
+        defaults = __spreadProps(__spreadValues({}, defaults), { value: String(defaults.value) });
+      }
+      super(defaults);
+      this.type = "decl";
+    }
+    get variable() {
+      return this.prop.startsWith("--") || this.prop[0] === "$";
+    }
+  }
+  declaration = Declaration;
+  Declaration.default = Declaration;
+  return declaration;
+}
+var container;
+var hasRequiredContainer;
+function requireContainer() {
+  if (hasRequiredContainer) return container;
+  hasRequiredContainer = 1;
+  let Comment = requireComment();
+  let Declaration = requireDeclaration();
+  let Node = requireNode();
+  let { isClean, my } = requireSymbols();
+  let AtRule, parse, Root, Rule;
+  function cleanSource(nodes) {
+    return nodes.map((i) => {
+      if (i.nodes) i.nodes = cleanSource(i.nodes);
+      delete i.source;
+      return i;
+    });
+  }
+  function markTreeDirty(node2) {
+    node2[isClean] = false;
+    if (node2.proxyOf.nodes) {
+      for (let i of node2.proxyOf.nodes) {
+        markTreeDirty(i);
+      }
+    }
+  }
+  class Container extends Node {
+    append(...children) {
+      for (let child of children) {
+        let nodes = this.normalize(child, this.last);
+        for (let node2 of nodes) this.proxyOf.nodes.push(node2);
+      }
+      this.markDirty();
+      return this;
+    }
+    cleanRaws(keepBetween) {
+      super.cleanRaws(keepBetween);
+      if (this.nodes) {
+        for (let node2 of this.nodes) node2.cleanRaws(keepBetween);
+      }
+    }
+    each(callback) {
+      if (!this.proxyOf.nodes) return void 0;
+      let iterator = this.getIterator();
+      let index, result2;
+      while (this.indexes[iterator] < this.proxyOf.nodes.length) {
+        index = this.indexes[iterator];
+        result2 = callback(this.proxyOf.nodes[index], index);
+        if (result2 === false) break;
+        this.indexes[iterator] += 1;
+      }
+      delete this.indexes[iterator];
+      return result2;
+    }
+    every(condition) {
+      return this.nodes.every(condition);
+    }
+    getIterator() {
+      if (!this.lastEach) this.lastEach = 0;
+      if (!this.indexes) this.indexes = {};
+      this.lastEach += 1;
+      let iterator = this.lastEach;
+      this.indexes[iterator] = 0;
+      return iterator;
+    }
+    getProxyProcessor() {
+      return {
+        get(node2, prop) {
+          if (prop === "proxyOf") {
+            return node2;
+          } else if (!node2[prop]) {
+            return node2[prop];
+          } else if (prop === "each" || typeof prop === "string" && prop.startsWith("walk")) {
+            return (...args) => {
+              return node2[prop](
+                ...args.map((i) => {
+                  if (typeof i === "function") {
+                    return (child, index) => i(child.toProxy(), index);
+                  } else {
+                    return i;
+                  }
+                })
+              );
+            };
+          } else if (prop === "every" || prop === "some") {
+            return (cb) => {
+              return node2[prop](
+                (child, ...other) => cb(child.toProxy(), ...other)
+              );
+            };
+          } else if (prop === "root") {
+            return () => node2.root().toProxy();
+          } else if (prop === "nodes") {
+            return node2.nodes.map((i) => i.toProxy());
+          } else if (prop === "first" || prop === "last") {
+            return node2[prop].toProxy();
+          } else {
+            return node2[prop];
+          }
+        },
+        set(node2, prop, value) {
+          if (node2[prop] === value) return true;
+          node2[prop] = value;
+          if (prop === "name" || prop === "params" || prop === "selector") {
+            node2.markDirty();
+          }
+          return true;
+        }
+      };
+    }
+    index(child) {
+      if (typeof child === "number") return child;
+      if (child.proxyOf) child = child.proxyOf;
+      return this.proxyOf.nodes.indexOf(child);
+    }
+    insertAfter(exist, add) {
+      let existIndex = this.index(exist);
+      let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse();
+      existIndex = this.index(exist);
+      for (let node2 of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node2);
+      let index;
+      for (let id in this.indexes) {
+        index = this.indexes[id];
+        if (existIndex < index) {
+          this.indexes[id] = index + nodes.length;
+        }
+      }
+      this.markDirty();
+      return this;
+    }
+    insertBefore(exist, add) {
+      let existIndex = this.index(exist);
+      let type = existIndex === 0 ? "prepend" : false;
+      let nodes = this.normalize(
+        add,
+        this.proxyOf.nodes[existIndex],
+        type
+      ).reverse();
+      existIndex = this.index(exist);
+      for (let node2 of nodes) this.proxyOf.nodes.splice(existIndex, 0, node2);
+      let index;
+      for (let id in this.indexes) {
+        index = this.indexes[id];
+        if (existIndex <= index) {
+          this.indexes[id] = index + nodes.length;
+        }
+      }
+      this.markDirty();
+      return this;
+    }
+    normalize(nodes, sample) {
+      if (typeof nodes === "string") {
+        nodes = cleanSource(parse(nodes).nodes);
+      } else if (typeof nodes === "undefined") {
+        nodes = [];
+      } else if (Array.isArray(nodes)) {
+        nodes = nodes.slice(0);
+        for (let i of nodes) {
+          if (i.parent) i.parent.removeChild(i, "ignore");
+        }
+      } else if (nodes.type === "root" && this.type !== "document") {
+        nodes = nodes.nodes.slice(0);
+        for (let i of nodes) {
+          if (i.parent) i.parent.removeChild(i, "ignore");
+        }
+      } else if (nodes.type) {
+        nodes = [nodes];
+      } else if (nodes.prop) {
+        if (typeof nodes.value === "undefined") {
+          throw new Error("Value field is missed in node creation");
+        } else if (typeof nodes.value !== "string") {
+          nodes.value = String(nodes.value);
+        }
+        nodes = [new Declaration(nodes)];
+      } else if (nodes.selector || nodes.selectors) {
+        nodes = [new Rule(nodes)];
+      } else if (nodes.name) {
+        nodes = [new AtRule(nodes)];
+      } else if (nodes.text) {
+        nodes = [new Comment(nodes)];
+      } else {
+        throw new Error("Unknown node type in node creation");
+      }
+      let processed = nodes.map((i) => {
+        if (!i[my]) Container.rebuild(i);
+        i = i.proxyOf;
+        if (i.parent) i.parent.removeChild(i);
+        if (i[isClean]) markTreeDirty(i);
+        if (!i.raws) i.raws = {};
+        if (typeof i.raws.before === "undefined") {
+          if (sample && typeof sample.raws.before !== "undefined") {
+            i.raws.before = sample.raws.before.replace(/\S/g, "");
+          }
+        }
+        i.parent = this.proxyOf;
+        return i;
+      });
+      return processed;
+    }
+    prepend(...children) {
+      children = children.reverse();
+      for (let child of children) {
+        let nodes = this.normalize(child, this.first, "prepend").reverse();
+        for (let node2 of nodes) this.proxyOf.nodes.unshift(node2);
+        for (let id in this.indexes) {
+          this.indexes[id] = this.indexes[id] + nodes.length;
+        }
+      }
+      this.markDirty();
+      return this;
+    }
+    push(child) {
+      child.parent = this;
+      this.proxyOf.nodes.push(child);
+      return this;
+    }
+    removeAll() {
+      for (let node2 of this.proxyOf.nodes) node2.parent = void 0;
+      this.proxyOf.nodes = [];
+      this.markDirty();
+      return this;
+    }
+    removeChild(child) {
+      child = this.index(child);
+      this.proxyOf.nodes[child].parent = void 0;
+      this.proxyOf.nodes.splice(child, 1);
+      let index;
+      for (let id in this.indexes) {
+        index = this.indexes[id];
+        if (index >= child) {
+          this.indexes[id] = index - 1;
+        }
+      }
+      this.markDirty();
+      return this;
+    }
+    replaceValues(pattern, opts, callback) {
+      if (!callback) {
+        callback = opts;
+        opts = {};
+      }
+      this.walkDecls((decl) => {
+        if (opts.props && !opts.props.includes(decl.prop)) return;
+        if (opts.fast && !decl.value.includes(opts.fast)) return;
+        decl.value = decl.value.replace(pattern, callback);
+      });
+      this.markDirty();
+      return this;
+    }
+    some(condition) {
+      return this.nodes.some(condition);
+    }
+    walk(callback) {
+      return this.each((child, i) => {
+        let result2;
+        try {
+          result2 = callback(child, i);
+        } catch (e) {
+          throw child.addToError(e);
+        }
+        if (result2 !== false && child.walk) {
+          result2 = child.walk(callback);
+        }
+        return result2;
+      });
+    }
+    walkAtRules(name, callback) {
+      if (!callback) {
+        callback = name;
+        return this.walk((child, i) => {
+          if (child.type === "atrule") {
+            return callback(child, i);
+          }
+        });
+      }
+      if (name instanceof RegExp) {
+        return this.walk((child, i) => {
+          if (child.type === "atrule" && name.test(child.name)) {
+            return callback(child, i);
+          }
+        });
+      }
+      return this.walk((child, i) => {
+        if (child.type === "atrule" && child.name === name) {
+          return callback(child, i);
+        }
+      });
+    }
+    walkComments(callback) {
+      return this.walk((child, i) => {
+        if (child.type === "comment") {
+          return callback(child, i);
+        }
+      });
+    }
+    walkDecls(prop, callback) {
+      if (!callback) {
+        callback = prop;
+        return this.walk((child, i) => {
+          if (child.type === "decl") {
+            return callback(child, i);
+          }
+        });
+      }
+      if (prop instanceof RegExp) {
+        return this.walk((child, i) => {
+          if (child.type === "decl" && prop.test(child.prop)) {
+            return callback(child, i);
+          }
+        });
+      }
+      return this.walk((child, i) => {
+        if (child.type === "decl" && child.prop === prop) {
+          return callback(child, i);
+        }
+      });
+    }
+    walkRules(selector, callback) {
+      if (!callback) {
+        callback = selector;
+        return this.walk((child, i) => {
+          if (child.type === "rule") {
+            return callback(child, i);
+          }
+        });
+      }
+      if (selector instanceof RegExp) {
+        return this.walk((child, i) => {
+          if (child.type === "rule" && selector.test(child.selector)) {
+            return callback(child, i);
+          }
+        });
+      }
+      return this.walk((child, i) => {
+        if (child.type === "rule" && child.selector === selector) {
+          return callback(child, i);
+        }
+      });
+    }
+    get first() {
+      if (!this.proxyOf.nodes) return void 0;
+      return this.proxyOf.nodes[0];
+    }
+    get last() {
+      if (!this.proxyOf.nodes) return void 0;
+      return this.proxyOf.nodes[this.proxyOf.nodes.length - 1];
+    }
+  }
+  Container.registerParse = (dependant) => {
+    parse = dependant;
+  };
+  Container.registerRule = (dependant) => {
+    Rule = dependant;
+  };
+  Container.registerAtRule = (dependant) => {
+    AtRule = dependant;
+  };
+  Container.registerRoot = (dependant) => {
+    Root = dependant;
+  };
+  container = Container;
+  Container.default = Container;
+  Container.rebuild = (node2) => {
+    if (node2.type === "atrule") {
+      Object.setPrototypeOf(node2, AtRule.prototype);
+    } else if (node2.type === "rule") {
+      Object.setPrototypeOf(node2, Rule.prototype);
+    } else if (node2.type === "decl") {
+      Object.setPrototypeOf(node2, Declaration.prototype);
+    } else if (node2.type === "comment") {
+      Object.setPrototypeOf(node2, Comment.prototype);
+    } else if (node2.type === "root") {
+      Object.setPrototypeOf(node2, Root.prototype);
+    }
+    node2[my] = true;
+    if (node2.nodes) {
+      node2.nodes.forEach((child) => {
+        Container.rebuild(child);
+      });
+    }
+  };
+  return container;
+}
+var atRule;
+var hasRequiredAtRule;
+function requireAtRule() {
+  if (hasRequiredAtRule) return atRule;
+  hasRequiredAtRule = 1;
+  let Container = requireContainer();
+  class AtRule extends Container {
+    constructor(defaults) {
+      super(defaults);
+      this.type = "atrule";
+    }
+    append(...children) {
+      if (!this.proxyOf.nodes) this.nodes = [];
+      return super.append(...children);
+    }
+    prepend(...children) {
+      if (!this.proxyOf.nodes) this.nodes = [];
+      return super.prepend(...children);
+    }
+  }
+  atRule = AtRule;
+  AtRule.default = AtRule;
+  Container.registerAtRule(AtRule);
+  return atRule;
+}
+var document2;
+var hasRequiredDocument;
+function requireDocument() {
+  if (hasRequiredDocument) return document2;
+  hasRequiredDocument = 1;
+  let Container = requireContainer();
+  let LazyResult, Processor;
+  class Document extends Container {
+    constructor(defaults) {
+      super(__spreadValues({ type: "document" }, defaults));
+      if (!this.nodes) {
+        this.nodes = [];
+      }
+    }
+    toResult(opts = {}) {
+      let lazy = new LazyResult(new Processor(), this, opts);
+      return lazy.stringify();
+    }
+  }
+  Document.registerLazyResult = (dependant) => {
+    LazyResult = dependant;
+  };
+  Document.registerProcessor = (dependant) => {
+    Processor = dependant;
+  };
+  document2 = Document;
+  Document.default = Document;
+  return document2;
+}
+var nonSecure;
+var hasRequiredNonSecure;
+function requireNonSecure() {
+  if (hasRequiredNonSecure) return nonSecure;
+  hasRequiredNonSecure = 1;
+  let urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+  let customAlphabet = (alphabet, defaultSize = 21) => {
+    return (size = defaultSize) => {
+      let id = "";
+      let i = size | 0;
+      while (i--) {
+        id += alphabet[Math.random() * alphabet.length | 0];
+      }
+      return id;
+    };
+  };
+  let nanoid = (size = 21) => {
+    let id = "";
+    let i = size | 0;
+    while (i--) {
+      id += urlAlphabet[Math.random() * 64 | 0];
+    }
+    return id;
+  };
+  nonSecure = { nanoid, customAlphabet };
+  return nonSecure;
+}
+var previousMap;
+var hasRequiredPreviousMap;
+function requirePreviousMap() {
+  if (hasRequiredPreviousMap) return previousMap;
+  hasRequiredPreviousMap = 1;
+  let { existsSync, readFileSync } = require$$2;
+  let { dirname, join } = require$$2;
+  let { SourceMapConsumer, SourceMapGenerator } = require$$2;
+  function fromBase64(str) {
+    if (Buffer) {
+      return Buffer.from(str, "base64").toString();
+    } else {
+      return window.atob(str);
+    }
+  }
+  class PreviousMap {
+    constructor(css, opts) {
+      if (opts.map === false) return;
+      this.loadAnnotation(css);
+      this.inline = this.startWith(this.annotation, "data:");
+      let prev = opts.map ? opts.map.prev : void 0;
+      let text = this.loadMap(opts.from, prev);
+      if (!this.mapFile && opts.from) {
+        this.mapFile = opts.from;
+      }
+      if (this.mapFile) this.root = dirname(this.mapFile);
+      if (text) this.text = text;
+    }
+    consumer() {
+      if (!this.consumerCache) {
+        this.consumerCache = new SourceMapConsumer(this.text);
+      }
+      return this.consumerCache;
+    }
+    decodeInline(text) {
+      let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/;
+      let baseUri = /^data:application\/json;base64,/;
+      let charsetUri = /^data:application\/json;charset=utf-?8,/;
+      let uri = /^data:application\/json,/;
+      let uriMatch = text.match(charsetUri) || text.match(uri);
+      if (uriMatch) {
+        return decodeURIComponent(text.substr(uriMatch[0].length));
+      }
+      let baseUriMatch = text.match(baseCharsetUri) || text.match(baseUri);
+      if (baseUriMatch) {
+        return fromBase64(text.substr(baseUriMatch[0].length));
+      }
+      let encoding = text.match(/data:application\/json;([^,]+),/)[1];
+      throw new Error("Unsupported source map encoding " + encoding);
+    }
+    getAnnotationURL(sourceMapString) {
+      return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, "").trim();
+    }
+    isMap(map) {
+      if (typeof map !== "object") return false;
+      return typeof map.mappings === "string" || typeof map._mappings === "string" || Array.isArray(map.sections);
+    }
+    loadAnnotation(css) {
+      let comments = css.match(/\/\*\s*# sourceMappingURL=/g);
+      if (!comments) return;
+      let start = css.lastIndexOf(comments.pop());
+      let end = css.indexOf("*/", start);
+      if (start > -1 && end > -1) {
+        this.annotation = this.getAnnotationURL(css.substring(start, end));
+      }
+    }
+    loadFile(path) {
+      this.root = dirname(path);
+      if (existsSync(path)) {
+        this.mapFile = path;
+        return readFileSync(path, "utf-8").toString().trim();
+      }
+    }
+    loadMap(file, prev) {
+      if (prev === false) return false;
+      if (prev) {
+        if (typeof prev === "string") {
+          return prev;
+        } else if (typeof prev === "function") {
+          let prevPath = prev(file);
+          if (prevPath) {
+            let map = this.loadFile(prevPath);
+            if (!map) {
+              throw new Error(
+                "Unable to load previous source map: " + prevPath.toString()
+              );
+            }
+            return map;
+          }
+        } else if (prev instanceof SourceMapConsumer) {
+          return SourceMapGenerator.fromSourceMap(prev).toString();
+        } else if (prev instanceof SourceMapGenerator) {
+          return prev.toString();
+        } else if (this.isMap(prev)) {
+          return JSON.stringify(prev);
+        } else {
+          throw new Error(
+            "Unsupported previous source map format: " + prev.toString()
+          );
+        }
+      } else if (this.inline) {
+        return this.decodeInline(this.annotation);
+      } else if (this.annotation) {
+        let map = this.annotation;
+        if (file) map = join(dirname(file), map);
+        return this.loadFile(map);
+      }
+    }
+    startWith(string, start) {
+      if (!string) return false;
+      return string.substr(0, start.length) === start;
+    }
+    withContent() {
+      return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
+    }
+  }
+  previousMap = PreviousMap;
+  PreviousMap.default = PreviousMap;
+  return previousMap;
+}
+var input;
+var hasRequiredInput;
+function requireInput() {
+  if (hasRequiredInput) return input;
+  hasRequiredInput = 1;
+  let { nanoid } = /* @__PURE__ */ requireNonSecure();
+  let { isAbsolute, resolve } = require$$2;
+  let { SourceMapConsumer, SourceMapGenerator } = require$$2;
+  let { fileURLToPath, pathToFileURL } = require$$2;
+  let CssSyntaxError = requireCssSyntaxError();
+  let PreviousMap = requirePreviousMap();
+  let terminalHighlight = require$$2;
+  let fromOffsetCache = Symbol("fromOffsetCache");
+  let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
+  let pathAvailable = Boolean(resolve && isAbsolute);
+  class Input {
+    constructor(css, opts = {}) {
+      if (css === null || typeof css === "undefined" || typeof css === "object" && !css.toString) {
+        throw new Error(`PostCSS received ${css} instead of CSS string`);
+      }
+      this.css = css.toString();
+      if (this.css[0] === "\uFEFF" || this.css[0] === "\uFFFE") {
+        this.hasBOM = true;
+        this.css = this.css.slice(1);
+      } else {
+        this.hasBOM = false;
+      }
+      this.document = this.css;
+      if (opts.document) this.document = opts.document.toString();
+      if (opts.from) {
+        if (!pathAvailable || /^\w+:\/\//.test(opts.from) || isAbsolute(opts.from)) {
+          this.file = opts.from;
+        } else {
+          this.file = resolve(opts.from);
+        }
+      }
+      if (pathAvailable && sourceMapAvailable) {
+        let map = new PreviousMap(this.css, opts);
+        if (map.text) {
+          this.map = map;
+          let file = map.consumer().file;
+          if (!this.file && file) this.file = this.mapResolve(file);
+        }
+      }
+      if (!this.file) {
+        this.id = "<input css " + nanoid(6) + ">";
+      }
+      if (this.map) this.map.file = this.from;
+    }
+    error(message, line, column, opts = {}) {
+      let endColumn, endLine, result2;
+      if (line && typeof line === "object") {
+        let start = line;
+        let end = column;
+        if (typeof start.offset === "number") {
+          let pos = this.fromOffset(start.offset);
+          line = pos.line;
+          column = pos.col;
+        } else {
+          line = start.line;
+          column = start.column;
+        }
+        if (typeof end.offset === "number") {
+          let pos = this.fromOffset(end.offset);
+          endLine = pos.line;
+          endColumn = pos.col;
+        } else {
+          endLine = end.line;
+          endColumn = end.column;
+        }
+      } else if (!column) {
+        let pos = this.fromOffset(line);
+        line = pos.line;
+        column = pos.col;
+      }
+      let origin = this.origin(line, column, endLine, endColumn);
+      if (origin) {
+        result2 = new CssSyntaxError(
+          message,
+          origin.endLine === void 0 ? origin.line : { column: origin.column, line: origin.line },
+          origin.endLine === void 0 ? origin.column : { column: origin.endColumn, line: origin.endLine },
+          origin.source,
+          origin.file,
+          opts.plugin
+        );
+      } else {
+        result2 = new CssSyntaxError(
+          message,
+          endLine === void 0 ? line : { column, line },
+          endLine === void 0 ? column : { column: endColumn, line: endLine },
+          this.css,
+          this.file,
+          opts.plugin
+        );
+      }
+      result2.input = { column, endColumn, endLine, line, source: this.css };
+      if (this.file) {
+        if (pathToFileURL) {
+          result2.input.url = pathToFileURL(this.file).toString();
+        }
+        result2.input.file = this.file;
+      }
+      return result2;
+    }
+    fromOffset(offset) {
+      let lastLine, lineToIndex;
+      if (!this[fromOffsetCache]) {
+        let lines = this.css.split("\n");
+        lineToIndex = new Array(lines.length);
+        let prevIndex = 0;
+        for (let i = 0, l = lines.length; i < l; i++) {
+          lineToIndex[i] = prevIndex;
+          prevIndex += lines[i].length + 1;
+        }
+        this[fromOffsetCache] = lineToIndex;
+      } else {
+        lineToIndex = this[fromOffsetCache];
+      }
+      lastLine = lineToIndex[lineToIndex.length - 1];
+      let min = 0;
+      if (offset >= lastLine) {
+        min = lineToIndex.length - 1;
+      } else {
+        let max = lineToIndex.length - 2;
+        let mid;
+        while (min < max) {
+          mid = min + (max - min >> 1);
+          if (offset < lineToIndex[mid]) {
+            max = mid - 1;
+          } else if (offset >= lineToIndex[mid + 1]) {
+            min = mid + 1;
+          } else {
+            min = mid;
+            break;
+          }
+        }
+      }
+      return {
+        col: offset - lineToIndex[min] + 1,
+        line: min + 1
+      };
+    }
+    mapResolve(file) {
+      if (/^\w+:\/\//.test(file)) {
+        return file;
+      }
+      return resolve(this.map.consumer().sourceRoot || this.map.root || ".", file);
+    }
+    origin(line, column, endLine, endColumn) {
+      if (!this.map) return false;
+      let consumer = this.map.consumer();
+      let from = consumer.originalPositionFor({ column, line });
+      if (!from.source) return false;
+      let to;
+      if (typeof endLine === "number") {
+        to = consumer.originalPositionFor({ column: endColumn, line: endLine });
+      }
+      let fromUrl;
+      if (isAbsolute(from.source)) {
+        fromUrl = pathToFileURL(from.source);
+      } else {
+        fromUrl = new URL(
+          from.source,
+          this.map.consumer().sourceRoot || pathToFileURL(this.map.mapFile)
+        );
+      }
+      let result2 = {
+        column: from.column,
+        endColumn: to && to.column,
+        endLine: to && to.line,
+        line: from.line,
+        url: fromUrl.toString()
+      };
+      if (fromUrl.protocol === "file:") {
+        if (fileURLToPath) {
+          result2.file = fileURLToPath(fromUrl);
+        } else {
+          throw new Error(`file: protocol is not available in this PostCSS build`);
+        }
+      }
+      let source = consumer.sourceContentFor(from.source);
+      if (source) result2.source = source;
+      return result2;
+    }
+    toJSON() {
+      let json = {};
+      for (let name of ["hasBOM", "css", "file", "id"]) {
+        if (this[name] != null) {
+          json[name] = this[name];
+        }
+      }
+      if (this.map) {
+        json.map = __spreadValues({}, this.map);
+        if (json.map.consumerCache) {
+          json.map.consumerCache = void 0;
+        }
+      }
+      return json;
+    }
+    get from() {
+      return this.file || this.id;
+    }
+  }
+  input = Input;
+  Input.default = Input;
+  if (terminalHighlight && terminalHighlight.registerInput) {
+    terminalHighlight.registerInput(Input);
+  }
+  return input;
+}
+var root;
+var hasRequiredRoot;
+function requireRoot() {
+  if (hasRequiredRoot) return root;
+  hasRequiredRoot = 1;
+  let Container = requireContainer();
+  let LazyResult, Processor;
+  class Root extends Container {
+    constructor(defaults) {
+      super(defaults);
+      this.type = "root";
+      if (!this.nodes) this.nodes = [];
+    }
+    normalize(child, sample, type) {
+      let nodes = super.normalize(child);
+      if (sample) {
+        if (type === "prepend") {
+          if (this.nodes.length > 1) {
+            sample.raws.before = this.nodes[1].raws.before;
+          } else {
+            delete sample.raws.before;
+          }
+        } else if (this.first !== sample) {
+          for (let node2 of nodes) {
+            node2.raws.before = sample.raws.before;
+          }
+        }
+      }
+      return nodes;
+    }
+    removeChild(child, ignore) {
+      let index = this.index(child);
+      if (!ignore && index === 0 && this.nodes.length > 1) {
+        this.nodes[1].raws.before = this.nodes[index].raws.before;
+      }
+      return super.removeChild(child);
+    }
+    toResult(opts = {}) {
+      let lazy = new LazyResult(new Processor(), this, opts);
+      return lazy.stringify();
+    }
+  }
+  Root.registerLazyResult = (dependant) => {
+    LazyResult = dependant;
+  };
+  Root.registerProcessor = (dependant) => {
+    Processor = dependant;
+  };
+  root = Root;
+  Root.default = Root;
+  Container.registerRoot(Root);
+  return root;
+}
+var list_1;
+var hasRequiredList;
+function requireList() {
+  if (hasRequiredList) return list_1;
+  hasRequiredList = 1;
+  let list = {
+    comma(string) {
+      return list.split(string, [","], true);
+    },
+    space(string) {
+      let spaces = [" ", "\n", "	"];
+      return list.split(string, spaces);
+    },
+    split(string, separators, last) {
+      let array = [];
+      let current = "";
+      let split = false;
+      let func = 0;
+      let inQuote = false;
+      let prevQuote = "";
+      let escape = false;
+      for (let letter of string) {
+        if (escape) {
+          escape = false;
+        } else if (letter === "\\") {
+          escape = true;
+        } else if (inQuote) {
+          if (letter === prevQuote) {
+            inQuote = false;
+          }
+        } else if (letter === '"' || letter === "'") {
+          inQuote = true;
+          prevQuote = letter;
+        } else if (letter === "(") {
+          func += 1;
+        } else if (letter === ")") {
+          if (func > 0) func -= 1;
+        } else if (func === 0) {
+          if (separators.includes(letter)) split = true;
+        }
+        if (split) {
+          if (current !== "") array.push(current.trim());
+          current = "";
+          split = false;
+        } else {
+          current += letter;
+        }
+      }
+      if (last || current !== "") array.push(current.trim());
+      return array;
+    }
+  };
+  list_1 = list;
+  list.default = list;
+  return list_1;
+}
+var rule;
+var hasRequiredRule;
+function requireRule() {
+  if (hasRequiredRule) return rule;
+  hasRequiredRule = 1;
+  let Container = requireContainer();
+  let list = requireList();
+  class Rule extends Container {
+    constructor(defaults) {
+      super(defaults);
+      this.type = "rule";
+      if (!this.nodes) this.nodes = [];
+    }
+    get selectors() {
+      return list.comma(this.selector);
+    }
+    set selectors(values) {
+      let match = this.selector ? this.selector.match(/,\s*/) : null;
+      let sep = match ? match[0] : "," + this.raw("between", "beforeOpen");
+      this.selector = values.join(sep);
+    }
+  }
+  rule = Rule;
+  Rule.default = Rule;
+  Container.registerRule(Rule);
+  return rule;
+}
+var fromJSON_1;
+var hasRequiredFromJSON;
+function requireFromJSON() {
+  if (hasRequiredFromJSON) return fromJSON_1;
+  hasRequiredFromJSON = 1;
+  let AtRule = requireAtRule();
+  let Comment = requireComment();
+  let Declaration = requireDeclaration();
+  let Input = requireInput();
+  let PreviousMap = requirePreviousMap();
+  let Root = requireRoot();
+  let Rule = requireRule();
+  function fromJSON(json, inputs) {
+    if (Array.isArray(json)) return json.map((n) => fromJSON(n));
+    let _a = json, { inputs: ownInputs } = _a, defaults = __objRest(_a, ["inputs"]);
+    if (ownInputs) {
+      inputs = [];
+      for (let input2 of ownInputs) {
+        let inputHydrated = __spreadProps(__spreadValues({}, input2), { __proto__: Input.prototype });
+        if (inputHydrated.map) {
+          inputHydrated.map = __spreadProps(__spreadValues({}, inputHydrated.map), {
+            __proto__: PreviousMap.prototype
+          });
+        }
+        inputs.push(inputHydrated);
+      }
+    }
+    if (defaults.nodes) {
+      defaults.nodes = json.nodes.map((n) => fromJSON(n, inputs));
+    }
+    if (defaults.source) {
+      let _b = defaults.source, { inputId } = _b, source = __objRest(_b, ["inputId"]);
+      defaults.source = source;
+      if (inputId != null) {
+        defaults.source.input = inputs[inputId];
+      }
+    }
+    if (defaults.type === "root") {
+      return new Root(defaults);
+    } else if (defaults.type === "decl") {
+      return new Declaration(defaults);
+    } else if (defaults.type === "rule") {
+      return new Rule(defaults);
+    } else if (defaults.type === "comment") {
+      return new Comment(defaults);
+    } else if (defaults.type === "atrule") {
+      return new AtRule(defaults);
+    } else {
+      throw new Error("Unknown node type: " + json.type);
+    }
+  }
+  fromJSON_1 = fromJSON;
+  fromJSON.default = fromJSON;
+  return fromJSON_1;
+}
+var mapGenerator;
+var hasRequiredMapGenerator;
+function requireMapGenerator() {
+  if (hasRequiredMapGenerator) return mapGenerator;
+  hasRequiredMapGenerator = 1;
+  let { dirname, relative, resolve, sep } = require$$2;
+  let { SourceMapConsumer, SourceMapGenerator } = require$$2;
+  let { pathToFileURL } = require$$2;
+  let Input = requireInput();
+  let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
+  let pathAvailable = Boolean(dirname && resolve && relative && sep);
+  class MapGenerator {
+    constructor(stringify, root2, opts, cssString) {
+      this.stringify = stringify;
+      this.mapOpts = opts.map || {};
+      this.root = root2;
+      this.opts = opts;
+      this.css = cssString;
+      this.originalCSS = cssString;
+      this.usesFileUrls = !this.mapOpts.from && this.mapOpts.absolute;
+      this.memoizedFileURLs = /* @__PURE__ */ new Map();
+      this.memoizedPaths = /* @__PURE__ */ new Map();
+      this.memoizedURLs = /* @__PURE__ */ new Map();
+    }
+    addAnnotation() {
+      let content;
+      if (this.isInline()) {
+        content = "data:application/json;base64," + this.toBase64(this.map.toString());
+      } else if (typeof this.mapOpts.annotation === "string") {
+        content = this.mapOpts.annotation;
+      } else if (typeof this.mapOpts.annotation === "function") {
+        content = this.mapOpts.annotation(this.opts.to, this.root);
+      } else {
+        content = this.outputFile() + ".map";
+      }
+      let eol = "\n";
+      if (this.css.includes("\r\n")) eol = "\r\n";
+      this.css += eol + "/*# sourceMappingURL=" + content + " */";
+    }
+    applyPrevMaps() {
+      for (let prev of this.previous()) {
+        let from = this.toUrl(this.path(prev.file));
+        let root2 = prev.root || dirname(prev.file);
+        let map;
+        if (this.mapOpts.sourcesContent === false) {
+          map = new SourceMapConsumer(prev.text);
+          if (map.sourcesContent) {
+            map.sourcesContent = null;
+          }
+        } else {
+          map = prev.consumer();
+        }
+        this.map.applySourceMap(map, from, this.toUrl(this.path(root2)));
+      }
+    }
+    clearAnnotation() {
+      if (this.mapOpts.annotation === false) return;
+      if (this.root) {
+        let node2;
+        for (let i = this.root.nodes.length - 1; i >= 0; i--) {
+          node2 = this.root.nodes[i];
+          if (node2.type !== "comment") continue;
+          if (node2.text.startsWith("# sourceMappingURL=")) {
+            this.root.removeChild(i);
+          }
+        }
+      } else if (this.css) {
+        this.css = this.css.replace(/\n*\/\*#[\S\s]*?\*\/$/gm, "");
+      }
+    }
+    generate() {
+      this.clearAnnotation();
+      if (pathAvailable && sourceMapAvailable && this.isMap()) {
+        return this.generateMap();
+      } else {
+        let result2 = "";
+        this.stringify(this.root, (i) => {
+          result2 += i;
+        });
+        return [result2];
+      }
+    }
+    generateMap() {
+      if (this.root) {
+        this.generateString();
+      } else if (this.previous().length === 1) {
+        let prev = this.previous()[0].consumer();
+        prev.file = this.outputFile();
+        this.map = SourceMapGenerator.fromSourceMap(prev, {
+          ignoreInvalidMapping: true
+        });
+      } else {
+        this.map = new SourceMapGenerator({
+          file: this.outputFile(),
+          ignoreInvalidMapping: true
+        });
+        this.map.addMapping({
+          generated: { column: 0, line: 1 },
+          original: { column: 0, line: 1 },
+          source: this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>"
+        });
+      }
+      if (this.isSourcesContent()) this.setSourcesContent();
+      if (this.root && this.previous().length > 0) this.applyPrevMaps();
+      if (this.isAnnotation()) this.addAnnotation();
+      if (this.isInline()) {
+        return [this.css];
+      } else {
+        return [this.css, this.map];
+      }
+    }
+    generateString() {
+      this.css = "";
+      this.map = new SourceMapGenerator({
+        file: this.outputFile(),
+        ignoreInvalidMapping: true
+      });
+      let line = 1;
+      let column = 1;
+      let noSource = "<no source>";
+      let mapping = {
+        generated: { column: 0, line: 0 },
+        original: { column: 0, line: 0 },
+        source: ""
+      };
+      let last, lines;
+      this.stringify(this.root, (str, node2, type) => {
+        this.css += str;
+        if (node2 && type !== "end") {
+          mapping.generated.line = line;
+          mapping.generated.column = column - 1;
+          if (node2.source && node2.source.start) {
+            mapping.source = this.sourcePath(node2);
+            mapping.original.line = node2.source.start.line;
+            mapping.original.column = node2.source.start.column - 1;
+            this.map.addMapping(mapping);
+          } else {
+            mapping.source = noSource;
+            mapping.original.line = 1;
+            mapping.original.column = 0;
+            this.map.addMapping(mapping);
+          }
+        }
+        lines = str.match(/\n/g);
+        if (lines) {
+          line += lines.length;
+          last = str.lastIndexOf("\n");
+          column = str.length - last;
+        } else {
+          column += str.length;
+        }
+        if (node2 && type !== "start") {
+          let p = node2.parent || { raws: {} };
+          let childless = node2.type === "decl" || node2.type === "atrule" && !node2.nodes;
+          if (!childless || node2 !== p.last || p.raws.semicolon) {
+            if (node2.source && node2.source.end) {
+              mapping.source = this.sourcePath(node2);
+              mapping.original.line = node2.source.end.line;
+              mapping.original.column = node2.source.end.column - 1;
+              mapping.generated.line = line;
+              mapping.generated.column = column - 2;
+              this.map.addMapping(mapping);
+            } else {
+              mapping.source = noSource;
+              mapping.original.line = 1;
+              mapping.original.column = 0;
+              mapping.generated.line = line;
+              mapping.generated.column = column - 1;
+              this.map.addMapping(mapping);
+            }
+          }
+        }
+      });
+    }
+    isAnnotation() {
+      if (this.isInline()) {
+        return true;
+      }
+      if (typeof this.mapOpts.annotation !== "undefined") {
+        return this.mapOpts.annotation;
+      }
+      if (this.previous().length) {
+        return this.previous().some((i) => i.annotation);
+      }
+      return true;
+    }
+    isInline() {
+      if (typeof this.mapOpts.inline !== "undefined") {
+        return this.mapOpts.inline;
+      }
+      let annotation = this.mapOpts.annotation;
+      if (typeof annotation !== "undefined" && annotation !== true) {
+        return false;
+      }
+      if (this.previous().length) {
+        return this.previous().some((i) => i.inline);
+      }
+      return true;
+    }
+    isMap() {
+      if (typeof this.opts.map !== "undefined") {
+        return !!this.opts.map;
+      }
+      return this.previous().length > 0;
+    }
+    isSourcesContent() {
+      if (typeof this.mapOpts.sourcesContent !== "undefined") {
+        return this.mapOpts.sourcesContent;
+      }
+      if (this.previous().length) {
+        return this.previous().some((i) => i.withContent());
+      }
+      return true;
+    }
+    outputFile() {
+      if (this.opts.to) {
+        return this.path(this.opts.to);
+      } else if (this.opts.from) {
+        return this.path(this.opts.from);
+      } else {
+        return "to.css";
+      }
+    }
+    path(file) {
+      if (this.mapOpts.absolute) return file;
+      if (file.charCodeAt(0) === 60) return file;
+      if (/^\w+:\/\//.test(file)) return file;
+      let cached = this.memoizedPaths.get(file);
+      if (cached) return cached;
+      let from = this.opts.to ? dirname(this.opts.to) : ".";
+      if (typeof this.mapOpts.annotation === "string") {
+        from = dirname(resolve(from, this.mapOpts.annotation));
+      }
+      let path = relative(from, file);
+      this.memoizedPaths.set(file, path);
+      return path;
+    }
+    previous() {
+      if (!this.previousMaps) {
+        this.previousMaps = [];
+        if (this.root) {
+          this.root.walk((node2) => {
+            if (node2.source && node2.source.input.map) {
+              let map = node2.source.input.map;
+              if (!this.previousMaps.includes(map)) {
+                this.previousMaps.push(map);
+              }
+            }
+          });
+        } else {
+          let input2 = new Input(this.originalCSS, this.opts);
+          if (input2.map) this.previousMaps.push(input2.map);
+        }
+      }
+      return this.previousMaps;
+    }
+    setSourcesContent() {
+      let already = {};
+      if (this.root) {
+        this.root.walk((node2) => {
+          if (node2.source) {
+            let from = node2.source.input.from;
+            if (from && !already[from]) {
+              already[from] = true;
+              let fromUrl = this.usesFileUrls ? this.toFileUrl(from) : this.toUrl(this.path(from));
+              this.map.setSourceContent(fromUrl, node2.source.input.css);
+            }
+          }
+        });
+      } else if (this.css) {
+        let from = this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>";
+        this.map.setSourceContent(from, this.css);
+      }
+    }
+    sourcePath(node2) {
+      if (this.mapOpts.from) {
+        return this.toUrl(this.mapOpts.from);
+      } else if (this.usesFileUrls) {
+        return this.toFileUrl(node2.source.input.from);
+      } else {
+        return this.toUrl(this.path(node2.source.input.from));
+      }
+    }
+    toBase64(str) {
+      if (Buffer) {
+        return Buffer.from(str).toString("base64");
+      } else {
+        return window.btoa(unescape(encodeURIComponent(str)));
+      }
+    }
+    toFileUrl(path) {
+      let cached = this.memoizedFileURLs.get(path);
+      if (cached) return cached;
+      if (pathToFileURL) {
+        let fileURL = pathToFileURL(path).toString();
+        this.memoizedFileURLs.set(path, fileURL);
+        return fileURL;
+      } else {
+        throw new Error(
+          "`map.absolute` option is not available in this PostCSS build"
+        );
+      }
+    }
+    toUrl(path) {
+      let cached = this.memoizedURLs.get(path);
+      if (cached) return cached;
+      if (sep === "\\") {
+        path = path.replace(/\\/g, "/");
+      }
+      let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent);
+      this.memoizedURLs.set(path, url);
+      return url;
+    }
+  }
+  mapGenerator = MapGenerator;
+  return mapGenerator;
+}
+var tokenize;
+var hasRequiredTokenize;
+function requireTokenize() {
+  if (hasRequiredTokenize) return tokenize;
+  hasRequiredTokenize = 1;
+  const SINGLE_QUOTE = "'".charCodeAt(0);
+  const DOUBLE_QUOTE = '"'.charCodeAt(0);
+  const BACKSLASH = "\\".charCodeAt(0);
+  const SLASH = "/".charCodeAt(0);
+  const NEWLINE = "\n".charCodeAt(0);
+  const SPACE = " ".charCodeAt(0);
+  const FEED = "\f".charCodeAt(0);
+  const TAB = "	".charCodeAt(0);
+  const CR = "\r".charCodeAt(0);
+  const OPEN_SQUARE = "[".charCodeAt(0);
+  const CLOSE_SQUARE = "]".charCodeAt(0);
+  const OPEN_PARENTHESES = "(".charCodeAt(0);
+  const CLOSE_PARENTHESES = ")".charCodeAt(0);
+  const OPEN_CURLY = "{".charCodeAt(0);
+  const CLOSE_CURLY = "}".charCodeAt(0);
+  const SEMICOLON = ";".charCodeAt(0);
+  const ASTERISK = "*".charCodeAt(0);
+  const COLON = ":".charCodeAt(0);
+  const AT = "@".charCodeAt(0);
+  const RE_AT_END = /[\t\n\f\r "#'()/;[\\\]{}]/g;
+  const RE_WORD_END = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g;
+  const RE_BAD_BRACKET = /.[\r\n"'(/\\]/;
+  const RE_HEX_ESCAPE = /[\da-f]/i;
+  tokenize = function tokenizer(input2, options = {}) {
+    let css = input2.css.valueOf();
+    let ignore = options.ignoreErrors;
+    let code, content, escape, next, quote;
+    let currentToken, escaped, escapePos, n, prev;
+    let length = css.length;
+    let pos = 0;
+    let buffer = [];
+    let returned = [];
+    function position() {
+      return pos;
+    }
+    function unclosed(what) {
+      throw input2.error("Unclosed " + what, pos);
+    }
+    function endOfFile() {
+      return returned.length === 0 && pos >= length;
+    }
+    function nextToken(opts) {
+      if (returned.length) return returned.pop();
+      if (pos >= length) return;
+      let ignoreUnclosed = opts ? opts.ignoreUnclosed : false;
+      code = css.charCodeAt(pos);
+      switch (code) {
+        case NEWLINE:
+        case SPACE:
+        case TAB:
+        case CR:
+        case FEED: {
+          next = pos;
+          do {
+            next += 1;
+            code = css.charCodeAt(next);
+          } while (code === SPACE || code === NEWLINE || code === TAB || code === CR || code === FEED);
+          currentToken = ["space", css.slice(pos, next)];
+          pos = next - 1;
+          break;
+        }
+        case OPEN_SQUARE:
+        case CLOSE_SQUARE:
+        case OPEN_CURLY:
+        case CLOSE_CURLY:
+        case COLON:
+        case SEMICOLON:
+        case CLOSE_PARENTHESES: {
+          let controlChar = String.fromCharCode(code);
+          currentToken = [controlChar, controlChar, pos];
+          break;
+        }
+        case OPEN_PARENTHESES: {
+          prev = buffer.length ? buffer.pop()[1] : "";
+          n = css.charCodeAt(pos + 1);
+          if (prev === "url" && n !== SINGLE_QUOTE && n !== DOUBLE_QUOTE && n !== SPACE && n !== NEWLINE && n !== TAB && n !== FEED && n !== CR) {
+            next = pos;
+            do {
+              escaped = false;
+              next = css.indexOf(")", next + 1);
+              if (next === -1) {
+                if (ignore || ignoreUnclosed) {
+                  next = pos;
+                  break;
+                } else {
+                  unclosed("bracket");
+                }
+              }
+              escapePos = next;
+              while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
+                escapePos -= 1;
+                escaped = !escaped;
+              }
+            } while (escaped);
+            currentToken = ["brackets", css.slice(pos, next + 1), pos, next];
+            pos = next;
+          } else {
+            next = css.indexOf(")", pos + 1);
+            content = css.slice(pos, next + 1);
+            if (next === -1 || RE_BAD_BRACKET.test(content)) {
+              currentToken = ["(", "(", pos];
+            } else {
+              currentToken = ["brackets", content, pos, next];
+              pos = next;
+            }
+          }
+          break;
+        }
+        case SINGLE_QUOTE:
+        case DOUBLE_QUOTE: {
+          quote = code === SINGLE_QUOTE ? "'" : '"';
+          next = pos;
+          do {
+            escaped = false;
+            next = css.indexOf(quote, next + 1);
+            if (next === -1) {
+              if (ignore || ignoreUnclosed) {
+                next = pos + 1;
+                break;
+              } else {
+                unclosed("string");
+              }
+            }
+            escapePos = next;
+            while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
+              escapePos -= 1;
+              escaped = !escaped;
+            }
+          } while (escaped);
+          currentToken = ["string", css.slice(pos, next + 1), pos, next];
+          pos = next;
+          break;
+        }
+        case AT: {
+          RE_AT_END.lastIndex = pos + 1;
+          RE_AT_END.test(css);
+          if (RE_AT_END.lastIndex === 0) {
+            next = css.length - 1;
+          } else {
+            next = RE_AT_END.lastIndex - 2;
+          }
+          currentToken = ["at-word", css.slice(pos, next + 1), pos, next];
+          pos = next;
+          break;
+        }
+        case BACKSLASH: {
+          next = pos;
+          escape = true;
+          while (css.charCodeAt(next + 1) === BACKSLASH) {
+            next += 1;
+            escape = !escape;
+          }
+          code = css.charCodeAt(next + 1);
+          if (escape && code !== SLASH && code !== SPACE && code !== NEWLINE && code !== TAB && code !== CR && code !== FEED) {
+            next += 1;
+            if (RE_HEX_ESCAPE.test(css.charAt(next))) {
+              while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {
+                next += 1;
+              }
+              if (css.charCodeAt(next + 1) === SPACE) {
+                next += 1;
+              }
+            }
+          }
+          currentToken = ["word", css.slice(pos, next + 1), pos, next];
+          pos = next;
+          break;
+        }
+        default: {
+          if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {
+            next = css.indexOf("*/", pos + 2) + 1;
+            if (next === 0) {
+              if (ignore || ignoreUnclosed) {
+                next = css.length;
+              } else {
+                unclosed("comment");
+              }
+            }
+            currentToken = ["comment", css.slice(pos, next + 1), pos, next];
+            pos = next;
+          } else {
+            RE_WORD_END.lastIndex = pos + 1;
+            RE_WORD_END.test(css);
+            if (RE_WORD_END.lastIndex === 0) {
+              next = css.length - 1;
+            } else {
+              next = RE_WORD_END.lastIndex - 2;
+            }
+            currentToken = ["word", css.slice(pos, next + 1), pos, next];
+            buffer.push(currentToken);
+            pos = next;
+          }
+          break;
+        }
+      }
+      pos++;
+      return currentToken;
+    }
+    function back(token) {
+      returned.push(token);
+    }
+    return {
+      back,
+      endOfFile,
+      nextToken,
+      position
+    };
+  };
+  return tokenize;
+}
+var parser;
+var hasRequiredParser;
+function requireParser() {
+  if (hasRequiredParser) return parser;
+  hasRequiredParser = 1;
+  let AtRule = requireAtRule();
+  let Comment = requireComment();
+  let Declaration = requireDeclaration();
+  let Root = requireRoot();
+  let Rule = requireRule();
+  let tokenizer = requireTokenize();
+  const SAFE_COMMENT_NEIGHBOR = {
+    empty: true,
+    space: true
+  };
+  function findLastWithPosition(tokens) {
+    for (let i = tokens.length - 1; i >= 0; i--) {
+      let token = tokens[i];
+      let pos = token[3] || token[2];
+      if (pos) return pos;
+    }
+  }
+  class Parser {
+    constructor(input2) {
+      this.input = input2;
+      this.root = new Root();
+      this.current = this.root;
+      this.spaces = "";
+      this.semicolon = false;
+      this.createTokenizer();
+      this.root.source = { input: input2, start: { column: 1, line: 1, offset: 0 } };
+    }
+    atrule(token) {
+      let node2 = new AtRule();
+      node2.name = token[1].slice(1);
+      if (node2.name === "") {
+        this.unnamedAtrule(node2, token);
+      }
+      this.init(node2, token[2]);
+      let type;
+      let prev;
+      let shift;
+      let last = false;
+      let open = false;
+      let params = [];
+      let brackets = [];
+      while (!this.tokenizer.endOfFile()) {
+        token = this.tokenizer.nextToken();
+        type = token[0];
+        if (type === "(" || type === "[") {
+          brackets.push(type === "(" ? ")" : "]");
+        } else if (type === "{" && brackets.length > 0) {
+          brackets.push("}");
+        } else if (type === brackets[brackets.length - 1]) {
+          brackets.pop();
+        }
+        if (brackets.length === 0) {
+          if (type === ";") {
+            node2.source.end = this.getPosition(token[2]);
+            node2.source.end.offset++;
+            this.semicolon = true;
+            break;
+          } else if (type === "{") {
+            open = true;
+            break;
+          } else if (type === "}") {
+            if (params.length > 0) {
+              shift = params.length - 1;
+              prev = params[shift];
+              while (prev && prev[0] === "space") {
+                prev = params[--shift];
+              }
+              if (prev) {
+                node2.source.end = this.getPosition(prev[3] || prev[2]);
+                node2.source.end.offset++;
+              }
+            }
+            this.end(token);
+            break;
+          } else {
+            params.push(token);
+          }
+        } else {
+          params.push(token);
+        }
+        if (this.tokenizer.endOfFile()) {
+          last = true;
+          break;
+        }
+      }
+      node2.raws.between = this.spacesAndCommentsFromEnd(params);
+      if (params.length) {
+        node2.raws.afterName = this.spacesAndCommentsFromStart(params);
+        this.raw(node2, "params", params);
+        if (last) {
+          token = params[params.length - 1];
+          node2.source.end = this.getPosition(token[3] || token[2]);
+          node2.source.end.offset++;
+          this.spaces = node2.raws.between;
+          node2.raws.between = "";
+        }
+      } else {
+        node2.raws.afterName = "";
+        node2.params = "";
+      }
+      if (open) {
+        node2.nodes = [];
+        this.current = node2;
+      }
+    }
+    checkMissedSemicolon(tokens) {
+      let colon = this.colon(tokens);
+      if (colon === false) return;
+      let founded = 0;
+      let token;
+      for (let j = colon - 1; j >= 0; j--) {
+        token = tokens[j];
+        if (token[0] !== "space") {
+          founded += 1;
+          if (founded === 2) break;
+        }
+      }
+      throw this.input.error(
+        "Missed semicolon",
+        token[0] === "word" ? token[3] + 1 : token[2]
+      );
+    }
+    colon(tokens) {
+      let brackets = 0;
+      let prev, token, type;
+      for (let [i, element] of tokens.entries()) {
+        token = element;
+        type = token[0];
+        if (type === "(") {
+          brackets += 1;
+        }
+        if (type === ")") {
+          brackets -= 1;
+        }
+        if (brackets === 0 && type === ":") {
+          if (!prev) {
+            this.doubleColon(token);
+          } else if (prev[0] === "word" && prev[1] === "progid") {
+            continue;
+          } else {
+            return i;
+          }
+        }
+        prev = token;
+      }
+      return false;
+    }
+    comment(token) {
+      let node2 = new Comment();
+      this.init(node2, token[2]);
+      node2.source.end = this.getPosition(token[3] || token[2]);
+      node2.source.end.offset++;
+      let text = token[1].slice(2, -2);
+      if (/^\s*$/.test(text)) {
+        node2.text = "";
+        node2.raws.left = text;
+        node2.raws.right = "";
+      } else {
+        let match = text.match(/^(\s*)([^]*\S)(\s*)$/);
+        node2.text = match[2];
+        node2.raws.left = match[1];
+        node2.raws.right = match[3];
+      }
+    }
+    createTokenizer() {
+      this.tokenizer = tokenizer(this.input);
+    }
+    decl(tokens, customProperty) {
+      let node2 = new Declaration();
+      this.init(node2, tokens[0][2]);
+      let last = tokens[tokens.length - 1];
+      if (last[0] === ";") {
+        this.semicolon = true;
+        tokens.pop();
+      }
+      node2.source.end = this.getPosition(
+        last[3] || last[2] || findLastWithPosition(tokens)
+      );
+      node2.source.end.offset++;
+      while (tokens[0][0] !== "word") {
+        if (tokens.length === 1) this.unknownWord(tokens);
+        node2.raws.before += tokens.shift()[1];
+      }
+      node2.source.start = this.getPosition(tokens[0][2]);
+      node2.prop = "";
+      while (tokens.length) {
+        let type = tokens[0][0];
+        if (type === ":" || type === "space" || type === "comment") {
+          break;
+        }
+        node2.prop += tokens.shift()[1];
+      }
+      node2.raws.between = "";
+      let token;
+      while (tokens.length) {
+        token = tokens.shift();
+        if (token[0] === ":") {
+          node2.raws.between += token[1];
+          break;
+        } else {
+          if (token[0] === "word" && /\w/.test(token[1])) {
+            this.unknownWord([token]);
+          }
+          node2.raws.between += token[1];
+        }
+      }
+      if (node2.prop[0] === "_" || node2.prop[0] === "*") {
+        node2.raws.before += node2.prop[0];
+        node2.prop = node2.prop.slice(1);
+      }
+      let firstSpaces = [];
+      let next;
+      while (tokens.length) {
+        next = tokens[0][0];
+        if (next !== "space" && next !== "comment") break;
+        firstSpaces.push(tokens.shift());
+      }
+      this.precheckMissedSemicolon(tokens);
+      for (let i = tokens.length - 1; i >= 0; i--) {
+        token = tokens[i];
+        if (token[1].toLowerCase() === "!important") {
+          node2.important = true;
+          let string = this.stringFrom(tokens, i);
+          string = this.spacesFromEnd(tokens) + string;
+          if (string !== " !important") node2.raws.important = string;
+          break;
+        } else if (token[1].toLowerCase() === "important") {
+          let cache = tokens.slice(0);
+          let str = "";
+          for (let j = i; j > 0; j--) {
+            let type = cache[j][0];
+            if (str.trim().startsWith("!") && type !== "space") {
+              break;
+            }
+            str = cache.pop()[1] + str;
+          }
+          if (str.trim().startsWith("!")) {
+            node2.important = true;
+            node2.raws.important = str;
+            tokens = cache;
+          }
+        }
+        if (token[0] !== "space" && token[0] !== "comment") {
+          break;
+        }
+      }
+      let hasWord = tokens.some((i) => i[0] !== "space" && i[0] !== "comment");
+      if (hasWord) {
+        node2.raws.between += firstSpaces.map((i) => i[1]).join("");
+        firstSpaces = [];
+      }
+      this.raw(node2, "value", firstSpaces.concat(tokens), customProperty);
+      if (node2.value.includes(":") && !customProperty) {
+        this.checkMissedSemicolon(tokens);
+      }
+    }
+    doubleColon(token) {
+      throw this.input.error(
+        "Double colon",
+        { offset: token[2] },
+        { offset: token[2] + token[1].length }
+      );
+    }
+    emptyRule(token) {
+      let node2 = new Rule();
+      this.init(node2, token[2]);
+      node2.selector = "";
+      node2.raws.between = "";
+      this.current = node2;
+    }
+    end(token) {
+      if (this.current.nodes && this.current.nodes.length) {
+        this.current.raws.semicolon = this.semicolon;
+      }
+      this.semicolon = false;
+      this.current.raws.after = (this.current.raws.after || "") + this.spaces;
+      this.spaces = "";
+      if (this.current.parent) {
+        this.current.source.end = this.getPosition(token[2]);
+        this.current.source.end.offset++;
+        this.current = this.current.parent;
+      } else {
+        this.unexpectedClose(token);
+      }
+    }
+    endFile() {
+      if (this.current.parent) this.unclosedBlock();
+      if (this.current.nodes && this.current.nodes.length) {
+        this.current.raws.semicolon = this.semicolon;
+      }
+      this.current.raws.after = (this.current.raws.after || "") + this.spaces;
+      this.root.source.end = this.getPosition(this.tokenizer.position());
+    }
+    freeSemicolon(token) {
+      this.spaces += token[1];
+      if (this.current.nodes) {
+        let prev = this.current.nodes[this.current.nodes.length - 1];
+        if (prev && prev.type === "rule" && !prev.raws.ownSemicolon) {
+          prev.raws.ownSemicolon = this.spaces;
+          this.spaces = "";
+        }
+      }
+    }
+    // Helpers
+    getPosition(offset) {
+      let pos = this.input.fromOffset(offset);
+      return {
+        column: pos.col,
+        line: pos.line,
+        offset
+      };
+    }
+    init(node2, offset) {
+      this.current.push(node2);
+      node2.source = {
+        input: this.input,
+        start: this.getPosition(offset)
+      };
+      node2.raws.before = this.spaces;
+      this.spaces = "";
+      if (node2.type !== "comment") this.semicolon = false;
+    }
+    other(start) {
+      let end = false;
+      let type = null;
+      let colon = false;
+      let bracket = null;
+      let brackets = [];
+      let customProperty = start[1].startsWith("--");
+      let tokens = [];
+      let token = start;
+      while (token) {
+        type = token[0];
+        tokens.push(token);
+        if (type === "(" || type === "[") {
+          if (!bracket) bracket = token;
+          brackets.push(type === "(" ? ")" : "]");
+        } else if (customProperty && colon && type === "{") {
+          if (!bracket) bracket = token;
+          brackets.push("}");
+        } else if (brackets.length === 0) {
+          if (type === ";") {
+            if (colon) {
+              this.decl(tokens, customProperty);
+              return;
+            } else {
+              break;
+            }
+          } else if (type === "{") {
+            this.rule(tokens);
+            return;
+          } else if (type === "}") {
+            this.tokenizer.back(tokens.pop());
+            end = true;
+            break;
+          } else if (type === ":") {
+            colon = true;
+          }
+        } else if (type === brackets[brackets.length - 1]) {
+          brackets.pop();
+          if (brackets.length === 0) bracket = null;
+        }
+        token = this.tokenizer.nextToken();
+      }
+      if (this.tokenizer.endOfFile()) end = true;
+      if (brackets.length > 0) this.unclosedBracket(bracket);
+      if (end && colon) {
+        if (!customProperty) {
+          while (tokens.length) {
+            token = tokens[tokens.length - 1][0];
+            if (token !== "space" && token !== "comment") break;
+            this.tokenizer.back(tokens.pop());
+          }
+        }
+        this.decl(tokens, customProperty);
+      } else {
+        this.unknownWord(tokens);
+      }
+    }
+    parse() {
+      let token;
+      while (!this.tokenizer.endOfFile()) {
+        token = this.tokenizer.nextToken();
+        switch (token[0]) {
+          case "space":
+            this.spaces += token[1];
+            break;
+          case ";":
+            this.freeSemicolon(token);
+            break;
+          case "}":
+            this.end(token);
+            break;
+          case "comment":
+            this.comment(token);
+            break;
+          case "at-word":
+            this.atrule(token);
+            break;
+          case "{":
+            this.emptyRule(token);
+            break;
+          default:
+            this.other(token);
+            break;
+        }
+      }
+      this.endFile();
+    }
+    precheckMissedSemicolon() {
+    }
+    raw(node2, prop, tokens, customProperty) {
+      let token, type;
+      let length = tokens.length;
+      let value = "";
+      let clean = true;
+      let next, prev;
+      for (let i = 0; i < length; i += 1) {
+        token = tokens[i];
+        type = token[0];
+        if (type === "space" && i === length - 1 && !customProperty) {
+          clean = false;
+        } else if (type === "comment") {
+          prev = tokens[i - 1] ? tokens[i - 1][0] : "empty";
+          next = tokens[i + 1] ? tokens[i + 1][0] : "empty";
+          if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) {
+            if (value.slice(-1) === ",") {
+              clean = false;
+            } else {
+              value += token[1];
+            }
+          } else {
+            clean = false;
+          }
+        } else {
+          value += token[1];
+        }
+      }
+      if (!clean) {
+        let raw = tokens.reduce((all, i) => all + i[1], "");
+        node2.raws[prop] = { raw, value };
+      }
+      node2[prop] = value;
+    }
+    rule(tokens) {
+      tokens.pop();
+      let node2 = new Rule();
+      this.init(node2, tokens[0][2]);
+      node2.raws.between = this.spacesAndCommentsFromEnd(tokens);
+      this.raw(node2, "selector", tokens);
+      this.current = node2;
+    }
+    spacesAndCommentsFromEnd(tokens) {
+      let lastTokenType;
+      let spaces = "";
+      while (tokens.length) {
+        lastTokenType = tokens[tokens.length - 1][0];
+        if (lastTokenType !== "space" && lastTokenType !== "comment") break;
+        spaces = tokens.pop()[1] + spaces;
+      }
+      return spaces;
+    }
+    // Errors
+    spacesAndCommentsFromStart(tokens) {
+      let next;
+      let spaces = "";
+      while (tokens.length) {
+        next = tokens[0][0];
+        if (next !== "space" && next !== "comment") break;
+        spaces += tokens.shift()[1];
+      }
+      return spaces;
+    }
+    spacesFromEnd(tokens) {
+      let lastTokenType;
+      let spaces = "";
+      while (tokens.length) {
+        lastTokenType = tokens[tokens.length - 1][0];
+        if (lastTokenType !== "space") break;
+        spaces = tokens.pop()[1] + spaces;
+      }
+      return spaces;
+    }
+    stringFrom(tokens, from) {
+      let result2 = "";
+      for (let i = from; i < tokens.length; i++) {
+        result2 += tokens[i][1];
+      }
+      tokens.splice(from, tokens.length - from);
+      return result2;
+    }
+    unclosedBlock() {
+      let pos = this.current.source.start;
+      throw this.input.error("Unclosed block", pos.line, pos.column);
+    }
+    unclosedBracket(bracket) {
+      throw this.input.error(
+        "Unclosed bracket",
+        { offset: bracket[2] },
+        { offset: bracket[2] + 1 }
+      );
+    }
+    unexpectedClose(token) {
+      throw this.input.error(
+        "Unexpected }",
+        { offset: token[2] },
+        { offset: token[2] + 1 }
+      );
+    }
+    unknownWord(tokens) {
+      throw this.input.error(
+        "Unknown word",
+        { offset: tokens[0][2] },
+        { offset: tokens[0][2] + tokens[0][1].length }
+      );
+    }
+    unnamedAtrule(node2, token) {
+      throw this.input.error(
+        "At-rule without name",
+        { offset: token[2] },
+        { offset: token[2] + token[1].length }
+      );
+    }
+  }
+  parser = Parser;
+  return parser;
+}
+var parse_1;
+var hasRequiredParse;
+function requireParse() {
+  if (hasRequiredParse) return parse_1;
+  hasRequiredParse = 1;
+  let Container = requireContainer();
+  let Input = requireInput();
+  let Parser = requireParser();
+  function parse(css, opts) {
+    let input2 = new Input(css, opts);
+    let parser2 = new Parser(input2);
+    try {
+      parser2.parse();
+    } catch (e) {
+      if (true) {
+        if (e.name === "CssSyntaxError" && opts && opts.from) {
+          if (/\.scss$/i.test(opts.from)) {
+            e.message += "\nYou tried to parse SCSS with the standard CSS parser; try again with the postcss-scss parser";
+          } else if (/\.sass/i.test(opts.from)) {
+            e.message += "\nYou tried to parse Sass with the standard CSS parser; try again with the postcss-sass parser";
+          } else if (/\.less$/i.test(opts.from)) {
+            e.message += "\nYou tried to parse Less with the standard CSS parser; try again with the postcss-less parser";
+          }
+        }
+      }
+      throw e;
+    }
+    return parser2.root;
+  }
+  parse_1 = parse;
+  parse.default = parse;
+  Container.registerParse(parse);
+  return parse_1;
+}
+var warning;
+var hasRequiredWarning;
+function requireWarning() {
+  if (hasRequiredWarning) return warning;
+  hasRequiredWarning = 1;
+  class Warning {
+    constructor(text, opts = {}) {
+      this.type = "warning";
+      this.text = text;
+      if (opts.node && opts.node.source) {
+        let range = opts.node.rangeBy(opts);
+        this.line = range.start.line;
+        this.column = range.start.column;
+        this.endLine = range.end.line;
+        this.endColumn = range.end.column;
+      }
+      for (let opt in opts) this[opt] = opts[opt];
+    }
+    toString() {
+      if (this.node) {
+        return this.node.error(this.text, {
+          index: this.index,
+          plugin: this.plugin,
+          word: this.word
+        }).message;
+      }
+      if (this.plugin) {
+        return this.plugin + ": " + this.text;
+      }
+      return this.text;
+    }
+  }
+  warning = Warning;
+  Warning.default = Warning;
+  return warning;
+}
+var result;
+var hasRequiredResult;
+function requireResult() {
+  if (hasRequiredResult) return result;
+  hasRequiredResult = 1;
+  let Warning = requireWarning();
+  class Result {
+    constructor(processor2, root2, opts) {
+      this.processor = processor2;
+      this.messages = [];
+      this.root = root2;
+      this.opts = opts;
+      this.css = void 0;
+      this.map = void 0;
+    }
+    toString() {
+      return this.css;
+    }
+    warn(text, opts = {}) {
+      if (!opts.plugin) {
+        if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
+          opts.plugin = this.lastPlugin.postcssPlugin;
+        }
+      }
+      let warning2 = new Warning(text, opts);
+      this.messages.push(warning2);
+      return warning2;
+    }
+    warnings() {
+      return this.messages.filter((i) => i.type === "warning");
+    }
+    get content() {
+      return this.css;
+    }
+  }
+  result = Result;
+  Result.default = Result;
+  return result;
+}
+var warnOnce;
+var hasRequiredWarnOnce;
+function requireWarnOnce() {
+  if (hasRequiredWarnOnce) return warnOnce;
+  hasRequiredWarnOnce = 1;
+  let printed = {};
+  warnOnce = function warnOnce2(message) {
+    if (printed[message]) return;
+    printed[message] = true;
+    if (typeof console !== "undefined" && console.warn) {
+      console.warn(message);
+    }
+  };
+  return warnOnce;
+}
+var lazyResult;
+var hasRequiredLazyResult;
+function requireLazyResult() {
+  if (hasRequiredLazyResult) return lazyResult;
+  hasRequiredLazyResult = 1;
+  let Container = requireContainer();
+  let Document = requireDocument();
+  let MapGenerator = requireMapGenerator();
+  let parse = requireParse();
+  let Result = requireResult();
+  let Root = requireRoot();
+  let stringify = requireStringify();
+  let { isClean, my } = requireSymbols();
+  let warnOnce2 = requireWarnOnce();
+  const TYPE_TO_CLASS_NAME = {
+    atrule: "AtRule",
+    comment: "Comment",
+    decl: "Declaration",
+    document: "Document",
+    root: "Root",
+    rule: "Rule"
+  };
+  const PLUGIN_PROPS = {
+    AtRule: true,
+    AtRuleExit: true,
+    Comment: true,
+    CommentExit: true,
+    Declaration: true,
+    DeclarationExit: true,
+    Document: true,
+    DocumentExit: true,
+    Once: true,
+    OnceExit: true,
+    postcssPlugin: true,
+    prepare: true,
+    Root: true,
+    RootExit: true,
+    Rule: true,
+    RuleExit: true
+  };
+  const NOT_VISITORS = {
+    Once: true,
+    postcssPlugin: true,
+    prepare: true
+  };
+  const CHILDREN = 0;
+  function isPromise(obj) {
+    return typeof obj === "object" && typeof obj.then === "function";
+  }
+  function getEvents(node2) {
+    let key = false;
+    let type = TYPE_TO_CLASS_NAME[node2.type];
+    if (node2.type === "decl") {
+      key = node2.prop.toLowerCase();
+    } else if (node2.type === "atrule") {
+      key = node2.name.toLowerCase();
+    }
+    if (key && node2.append) {
+      return [
+        type,
+        type + "-" + key,
+        CHILDREN,
+        type + "Exit",
+        type + "Exit-" + key
+      ];
+    } else if (key) {
+      return [type, type + "-" + key, type + "Exit", type + "Exit-" + key];
+    } else if (node2.append) {
+      return [type, CHILDREN, type + "Exit"];
+    } else {
+      return [type, type + "Exit"];
+    }
+  }
+  function toStack(node2) {
+    let events;
+    if (node2.type === "document") {
+      events = ["Document", CHILDREN, "DocumentExit"];
+    } else if (node2.type === "root") {
+      events = ["Root", CHILDREN, "RootExit"];
+    } else {
+      events = getEvents(node2);
+    }
+    return {
+      eventIndex: 0,
+      events,
+      iterator: 0,
+      node: node2,
+      visitorIndex: 0,
+      visitors: []
+    };
+  }
+  function cleanMarks(node2) {
+    node2[isClean] = false;
+    if (node2.nodes) node2.nodes.forEach((i) => cleanMarks(i));
+    return node2;
+  }
+  let postcss2 = {};
+  class LazyResult {
+    constructor(processor2, css, opts) {
+      this.stringified = false;
+      this.processed = false;
+      let root2;
+      if (typeof css === "object" && css !== null && (css.type === "root" || css.type === "document")) {
+        root2 = cleanMarks(css);
+      } else if (css instanceof LazyResult || css instanceof Result) {
+        root2 = cleanMarks(css.root);
+        if (css.map) {
+          if (typeof opts.map === "undefined") opts.map = {};
+          if (!opts.map.inline) opts.map.inline = false;
+          opts.map.prev = css.map;
+        }
+      } else {
+        let parser2 = parse;
+        if (opts.syntax) parser2 = opts.syntax.parse;
+        if (opts.parser) parser2 = opts.parser;
+        if (parser2.parse) parser2 = parser2.parse;
+        try {
+          root2 = parser2(css, opts);
+        } catch (error) {
+          this.processed = true;
+          this.error = error;
+        }
+        if (root2 && !root2[my]) {
+          Container.rebuild(root2);
+        }
+      }
+      this.result = new Result(processor2, root2, opts);
+      this.helpers = __spreadProps(__spreadValues({}, postcss2), { postcss: postcss2, result: this.result });
+      this.plugins = this.processor.plugins.map((plugin) => {
+        if (typeof plugin === "object" && plugin.prepare) {
+          return __spreadValues(__spreadValues({}, plugin), plugin.prepare(this.result));
+        } else {
+          return plugin;
+        }
+      });
+    }
+    async() {
+      if (this.error) return Promise.reject(this.error);
+      if (this.processed) return Promise.resolve(this.result);
+      if (!this.processing) {
+        this.processing = this.runAsync();
+      }
+      return this.processing;
+    }
+    catch(onRejected) {
+      return this.async().catch(onRejected);
+    }
+    finally(onFinally) {
+      return this.async().then(onFinally, onFinally);
+    }
+    getAsyncError() {
+      throw new Error("Use process(css).then(cb) to work with async plugins");
+    }
+    handleError(error, node2) {
+      let plugin = this.result.lastPlugin;
+      try {
+        if (node2) node2.addToError(error);
+        this.error = error;
+        if (error.name === "CssSyntaxError" && !error.plugin) {
+          error.plugin = plugin.postcssPlugin;
+          error.setMessage();
+        } else if (plugin.postcssVersion) {
+          if (true) {
+            let pluginName = plugin.postcssPlugin;
+            let pluginVer = plugin.postcssVersion;
+            let runtimeVer = this.result.processor.version;
+            let a = pluginVer.split(".");
+            let b = runtimeVer.split(".");
+            if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {
+              console.error(
+                "Unknown error from PostCSS plugin. Your current PostCSS version is " + runtimeVer + ", but " + pluginName + " uses " + pluginVer + ". Perhaps this is the source of the error below."
+              );
+            }
+          }
+        }
+      } catch (err) {
+        if (console && console.error) console.error(err);
+      }
+      return error;
+    }
+    prepareVisitors() {
+      this.listeners = {};
+      let add = (plugin, type, cb) => {
+        if (!this.listeners[type]) this.listeners[type] = [];
+        this.listeners[type].push([plugin, cb]);
+      };
+      for (let plugin of this.plugins) {
+        if (typeof plugin === "object") {
+          for (let event in plugin) {
+            if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) {
+              throw new Error(
+                `Unknown event ${event} in ${plugin.postcssPlugin}. Try to update PostCSS (${this.processor.version} now).`
+              );
+            }
+            if (!NOT_VISITORS[event]) {
+              if (typeof plugin[event] === "object") {
+                for (let filter in plugin[event]) {
+                  if (filter === "*") {
+                    add(plugin, event, plugin[event][filter]);
+                  } else {
+                    add(
+                      plugin,
+                      event + "-" + filter.toLowerCase(),
+                      plugin[event][filter]
+                    );
+                  }
+                }
+              } else if (typeof plugin[event] === "function") {
+                add(plugin, event, plugin[event]);
+              }
+            }
+          }
+        }
+      }
+      this.hasListener = Object.keys(this.listeners).length > 0;
+    }
+    async runAsync() {
+      this.plugin = 0;
+      for (let i = 0; i < this.plugins.length; i++) {
+        let plugin = this.plugins[i];
+        let promise = this.runOnRoot(plugin);
+        if (isPromise(promise)) {
+          try {
+            await promise;
+          } catch (error) {
+            throw this.handleError(error);
+          }
+        }
+      }
+      this.prepareVisitors();
+      if (this.hasListener) {
+        let root2 = this.result.root;
+        while (!root2[isClean]) {
+          root2[isClean] = true;
+          let stack = [toStack(root2)];
+          while (stack.length > 0) {
+            let promise = this.visitTick(stack);
+            if (isPromise(promise)) {
+              try {
+                await promise;
+              } catch (e) {
+                let node2 = stack[stack.length - 1].node;
+                throw this.handleError(e, node2);
+              }
+            }
+          }
+        }
+        if (this.listeners.OnceExit) {
+          for (let [plugin, visitor] of this.listeners.OnceExit) {
+            this.result.lastPlugin = plugin;
+            try {
+              if (root2.type === "document") {
+                let roots = root2.nodes.map(
+                  (subRoot) => visitor(subRoot, this.helpers)
+                );
+                await Promise.all(roots);
+              } else {
+                await visitor(root2, this.helpers);
+              }
+            } catch (e) {
+              throw this.handleError(e);
+            }
+          }
+        }
+      }
+      this.processed = true;
+      return this.stringify();
+    }
+    runOnRoot(plugin) {
+      this.result.lastPlugin = plugin;
+      try {
+        if (typeof plugin === "object" && plugin.Once) {
+          if (this.result.root.type === "document") {
+            let roots = this.result.root.nodes.map(
+              (root2) => plugin.Once(root2, this.helpers)
+            );
+            if (isPromise(roots[0])) {
+              return Promise.all(roots);
+            }
+            return roots;
+          }
+          return plugin.Once(this.result.root, this.helpers);
+        } else if (typeof plugin === "function") {
+          return plugin(this.result.root, this.result);
+        }
+      } catch (error) {
+        throw this.handleError(error);
+      }
+    }
+    stringify() {
+      if (this.error) throw this.error;
+      if (this.stringified) return this.result;
+      this.stringified = true;
+      this.sync();
+      let opts = this.result.opts;
+      let str = stringify;
+      if (opts.syntax) str = opts.syntax.stringify;
+      if (opts.stringifier) str = opts.stringifier;
+      if (str.stringify) str = str.stringify;
+      let map = new MapGenerator(str, this.result.root, this.result.opts);
+      let data = map.generate();
+      this.result.css = data[0];
+      this.result.map = data[1];
+      return this.result;
+    }
+    sync() {
+      if (this.error) throw this.error;
+      if (this.processed) return this.result;
+      this.processed = true;
+      if (this.processing) {
+        throw this.getAsyncError();
+      }
+      for (let plugin of this.plugins) {
+        let promise = this.runOnRoot(plugin);
+        if (isPromise(promise)) {
+          throw this.getAsyncError();
+        }
+      }
+      this.prepareVisitors();
+      if (this.hasListener) {
+        let root2 = this.result.root;
+        while (!root2[isClean]) {
+          root2[isClean] = true;
+          this.walkSync(root2);
+        }
+        if (this.listeners.OnceExit) {
+          if (root2.type === "document") {
+            for (let subRoot of root2.nodes) {
+              this.visitSync(this.listeners.OnceExit, subRoot);
+            }
+          } else {
+            this.visitSync(this.listeners.OnceExit, root2);
+          }
+        }
+      }
+      return this.result;
+    }
+    then(onFulfilled, onRejected) {
+      if (true) {
+        if (!("from" in this.opts)) {
+          warnOnce2(
+            "Without `from` option PostCSS could generate wrong source map and will not find Browserslist config. Set it to CSS file path or to `undefined` to prevent this warning."
+          );
+        }
+      }
+      return this.async().then(onFulfilled, onRejected);
+    }
+    toString() {
+      return this.css;
+    }
+    visitSync(visitors, node2) {
+      for (let [plugin, visitor] of visitors) {
+        this.result.lastPlugin = plugin;
+        let promise;
+        try {
+          promise = visitor(node2, this.helpers);
+        } catch (e) {
+          throw this.handleError(e, node2.proxyOf);
+        }
+        if (node2.type !== "root" && node2.type !== "document" && !node2.parent) {
+          return true;
+        }
+        if (isPromise(promise)) {
+          throw this.getAsyncError();
+        }
+      }
+    }
+    visitTick(stack) {
+      let visit2 = stack[stack.length - 1];
+      let { node: node2, visitors } = visit2;
+      if (node2.type !== "root" && node2.type !== "document" && !node2.parent) {
+        stack.pop();
+        return;
+      }
+      if (visitors.length > 0 && visit2.visitorIndex < visitors.length) {
+        let [plugin, visitor] = visitors[visit2.visitorIndex];
+        visit2.visitorIndex += 1;
+        if (visit2.visitorIndex === visitors.length) {
+          visit2.visitors = [];
+          visit2.visitorIndex = 0;
+        }
+        this.result.lastPlugin = plugin;
+        try {
+          return visitor(node2.toProxy(), this.helpers);
+        } catch (e) {
+          throw this.handleError(e, node2);
+        }
+      }
+      if (visit2.iterator !== 0) {
+        let iterator = visit2.iterator;
+        let child;
+        while (child = node2.nodes[node2.indexes[iterator]]) {
+          node2.indexes[iterator] += 1;
+          if (!child[isClean]) {
+            child[isClean] = true;
+            stack.push(toStack(child));
+            return;
+          }
+        }
+        visit2.iterator = 0;
+        delete node2.indexes[iterator];
+      }
+      let events = visit2.events;
+      while (visit2.eventIndex < events.length) {
+        let event = events[visit2.eventIndex];
+        visit2.eventIndex += 1;
+        if (event === CHILDREN) {
+          if (node2.nodes && node2.nodes.length) {
+            node2[isClean] = true;
+            visit2.iterator = node2.getIterator();
+          }
+          return;
+        } else if (this.listeners[event]) {
+          visit2.visitors = this.listeners[event];
+          return;
+        }
+      }
+      stack.pop();
+    }
+    walkSync(node2) {
+      node2[isClean] = true;
+      let events = getEvents(node2);
+      for (let event of events) {
+        if (event === CHILDREN) {
+          if (node2.nodes) {
+            node2.each((child) => {
+              if (!child[isClean]) this.walkSync(child);
+            });
+          }
+        } else {
+          let visitors = this.listeners[event];
+          if (visitors) {
+            if (this.visitSync(visitors, node2.toProxy())) return;
+          }
+        }
+      }
+    }
+    warnings() {
+      return this.sync().warnings();
+    }
+    get content() {
+      return this.stringify().content;
+    }
+    get css() {
+      return this.stringify().css;
+    }
+    get map() {
+      return this.stringify().map;
+    }
+    get messages() {
+      return this.sync().messages;
+    }
+    get opts() {
+      return this.result.opts;
+    }
+    get processor() {
+      return this.result.processor;
+    }
+    get root() {
+      return this.sync().root;
+    }
+    get [Symbol.toStringTag]() {
+      return "LazyResult";
+    }
+  }
+  LazyResult.registerPostcss = (dependant) => {
+    postcss2 = dependant;
+  };
+  lazyResult = LazyResult;
+  LazyResult.default = LazyResult;
+  Root.registerLazyResult(LazyResult);
+  Document.registerLazyResult(LazyResult);
+  return lazyResult;
+}
+var noWorkResult;
+var hasRequiredNoWorkResult;
+function requireNoWorkResult() {
+  if (hasRequiredNoWorkResult) return noWorkResult;
+  hasRequiredNoWorkResult = 1;
+  let MapGenerator = requireMapGenerator();
+  let parse = requireParse();
+  const Result = requireResult();
+  let stringify = requireStringify();
+  let warnOnce2 = requireWarnOnce();
+  class NoWorkResult {
+    constructor(processor2, css, opts) {
+      css = css.toString();
+      this.stringified = false;
+      this._processor = processor2;
+      this._css = css;
+      this._opts = opts;
+      this._map = void 0;
+      let root2;
+      let str = stringify;
+      this.result = new Result(this._processor, root2, this._opts);
+      this.result.css = css;
+      let self = this;
+      Object.defineProperty(this.result, "root", {
+        get() {
+          return self.root;
+        }
+      });
+      let map = new MapGenerator(str, root2, this._opts, css);
+      if (map.isMap()) {
+        let [generatedCSS, generatedMap] = map.generate();
+        if (generatedCSS) {
+          this.result.css = generatedCSS;
+        }
+        if (generatedMap) {
+          this.result.map = generatedMap;
+        }
+      } else {
+        map.clearAnnotation();
+        this.result.css = map.css;
+      }
+    }
+    async() {
+      if (this.error) return Promise.reject(this.error);
+      return Promise.resolve(this.result);
+    }
+    catch(onRejected) {
+      return this.async().catch(onRejected);
+    }
+    finally(onFinally) {
+      return this.async().then(onFinally, onFinally);
+    }
+    sync() {
+      if (this.error) throw this.error;
+      return this.result;
+    }
+    then(onFulfilled, onRejected) {
+      if (true) {
+        if (!("from" in this._opts)) {
+          warnOnce2(
+            "Without `from` option PostCSS could generate wrong source map and will not find Browserslist config. Set it to CSS file path or to `undefined` to prevent this warning."
+          );
+        }
+      }
+      return this.async().then(onFulfilled, onRejected);
+    }
+    toString() {
+      return this._css;
+    }
+    warnings() {
+      return [];
+    }
+    get content() {
+      return this.result.css;
+    }
+    get css() {
+      return this.result.css;
+    }
+    get map() {
+      return this.result.map;
+    }
+    get messages() {
+      return [];
+    }
+    get opts() {
+      return this.result.opts;
+    }
+    get processor() {
+      return this.result.processor;
+    }
+    get root() {
+      if (this._root) {
+        return this._root;
+      }
+      let root2;
+      let parser2 = parse;
+      try {
+        root2 = parser2(this._css, this._opts);
+      } catch (error) {
+        this.error = error;
+      }
+      if (this.error) {
+        throw this.error;
+      } else {
+        this._root = root2;
+        return root2;
+      }
+    }
+    get [Symbol.toStringTag]() {
+      return "NoWorkResult";
+    }
+  }
+  noWorkResult = NoWorkResult;
+  NoWorkResult.default = NoWorkResult;
+  return noWorkResult;
+}
+var processor;
+var hasRequiredProcessor;
+function requireProcessor() {
+  if (hasRequiredProcessor) return processor;
+  hasRequiredProcessor = 1;
+  let Document = requireDocument();
+  let LazyResult = requireLazyResult();
+  let NoWorkResult = requireNoWorkResult();
+  let Root = requireRoot();
+  class Processor {
+    constructor(plugins = []) {
+      this.version = "8.5.1";
+      this.plugins = this.normalize(plugins);
+    }
+    normalize(plugins) {
+      let normalized = [];
+      for (let i of plugins) {
+        if (i.postcss === true) {
+          i = i();
+        } else if (i.postcss) {
+          i = i.postcss;
+        }
+        if (typeof i === "object" && Array.isArray(i.plugins)) {
+          normalized = normalized.concat(i.plugins);
+        } else if (typeof i === "object" && i.postcssPlugin) {
+          normalized.push(i);
+        } else if (typeof i === "function") {
+          normalized.push(i);
+        } else if (typeof i === "object" && (i.parse || i.stringify)) {
+          if (true) {
+            throw new Error(
+              "PostCSS syntaxes cannot be used as plugins. Instead, please use one of the syntax/parser/stringifier options as outlined in your PostCSS runner documentation."
+            );
+          }
+        } else {
+          throw new Error(i + " is not a PostCSS plugin");
+        }
+      }
+      return normalized;
+    }
+    process(css, opts = {}) {
+      if (!this.plugins.length && !opts.parser && !opts.stringifier && !opts.syntax) {
+        return new NoWorkResult(this, css, opts);
+      } else {
+        return new LazyResult(this, css, opts);
+      }
+    }
+    use(plugin) {
+      this.plugins = this.plugins.concat(this.normalize([plugin]));
+      return this;
+    }
+  }
+  processor = Processor;
+  Processor.default = Processor;
+  Root.registerProcessor(Processor);
+  Document.registerProcessor(Processor);
+  return processor;
+}
+var postcss_1;
+var hasRequiredPostcss;
+function requirePostcss() {
+  if (hasRequiredPostcss) return postcss_1;
+  hasRequiredPostcss = 1;
+  let AtRule = requireAtRule();
+  let Comment = requireComment();
+  let Container = requireContainer();
+  let CssSyntaxError = requireCssSyntaxError();
+  let Declaration = requireDeclaration();
+  let Document = requireDocument();
+  let fromJSON = requireFromJSON();
+  let Input = requireInput();
+  let LazyResult = requireLazyResult();
+  let list = requireList();
+  let Node = requireNode();
+  let parse = requireParse();
+  let Processor = requireProcessor();
+  let Result = requireResult();
+  let Root = requireRoot();
+  let Rule = requireRule();
+  let stringify = requireStringify();
+  let Warning = requireWarning();
+  function postcss2(...plugins) {
+    if (plugins.length === 1 && Array.isArray(plugins[0])) {
+      plugins = plugins[0];
+    }
+    return new Processor(plugins);
+  }
+  postcss2.plugin = function plugin(name, initializer) {
+    let warningPrinted = false;
+    function creator(...args) {
+      if (console && console.warn && !warningPrinted) {
+        warningPrinted = true;
+        console.warn(
+          name + ": postcss.plugin was deprecated. Migration guide:\nhttps://evilmartians.com/chronicles/postcss-8-plugin-migration"
+        );
+        if (process.env.LANG && process.env.LANG.startsWith("cn")) {
+          console.warn(
+            name + ": \u91CC\u9762 postcss.plugin \u88AB\u5F03\u7528. \u8FC1\u79FB\u6307\u5357:\nhttps://www.w3ctech.com/topic/2226"
+          );
+        }
+      }
+      let transformer = initializer(...args);
+      transformer.postcssPlugin = name;
+      transformer.postcssVersion = new Processor().version;
+      return transformer;
+    }
+    let cache;
+    Object.defineProperty(creator, "postcss", {
+      get() {
+        if (!cache) cache = creator();
+        return cache;
+      }
+    });
+    creator.process = function(css, processOpts, pluginOpts) {
+      return postcss2([creator(pluginOpts)]).process(css, processOpts);
+    };
+    return creator;
+  };
+  postcss2.stringify = stringify;
+  postcss2.parse = parse;
+  postcss2.fromJSON = fromJSON;
+  postcss2.list = list;
+  postcss2.comment = (defaults) => new Comment(defaults);
+  postcss2.atRule = (defaults) => new AtRule(defaults);
+  postcss2.decl = (defaults) => new Declaration(defaults);
+  postcss2.rule = (defaults) => new Rule(defaults);
+  postcss2.root = (defaults) => new Root(defaults);
+  postcss2.document = (defaults) => new Document(defaults);
+  postcss2.CssSyntaxError = CssSyntaxError;
+  postcss2.Declaration = Declaration;
+  postcss2.Container = Container;
+  postcss2.Processor = Processor;
+  postcss2.Document = Document;
+  postcss2.Comment = Comment;
+  postcss2.Warning = Warning;
+  postcss2.AtRule = AtRule;
+  postcss2.Result = Result;
+  postcss2.Input = Input;
+  postcss2.Rule = Rule;
+  postcss2.Root = Root;
+  postcss2.Node = Node;
+  LazyResult.registerPostcss(postcss2);
+  postcss_1 = postcss2;
+  postcss2.default = postcss2;
+  return postcss_1;
+}
+var safeParser$1;
+var hasRequiredSafeParser;
+function requireSafeParser() {
+  if (hasRequiredSafeParser) return safeParser$1;
+  hasRequiredSafeParser = 1;
+  let Comment = requireComment();
+  let Parser = requireParser();
+  let tokenizer = requireTokenize();
+  class SafeParser extends Parser {
+    checkMissedSemicolon() {
+    }
+    comment(token) {
+      let node2 = new Comment();
+      this.init(node2, token[2]);
+      let pos = this.input.fromOffset(token[3]) || this.input.fromOffset(this.input.css.length - 1);
+      node2.source.end = {
+        column: pos.col,
+        line: pos.line,
+        offset: token[3] + 1
+      };
+      let text = token[1].slice(2);
+      if (text.slice(-2) === "*/") text = text.slice(0, -2);
+      if (/^\s*$/.test(text)) {
+        node2.text = "";
+        node2.raws.left = text;
+        node2.raws.right = "";
+      } else {
+        let match = text.match(/^(\s*)([^]*\S)(\s*)$/);
+        node2.text = match[2];
+        node2.raws.left = match[1];
+        node2.raws.right = match[3];
+      }
+    }
+    createTokenizer() {
+      this.tokenizer = tokenizer(this.input, { ignoreErrors: true });
+    }
+    decl(tokens) {
+      if (tokens.length > 1 && tokens.some((i) => i[0] === "word")) {
+        super.decl(tokens);
+      }
+    }
+    doubleColon() {
+    }
+    endFile() {
+      if (this.current.nodes && this.current.nodes.length) {
+        this.current.raws.semicolon = this.semicolon;
+      }
+      this.current.raws.after = (this.current.raws.after || "") + this.spaces;
+      while (this.current.parent) {
+        this.current = this.current.parent;
+        this.current.raws.after = "";
+      }
+      this.root.source.end = this.getPosition(this.tokenizer.position());
+    }
+    precheckMissedSemicolon(tokens) {
+      let colon = this.colon(tokens);
+      if (colon === false) return;
+      let nextStart, prevEnd;
+      for (nextStart = colon - 1; nextStart >= 0; nextStart--) {
+        if (tokens[nextStart][0] === "word") break;
+      }
+      if (nextStart === 0 || nextStart < 0) return;
+      for (prevEnd = nextStart - 1; prevEnd >= 0; prevEnd--) {
+        if (tokens[prevEnd][0] !== "space") {
+          prevEnd += 1;
+          break;
+        }
+      }
+      let other = tokens.slice(nextStart);
+      let spaces = tokens.slice(prevEnd, nextStart);
+      tokens.splice(prevEnd, tokens.length - prevEnd);
+      this.spaces = spaces.map((i) => i[1]).join("");
+      this.decl(other);
+    }
+    unclosedBracket() {
+    }
+    unexpectedClose() {
+      this.current.raws.after += "}";
+    }
+    unknownWord(tokens) {
+      this.spaces += tokens.map((i) => i[1]).join("");
+    }
+    unnamedAtrule(node2) {
+      node2.name = "";
+    }
+  }
+  safeParser$1 = SafeParser;
+  return safeParser$1;
+}
+var safeParse;
+var hasRequiredSafeParse;
+function requireSafeParse() {
+  if (hasRequiredSafeParse) return safeParse;
+  hasRequiredSafeParse = 1;
+  let { Input } = requirePostcss();
+  let SafeParser = requireSafeParser();
+  safeParse = function safeParse2(css, opts) {
+    let input2 = new Input(css, opts);
+    let parser2 = new SafeParser(input2);
+    parser2.parse();
+    return parser2.root;
+  };
+  return safeParse;
+}
+var safeParseExports = requireSafeParse();
+var safeParser = /* @__PURE__ */ getDefaultExportFromCjs(safeParseExports);
+var postcssExports = requirePostcss();
+var postcss = /* @__PURE__ */ getDefaultExportFromCjs(postcssExports);
+postcss.stringify;
+postcss.fromJSON;
+postcss.plugin;
+postcss.parse;
+postcss.list;
+postcss.document;
+postcss.comment;
+postcss.atRule;
+postcss.rule;
+postcss.decl;
+postcss.root;
+postcss.CssSyntaxError;
+postcss.Declaration;
+postcss.Container;
+postcss.Processor;
+postcss.Document;
+postcss.Comment;
+postcss.Warning;
+postcss.AtRule;
+postcss.Result;
+postcss.Input;
+postcss.Rule;
+postcss.Root;
+postcss.Node;
+var tagMap = {
+  script: "noscript",
+  // camel case svg element tag names
+  altglyph: "altGlyph",
+  altglyphdef: "altGlyphDef",
+  altglyphitem: "altGlyphItem",
+  animatecolor: "animateColor",
+  animatemotion: "animateMotion",
+  animatetransform: "animateTransform",
+  clippath: "clipPath",
+  feblend: "feBlend",
+  fecolormatrix: "feColorMatrix",
+  fecomponenttransfer: "feComponentTransfer",
+  fecomposite: "feComposite",
+  feconvolvematrix: "feConvolveMatrix",
+  fediffuselighting: "feDiffuseLighting",
+  fedisplacementmap: "feDisplacementMap",
+  fedistantlight: "feDistantLight",
+  fedropshadow: "feDropShadow",
+  feflood: "feFlood",
+  fefunca: "feFuncA",
+  fefuncb: "feFuncB",
+  fefuncg: "feFuncG",
+  fefuncr: "feFuncR",
+  fegaussianblur: "feGaussianBlur",
+  feimage: "feImage",
+  femerge: "feMerge",
+  femergenode: "feMergeNode",
+  femorphology: "feMorphology",
+  feoffset: "feOffset",
+  fepointlight: "fePointLight",
+  fespecularlighting: "feSpecularLighting",
+  fespotlight: "feSpotLight",
+  fetile: "feTile",
+  feturbulence: "feTurbulence",
+  foreignobject: "foreignObject",
+  glyphref: "glyphRef",
+  lineargradient: "linearGradient",
+  radialgradient: "radialGradient"
+};
+function getTagName(n) {
+  let tagName = tagMap[n.tagName] ? tagMap[n.tagName] : n.tagName;
+  if (tagName === "link" && n.attributes._cssText) {
+    tagName = "style";
+  }
+  return tagName;
+}
+function adaptCssForReplay(cssText, cache) {
+  const cachedStyle = cache == null ? void 0 : cache.stylesWithHoverClass.get(cssText);
+  if (cachedStyle) return cachedStyle;
+  let result2 = cssText;
+  try {
+    const ast = postcss([
+      mediaSelectorPlugin,
+      pseudoClassPlugin
+    ]).process(cssText, { parser: safeParser });
+    result2 = ast.css;
+  } catch (error) {
+    console.warn("Failed to adapt css for replay", error);
+  }
+  cache == null ? void 0 : cache.stylesWithHoverClass.set(cssText, result2);
+  return result2;
+}
+function createCache() {
+  const stylesWithHoverClass = /* @__PURE__ */ new Map();
+  return {
+    stylesWithHoverClass
+  };
+}
+function safeDocNode(n, options) {
+  let stringContent = n.textContent;
+  if (n.isStyle && options.hackCss) {
+    try {
+      stringContent = adaptCssForReplay(n.textContent, options.cache);
+    } catch (e) {
+    }
+  }
+  return options.doc.createTextNode(stringContent);
+}
+function buildNode(n, options) {
+  var _a;
+  const { doc, hackCss, cache } = options;
+  switch (n.type) {
+    case types.NodeType$1.Document:
+      return doc.implementation.createDocument(null, "", null);
+    case types.NodeType$1.DocumentType:
+      return doc.implementation.createDocumentType(
+        n.name || "html",
+        n.publicId,
+        n.systemId
+      );
+    case types.NodeType$1.Element: {
+      const tagName = getTagName(n);
+      let node2;
+      if (n.isSVG) {
+        node2 = doc.createElementNS("http://www.w3.org/2000/svg", tagName);
+      } else {
+        if (
+          // If the tag name is a custom element name
+          n.isCustom && // If the browser supports custom elements
+          ((_a = doc.defaultView) == null ? void 0 : _a.customElements) && // If the custom element hasn't been defined yet
+          !doc.defaultView.customElements.get(n.tagName)
+        )
+          doc.defaultView.customElements.define(
+            n.tagName,
+            class extends doc.defaultView.HTMLElement {
+            }
+          );
+        node2 = doc.createElement(tagName);
+      }
+      const specialAttributes = {};
+      for (const name in n.attributes) {
+        if (!Object.prototype.hasOwnProperty.call(n.attributes, name)) {
+          continue;
+        }
+        let value = n.attributes[name];
+        if (tagName === "option" && name === "selected" && value === false) {
+          continue;
+        }
+        if (value === null) {
+          continue;
+        }
+        if (value === true) value = "";
+        if (name.startsWith("rr_")) {
+          specialAttributes[name] = value;
+          continue;
+        }
+        const isTextarea = tagName === "textarea" && name === "value";
+        const isRemoteOrDynamicCss = tagName === "style" && name === "_cssText";
+        if (isRemoteOrDynamicCss && hackCss && typeof value === "string") {
+          value = adaptCssForReplay(value, cache);
+        }
+        if ((isTextarea || isRemoteOrDynamicCss) && typeof value === "string") {
+          node2.appendChild(doc.createTextNode(value));
+          n.childNodes = [];
+          continue;
+        }
+        try {
+          if (n.isSVG && name === "xlink:href") {
+            node2.setAttributeNS(
+              "http://www.w3.org/1999/xlink",
+              name,
+              value.toString()
+            );
+          } else if (name === "onload" || name === "onclick" || name.substring(0, 7) === "onmouse") {
+            node2.setAttribute("_" + name, value.toString());
+          } else if (tagName === "meta" && n.attributes["http-equiv"] === "Content-Security-Policy" && name === "content") {
+            node2.setAttribute("csp-content", value.toString());
+            continue;
+          } else if (tagName === "link" && (n.attributes.rel === "preload" && n.attributes.as === "script" || n.attributes.rel === "modulepreload")) {
+          } else if (tagName === "link" && n.attributes.rel === "prefetch" && typeof n.attributes.href === "string" && types.extractFileExtension(n.attributes.href) === "js") {
+          } else if (tagName === "img" && n.attributes.srcset && n.attributes.rr_dataURL) {
+            node2.setAttribute(
+              "rrweb-original-srcset",
+              n.attributes.srcset
+            );
+          } else {
+            node2.setAttribute(name, value.toString());
+          }
+        } catch (error) {
+        }
+      }
+      for (const name in specialAttributes) {
+        const value = specialAttributes[name];
+        if (tagName === "canvas" && name === "rr_dataURL") {
+          const image = doc.createElement("img");
+          image.onload = () => {
+            const ctx = node2.getContext("2d");
+            if (ctx) {
+              ctx.drawImage(image, 0, 0, image.width, image.height);
+            }
+          };
+          image.src = value.toString();
+          if (node2.RRNodeType)
+            node2.rr_dataURL = value.toString();
+        } else if (tagName === "img" && name === "rr_dataURL") {
+          const image = node2;
+          if (!image.currentSrc.startsWith("data:")) {
+            image.setAttribute(
+              "rrweb-original-src",
+              n.attributes.src
+            );
+            image.src = value.toString();
+          }
+        }
+        if (name === "rr_width") {
+          node2.style.setProperty("width", value.toString());
+        } else if (name === "rr_height") {
+          node2.style.setProperty("height", value.toString());
+        } else if (name === "rr_mediaCurrentTime" && typeof value === "number") {
+          node2.currentTime = value;
+        } else if (name === "rr_mediaState") {
+          switch (value) {
+            case "played":
+              node2.play().catch((e) => console.warn("media playback error", e));
+              break;
+            case "paused":
+              node2.pause();
+              break;
+          }
+        } else if (name === "rr_mediaPlaybackRate" && typeof value === "number") {
+          node2.playbackRate = value;
+        } else if (name === "rr_mediaMuted" && typeof value === "boolean") {
+          node2.muted = value;
+        } else if (name === "rr_mediaLoop" && typeof value === "boolean") {
+          node2.loop = value;
+        } else if (name === "rr_mediaVolume" && typeof value === "number") {
+          node2.volume = value;
+        } else if (name === "rr_open_mode") {
+          node2.setAttribute(
+            "rr_open_mode",
+            value
+          );
+        }
+      }
+      if (n.isShadowHost) {
+        if (!node2.shadowRoot) {
+          node2.attachShadow({ mode: "open" });
+        } else {
+          while (node2.shadowRoot.firstChild) {
+            node2.shadowRoot.removeChild(node2.shadowRoot.firstChild);
+          }
+        }
+      }
+      return node2;
+    }
+    case types.NodeType$1.Text:
+      return safeDocNode(n, {
+        cache,
+        doc,
+        hackCss
+      });
+    case types.NodeType$1.CDATA:
+      if (n.textContent.trim() === "") {
+        return null;
+      }
+      return doc.createCDATASection(n.textContent);
+    case types.NodeType$1.Comment:
+      return doc.createComment(n.textContent);
+    default:
+      return null;
+  }
+}
+function buildNodeWithSN(n, options) {
+  const {
+    doc,
+    mirror,
+    skipChild = false,
+    hackCss = true,
+    afterAppend,
+    cache
+  } = options;
+  if (mirror.has(n.id)) {
+    const nodeInMirror = mirror.getNode(n.id);
+    const meta = mirror.getMeta(nodeInMirror);
+    if (types.isNodeMetaEqual(meta, n)) return mirror.getNode(n.id);
+  }
+  let node2 = buildNode(n, { doc, hackCss, cache });
+  if (!node2) {
+    return null;
+  }
+  if (n.rootId && mirror.getNode(n.rootId) !== doc) {
+    mirror.replace(n.rootId, doc);
+  }
+  if (n.type === types.NodeType$1.Document) {
+    doc.close();
+    doc.open();
+    if (n.compatMode === "BackCompat" && n.childNodes && n.childNodes[0].type !== types.NodeType$1.DocumentType) {
+      if (n.childNodes[0].type === types.NodeType$1.Element && "xmlns" in n.childNodes[0].attributes && n.childNodes[0].attributes.xmlns === "http://www.w3.org/1999/xhtml") {
+        doc.write(
+          '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "">'
+        );
+      } else {
+        doc.write(
+          '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "">'
+        );
+      }
+    }
+    node2 = doc;
+  }
+  mirror.add(node2, n);
+  if ((n.type === types.NodeType$1.Document || n.type === types.NodeType$1.Element) && !skipChild) {
+    for (const childN of n.childNodes) {
+      const childNode = buildNodeWithSN(childN, {
+        doc,
+        mirror,
+        skipChild: false,
+        hackCss,
+        afterAppend,
+        cache
+      });
+      if (!childNode) {
+        console.warn("Failed to rebuild", childN);
+        continue;
+      }
+      if (childN.isShadow && types.isElement(node2) && node2.shadowRoot) {
+        node2.shadowRoot.appendChild(childNode);
+      } else if (n.type === types.NodeType$1.Document && childN.type == types.NodeType$1.Element) {
+        const htmlElement = childNode;
+        let body = null;
+        htmlElement.childNodes.forEach((child) => {
+          if (child.nodeName === "BODY") body = child;
+        });
+        if (body) {
+          htmlElement.removeChild(body);
+          node2.appendChild(childNode);
+          htmlElement.appendChild(body);
+        } else {
+          node2.appendChild(childNode);
+        }
+      } else if (n.type === types.NodeType$1.Document && childN.type === types.NodeType$1.DocumentType) {
+        if (node2.firstChild && node2.firstChild.nodeType === 1) {
+          node2.insertBefore(childNode, node2.firstChild);
+        } else {
+          node2.appendChild(childNode);
+        }
+      } else {
+        node2.appendChild(childNode);
+      }
+      if (afterAppend) {
+        afterAppend(childNode, childN.id);
+      }
+    }
+  }
+  return node2;
+}
+function visit(mirror, onVisit) {
+  function walk(node2) {
+    onVisit(node2);
+  }
+  for (const id of mirror.getIds()) {
+    if (mirror.has(id)) {
+      walk(mirror.getNode(id));
+    }
+  }
+}
+function handleScroll(node2, mirror) {
+  const n = mirror.getMeta(node2);
+  if ((n == null ? void 0 : n.type) !== types.NodeType$1.Element) {
+    return;
+  }
+  const el = node2;
+  for (const name in n.attributes) {
+    if (!(Object.prototype.hasOwnProperty.call(n.attributes, name) && name.startsWith("rr_"))) {
+      continue;
+    }
+    const value = n.attributes[name];
+    if (name === "rr_scrollLeft") {
+      el.scrollLeft = value;
+    }
+    if (name === "rr_scrollTop") {
+      el.scrollTop = value;
+    }
+  }
+}
+function rebuild(n, options) {
+  const {
+    doc,
+    onVisit,
+    hackCss = true,
+    afterAppend,
+    cache,
+    mirror = new types.Mirror()
+  } = options;
+  const node2 = buildNodeWithSN(n, {
+    doc,
+    mirror,
+    skipChild: false,
+    hackCss,
+    afterAppend,
+    cache
+  });
+  visit(mirror, (visitedNode) => {
+    if (onVisit) {
+      onVisit(visitedNode);
+    }
+    handleScroll(visitedNode, mirror);
+  });
+  return node2;
+}
+exports.Mirror = types.Mirror;
+exports.NodeType = types.NodeType;
+exports.absolutifyURLs = types.absolutifyURLs;
+exports.checkDataURLSize = types.checkDataURLSize;
+exports.createMirror = types.createMirror;
+exports.escapeImportStatement = types.escapeImportStatement;
+exports.extractFileExtension = types.extractFileExtension;
+exports.fixSafariColons = types.fixSafariColons;
+exports.getInputType = types.getInputType;
+exports.is2DCanvasBlank = types.is2DCanvasBlank;
+exports.isCSSImportRule = types.isCSSImportRule;
+exports.isCSSStyleRule = types.isCSSStyleRule;
+exports.isElement = types.isElement;
+exports.isNativeShadowDom = types.isNativeShadowDom;
+exports.isNodeMetaEqual = types.isNodeMetaEqual;
+exports.isShadowRoot = types.isShadowRoot;
+exports.maskInputValue = types.maskInputValue;
+exports.recompressBase64Image = types.recompressBase64Image;
+exports.stringifyRule = types.stringifyRule;
+exports.stringifyStylesheet = types.stringifyStylesheet;
+exports.toLowerCase = types.toLowerCase;
+exports.adaptCssForReplay = adaptCssForReplay;
+exports.buildNodeWithSN = buildNodeWithSN;
+exports.createCache = createCache;
+exports.rebuild = rebuild;
+if (typeof module.exports == "object" && typeof exports == "object") {
+  var __cp = (to, from, except, desc) => {
+    if ((from && typeof from === "object") || typeof from === "function") {
+      for (let key of Object.getOwnPropertyNames(from)) {
+        if (!Object.prototype.hasOwnProperty.call(to, key) && key !== except)
+        Object.defineProperty(to, key, {
+          get: () => from[key],
+          enumerable: !(desc = Object.getOwnPropertyDescriptor(from, key)) || desc.enumerable,
+        });
+      }
+    }
+    return to;
+  };
+  module.exports = __cp(module.exports, exports);
+}
+return module.exports;
+}))
+//# sourceMappingURL=replay.umd.cjs.map