@posthog/rrweb-snapshot 0.0.6 → 0.0.8

package/dist/rrweb-snapshot.umd.cjs

@@ -1581,7 +1581,7 @@ function getAugmentedNamespace(n) {
 var picocolors_browser = { exports: {} };
 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 };
+  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;
@@ -1594,8 +1594,8 @@ const __viteBrowserExternal$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Ob
 const require$$2 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
 let pico = picocolors_browserExports;
 let terminalHighlight$1 = require$$2;
-let CssSyntaxError$3 = class CssSyntaxError extends Error {
-  constructor(message, line, column, source, file, plugin2) {
+let CssSyntaxError$4 = class CssSyntaxError extends Error {
+  constructor(message, line, column, source, file, plugin3) {
     super(message);
     this.name = "CssSyntaxError";
     this.reason = message;
@@ -1605,8 +1605,8 @@ let CssSyntaxError$3 = class CssSyntaxError extends Error {
     if (source) {
       this.source = source;
     }
-    if (plugin2) {
-      this.plugin = plugin2;
+    if (plugin3) {
+      this.plugin = plugin3;
     }
     if (typeof line !== "undefined" && typeof column !== "undefined") {
       if (typeof line === "number") {
@@ -1636,29 +1636,40 @@ let CssSyntaxError$3 = class CssSyntaxError extends Error {
     if (!this.source) return "";
     let css = this.source;
     if (color == null) color = pico.isColorSupported;
-    if (terminalHighlight$1) {
-      if (color) css = terminalHighlight$1(css);
-    }
-    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;
-    let mark, aside;
+    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);
-    } else {
-      mark = aside = (str) => str;
+      if (terminalHighlight$1) {
+        highlight = (text) => terminalHighlight$1(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, index2) => {
       let number = start + 1 + index2;
       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) + line + "\n " + spacing + mark("^");
+        return mark(">") + aside(gutter) + highlight(line) + "\n " + spacing + mark("^");
       }
-      return " " + aside(gutter) + line;
+      return " " + aside(gutter) + highlight(line);
     }).join("\n");
   }
   toString() {
@@ -1669,11 +1680,8 @@ let CssSyntaxError$3 = class CssSyntaxError extends Error {
     return this.name + ": " + this.message + code;
   }
 };
-var cssSyntaxError = CssSyntaxError$3;
-CssSyntaxError$3.default = CssSyntaxError$3;
-var symbols = {};
-symbols.isClean = Symbol("isClean");
-symbols.my = Symbol("my");
+var cssSyntaxError = CssSyntaxError$4;
+CssSyntaxError$4.default = CssSyntaxError$4;
 const DEFAULT_RAW = {
   after: "\n",
   beforeClose: "\n",
@@ -1972,16 +1980,19 @@ let Stringifier$2 = class Stringifier {
 var stringifier = Stringifier$2;
 Stringifier$2.default = Stringifier$2;
 let Stringifier$1 = stringifier;
-function stringify$4(node2, builder) {
+function stringify$5(node2, builder) {
   let str = new Stringifier$1(builder);
   str.stringify(node2);
 }
-var stringify_1 = stringify$4;
-stringify$4.default = stringify$4;
-let { isClean: isClean$2, my: my$2 } = symbols;
-let CssSyntaxError$2 = cssSyntaxError;
+var stringify_1 = stringify$5;
+stringify$5.default = stringify$5;
+var symbols = {};
+symbols.isClean = Symbol("isClean");
+symbols.my = Symbol("my");
+let CssSyntaxError$3 = cssSyntaxError;
 let Stringifier2 = stringifier;
-let stringify$3 = stringify_1;
+let stringify$4 = stringify_1;
+let { isClean: isClean$2, my: my$2 } = symbols;
 function cloneNode(obj, parent) {
   let cloned = new obj.constructor();
   for (let i in obj) {
@@ -2004,7 +2015,28 @@ function cloneNode(obj, parent) {
   }
   return cloned;
 }
-let Node$4 = class Node {
+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;
+}
+let Node$5 = class Node {
   constructor(defaults = {}) {
     this.raws = {};
     this[isClean$2] = false;
@@ -2081,7 +2113,7 @@ let Node$4 = class Node {
         opts
       );
     }
-    return new CssSyntaxError$2(message);
+    return new CssSyntaxError$3(message);
   }
   getProxyProcessor() {
     return {
@@ -2105,6 +2137,10 @@ let Node$4 = class Node {
       }
     };
   }
+  /* c8 ignore next 3 */
+  markClean() {
+    this[isClean$2] = true;
+  }
   markDirty() {
     if (this[isClean$2]) {
       this[isClean$2] = false;
@@ -2119,23 +2155,29 @@ let Node$4 = class Node {
     let index2 = this.parent.index(this);
     return this.parent.nodes[index2 + 1];
   }
-  positionBy(opts, stringRepresentation) {
+  positionBy(opts) {
     let pos = this.source.start;
     if (opts.index) {
-      pos = this.positionInside(opts.index, stringRepresentation);
+      pos = this.positionInside(opts.index);
     } else if (opts.word) {
-      stringRepresentation = this.toString();
+      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 index2 = stringRepresentation.indexOf(opts.word);
-      if (index2 !== -1) pos = this.positionInside(index2, stringRepresentation);
+      if (index2 !== -1) pos = this.positionInside(index2);
     }
     return pos;
   }
-  positionInside(index2, stringRepresentation) {
-    let string = stringRepresentation || this.toString();
+  positionInside(index2) {
     let column = this.source.start.column;
     let line = this.source.start.line;
-    for (let i = 0; i < index2; i++) {
-      if (string[i] === "\n") {
+    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 + index2;
+    for (let i = offset; i < end; i++) {
+      if (inputString[i] === "\n") {
         column = 1;
         line += 1;
       } else {
@@ -2162,11 +2204,17 @@ let Node$4 = class Node {
       line: start.line
     };
     if (opts.word) {
-      let stringRepresentation = this.toString();
+      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 index2 = stringRepresentation.indexOf(opts.word);
       if (index2 !== -1) {
-        start = this.positionInside(index2, stringRepresentation);
-        end = this.positionInside(index2 + opts.word.length, stringRepresentation);
+        start = this.positionInside(index2);
+        end = this.positionInside(
+          index2 + opts.word.length
+        );
       }
     } else {
       if (opts.start) {
@@ -2279,7 +2327,7 @@ let Node$4 = class Node {
     }
     return this.proxyCache;
   }
-  toString(stringifier2 = stringify$3) {
+  toString(stringifier2 = stringify$4) {
     if (stringifier2.stringify) stringifier2 = stringifier2.stringify;
     let result2 = "";
     stringifier2(this, (i) => {
@@ -2296,10 +2344,19 @@ let Node$4 = class Node {
     return this;
   }
 };
-var node = Node$4;
-Node$4.default = Node$4;
+var node = Node$5;
+Node$5.default = Node$5;
+let Node$4 = node;
+let Comment$6 = class Comment extends Node$4 {
+  constructor(defaults) {
+    super(defaults);
+    this.type = "comment";
+  }
+};
+var comment$1 = Comment$6;
+Comment$6.default = Comment$6;
 let Node$3 = node;
-let Declaration$4 = class Declaration extends Node$3 {
+let Declaration$5 = class Declaration extends Node$3 {
   constructor(defaults) {
     if (defaults && typeof defaults.value !== "undefined" && typeof defaults.value !== "string") {
       defaults = __spreadProps(__spreadValues({}, defaults), { value: String(defaults.value) });
@@ -2311,1124 +2368,1237 @@ let Declaration$4 = class Declaration extends Node$3 {
     return this.prop.startsWith("--") || this.prop[0] === "$";
   }
 };
-var declaration = Declaration$4;
-Declaration$4.default = Declaration$4;
-let urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-let customAlphabet = (alphabet, defaultSize = 21) => {
-  return (size = defaultSize) => {
-    let id = "";
-    let i = size;
-    while (i--) {
-      id += alphabet[Math.random() * alphabet.length | 0];
+var declaration = Declaration$5;
+Declaration$5.default = Declaration$5;
+let Comment$5 = comment$1;
+let Declaration$4 = declaration;
+let Node$2 = node;
+let { isClean: isClean$1, my: my$1 } = symbols;
+let AtRule$5;
+let parse$5;
+let Root$7;
+let Rule$5;
+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$1] = false;
+  if (node2.proxyOf.nodes) {
+    for (let i of node2.proxyOf.nodes) {
+      markTreeDirty(i);
     }
-    return id;
-  };
-};
-let nanoid$1 = (size = 21) => {
-  let id = "";
-  let i = size;
-  while (i--) {
-    id += urlAlphabet[Math.random() * 64 | 0];
-  }
-  return id;
-};
-var nonSecure = { nanoid: nanoid$1, customAlphabet };
-let { SourceMapConsumer: SourceMapConsumer$2, SourceMapGenerator: SourceMapGenerator$2 } = require$$2;
-let { existsSync, readFileSync } = require$$2;
-let { dirname: dirname$1, join } = require$$2;
-function fromBase64(str) {
-  if (Buffer) {
-    return Buffer.from(str, "base64").toString();
-  } else {
-    return window.atob(str);
   }
 }
-let PreviousMap$2 = 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;
+let Container$8 = class Container extends Node$2 {
+  append(...children) {
+    for (let child of children) {
+      let nodes = this.normalize(child, this.last);
+      for (let node2 of nodes) this.proxyOf.nodes.push(node2);
     }
-    if (this.mapFile) this.root = dirname$1(this.mapFile);
-    if (text) this.text = text;
+    this.markDirty();
+    return this;
   }
-  consumer() {
-    if (!this.consumerCache) {
-      this.consumerCache = new SourceMapConsumer$2(this.text);
+  cleanRaws(keepBetween) {
+    super.cleanRaws(keepBetween);
+    if (this.nodes) {
+      for (let node2 of this.nodes) node2.cleanRaws(keepBetween);
     }
-    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,/;
-    if (charsetUri.test(text) || uri.test(text)) {
-      return decodeURIComponent(text.substr(RegExp.lastMatch.length));
-    }
-    if (baseCharsetUri.test(text) || baseUri.test(text)) {
-      return fromBase64(text.substr(RegExp.lastMatch.length));
+  each(callback) {
+    if (!this.proxyOf.nodes) return void 0;
+    let iterator = this.getIterator();
+    let index2, result2;
+    while (this.indexes[iterator] < this.proxyOf.nodes.length) {
+      index2 = this.indexes[iterator];
+      result2 = callback(this.proxyOf.nodes[index2], index2);
+      if (result2 === false) break;
+      this.indexes[iterator] += 1;
     }
-    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);
+    delete this.indexes[iterator];
+    return result2;
   }
-  loadAnnotation(css) {
-    let comments = css.match(/\/\*\s*# sourceMappingURL=/gm);
-    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));
-    }
+  every(condition) {
+    return this.nodes.every(condition);
   }
-  loadFile(path) {
-    this.root = dirname$1(path);
-    if (existsSync(path)) {
-      this.mapFile = path;
-      return readFileSync(path, "utf-8").toString().trim();
-    }
+  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;
   }
-  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()
+  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, index2) => i(child.toProxy(), index2);
+                } else {
+                  return i;
+                }
+              })
             );
-          }
-          return map;
+          };
+        } 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];
         }
-      } else if (prev instanceof SourceMapConsumer$2) {
-        return SourceMapGenerator$2.fromSourceMap(prev).toString();
-      } else if (prev instanceof SourceMapGenerator$2) {
-        return prev.toString();
-      } else if (this.isMap(prev)) {
-        return JSON.stringify(prev);
-      } else {
-        throw new Error(
-          "Unsupported previous source map format: " + prev.toString()
-        );
+      },
+      set(node2, prop, value) {
+        if (node2[prop] === value) return true;
+        node2[prop] = value;
+        if (prop === "name" || prop === "params" || prop === "selector") {
+          node2.markDirty();
+        }
+        return true;
       }
-    } else if (this.inline) {
-      return this.decodeInline(this.annotation);
-    } else if (this.annotation) {
-      let map = this.annotation;
-      if (file) map = join(dirname$1(file), map);
-      return this.loadFile(map);
-    }
+    };
   }
-  startWith(string, start) {
-    if (!string) return false;
-    return string.substr(0, start.length) === start;
+  index(child) {
+    if (typeof child === "number") return child;
+    if (child.proxyOf) child = child.proxyOf;
+    return this.proxyOf.nodes.indexOf(child);
   }
-  withContent() {
-    return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
+  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 index2;
+    for (let id in this.indexes) {
+      index2 = this.indexes[id];
+      if (existIndex < index2) {
+        this.indexes[id] = index2 + nodes.length;
+      }
+    }
+    this.markDirty();
+    return this;
   }
-};
-var previousMap = PreviousMap$2;
-PreviousMap$2.default = PreviousMap$2;
-let { SourceMapConsumer: SourceMapConsumer$1, SourceMapGenerator: SourceMapGenerator$1 } = require$$2;
-let { fileURLToPath, pathToFileURL: pathToFileURL$1 } = require$$2;
-let { isAbsolute, resolve: resolve$1 } = require$$2;
-let { nanoid } = nonSecure;
-let terminalHighlight = require$$2;
-let CssSyntaxError$1 = cssSyntaxError;
-let PreviousMap$1 = previousMap;
-let fromOffsetCache = Symbol("fromOffsetCache");
-let sourceMapAvailable$1 = Boolean(SourceMapConsumer$1 && SourceMapGenerator$1);
-let pathAvailable$1 = Boolean(resolve$1 && isAbsolute);
-let Input$4 = 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`);
+  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 index2;
+    for (let id in this.indexes) {
+      index2 = this.indexes[id];
+      if (existIndex <= index2) {
+        this.indexes[id] = index2 + nodes.length;
+      }
     }
-    this.css = css.toString();
-    if (this.css[0] === "\uFEFF" || this.css[0] === "\uFFFE") {
-      this.hasBOM = true;
-      this.css = this.css.slice(1);
+    this.markDirty();
+    return this;
+  }
+  normalize(nodes, sample) {
+    if (typeof nodes === "string") {
+      nodes = cleanSource(parse$5(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$4(nodes)];
+    } else if (nodes.selector || nodes.selectors) {
+      nodes = [new Rule$5(nodes)];
+    } else if (nodes.name) {
+      nodes = [new AtRule$5(nodes)];
+    } else if (nodes.text) {
+      nodes = [new Comment$5(nodes)];
     } else {
-      this.hasBOM = false;
+      throw new Error("Unknown node type in node creation");
     }
-    if (opts.from) {
-      if (!pathAvailable$1 || /^\w+:\/\//.test(opts.from) || isAbsolute(opts.from)) {
-        this.file = opts.from;
-      } else {
-        this.file = resolve$1(opts.from);
+    let processed = nodes.map((i) => {
+      if (!i[my$1]) Container.rebuild(i);
+      i = i.proxyOf;
+      if (i.parent) i.parent.removeChild(i);
+      if (i[isClean$1]) 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;
       }
     }
-    if (pathAvailable$1 && sourceMapAvailable$1) {
-      let map = new PreviousMap$1(this.css, opts);
-      if (map.text) {
-        this.map = map;
-        let file = map.consumer().file;
-        if (!this.file && file) this.file = this.mapResolve(file);
+    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 index2;
+    for (let id in this.indexes) {
+      index2 = this.indexes[id];
+      if (index2 >= child) {
+        this.indexes[id] = index2 - 1;
       }
     }
-    if (!this.file) {
-      this.id = "<input css " + nanoid(6) + ">";
+    this.markDirty();
+    return this;
+  }
+  replaceValues(pattern, opts, callback) {
+    if (!callback) {
+      callback = opts;
+      opts = {};
     }
-    if (this.map) this.map.file = this.from;
+    this.walkDecls((decl2) => {
+      if (opts.props && !opts.props.includes(decl2.prop)) return;
+      if (opts.fast && !decl2.value.includes(opts.fast)) return;
+      decl2.value = decl2.value.replace(pattern, callback);
+    });
+    this.markDirty();
+    return this;
   }
-  error(message, line, column, opts = {}) {
-    let result2, endLine, endColumn;
-    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;
+  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 (typeof end.offset === "number") {
-        let pos = this.fromOffset(end.offset);
-        endLine = pos.line;
-        endColumn = pos.col;
-      } else {
-        endLine = end.line;
-        endColumn = end.column;
+      if (result2 !== false && child.walk) {
+        result2 = child.walk(callback);
       }
-    } else if (!column) {
-      let pos = this.fromOffset(line);
-      line = pos.line;
-      column = pos.col;
+      return result2;
+    });
+  }
+  walkAtRules(name, callback) {
+    if (!callback) {
+      callback = name;
+      return this.walk((child, i) => {
+        if (child.type === "atrule") {
+          return callback(child, i);
+        }
+      });
     }
-    let origin = this.origin(line, column, endLine, endColumn);
-    if (origin) {
-      result2 = new CssSyntaxError$1(
-        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$1(
-        message,
-        endLine === void 0 ? line : { column, line },
-        endLine === void 0 ? column : { column: endColumn, line: endLine },
-        this.css,
-        this.file,
-        opts.plugin
-      );
+    if (name instanceof RegExp) {
+      return this.walk((child, i) => {
+        if (child.type === "atrule" && name.test(child.name)) {
+          return callback(child, i);
+        }
+      });
     }
-    result2.input = { column, endColumn, endLine, line, source: this.css };
-    if (this.file) {
-      if (pathToFileURL$1) {
-        result2.input.url = pathToFileURL$1(this.file).toString();
+    return this.walk((child, i) => {
+      if (child.type === "atrule" && child.name === name) {
+        return callback(child, i);
       }
-      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;
+  walkComments(callback) {
+    return this.walk((child, i) => {
+      if (child.type === "comment") {
+        return callback(child, i);
       }
-      this[fromOffsetCache] = lineToIndex;
-    } else {
-      lineToIndex = this[fromOffsetCache];
+    });
+  }
+  walkDecls(prop, callback) {
+    if (!callback) {
+      callback = prop;
+      return this.walk((child, i) => {
+        if (child.type === "decl") {
+          return callback(child, i);
+        }
+      });
     }
-    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;
+    if (prop instanceof RegExp) {
+      return this.walk((child, i) => {
+        if (child.type === "decl" && prop.test(child.prop)) {
+          return callback(child, i);
         }
-      }
+      });
     }
-    return {
-      col: offset - lineToIndex[min] + 1,
-      line: min + 1
-    };
+    return this.walk((child, i) => {
+      if (child.type === "decl" && child.prop === prop) {
+        return callback(child, i);
+      }
+    });
   }
-  mapResolve(file) {
-    if (/^\w+:\/\//.test(file)) {
-      return file;
-    }
-    return resolve$1(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 });
+  walkRules(selector, callback) {
+    if (!callback) {
+      callback = selector;
+      return this.walk((child, i) => {
+        if (child.type === "rule") {
+          return callback(child, i);
+        }
+      });
     }
-    let fromUrl;
-    if (isAbsolute(from.source)) {
-      fromUrl = pathToFileURL$1(from.source);
-    } else {
-      fromUrl = new URL(
-        from.source,
-        this.map.consumer().sourceRoot || pathToFileURL$1(this.map.mapFile)
-      );
+    if (selector instanceof RegExp) {
+      return this.walk((child, i) => {
+        if (child.type === "rule" && selector.test(child.selector)) {
+          return callback(child, i);
+        }
+      });
     }
-    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`);
+    return this.walk((child, i) => {
+      if (child.type === "rule" && child.selector === selector) {
+        return callback(child, i);
       }
-    }
-    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 first() {
+    if (!this.proxyOf.nodes) return void 0;
+    return this.proxyOf.nodes[0];
   }
-  get from() {
-    return this.file || this.id;
+  get last() {
+    if (!this.proxyOf.nodes) return void 0;
+    return this.proxyOf.nodes[this.proxyOf.nodes.length - 1];
   }
 };
-var input = Input$4;
-Input$4.default = Input$4;
-if (terminalHighlight && terminalHighlight.registerInput) {
-  terminalHighlight.registerInput(Input$4);
-}
-let { SourceMapConsumer, SourceMapGenerator } = require$$2;
-let { dirname, relative, resolve, sep } = require$$2;
-let { pathToFileURL } = require$$2;
-let Input$3 = input;
-let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
-let pathAvailable = Boolean(dirname && resolve && relative && sep);
-let MapGenerator$2 = class MapGenerator {
-  constructor(stringify2, root2, opts, cssString) {
-    this.stringify = stringify2;
-    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();
+Container$8.registerParse = (dependant) => {
+  parse$5 = dependant;
+};
+Container$8.registerRule = (dependant) => {
+  Rule$5 = dependant;
+};
+Container$8.registerAtRule = (dependant) => {
+  AtRule$5 = dependant;
+};
+Container$8.registerRoot = (dependant) => {
+  Root$7 = dependant;
+};
+var container = Container$8;
+Container$8.default = Container$8;
+Container$8.rebuild = (node2) => {
+  if (node2.type === "atrule") {
+    Object.setPrototypeOf(node2, AtRule$5.prototype);
+  } else if (node2.type === "rule") {
+    Object.setPrototypeOf(node2, Rule$5.prototype);
+  } else if (node2.type === "decl") {
+    Object.setPrototypeOf(node2, Declaration$4.prototype);
+  } else if (node2.type === "comment") {
+    Object.setPrototypeOf(node2, Comment$5.prototype);
+  } else if (node2.type === "root") {
+    Object.setPrototypeOf(node2, Root$7.prototype);
   }
-  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 + " */";
+  node2[my$1] = true;
+  if (node2.nodes) {
+    node2.nodes.forEach((child) => {
+      Container$8.rebuild(child);
+    });
   }
-  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)));
-    }
+};
+let Container$7 = container;
+let AtRule$4 = class AtRule extends Container$7 {
+  constructor(defaults) {
+    super(defaults);
+    this.type = "atrule";
   }
-  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.indexOf("# sourceMappingURL=") === 0) {
-          this.root.removeChild(i);
-        }
-      }
-    } else if (this.css) {
-      this.css = this.css.replace(/\n*?\/\*#[\S\s]*?\*\/$/gm, "");
-    }
+  append(...children) {
+    if (!this.proxyOf.nodes) this.nodes = [];
+    return super.append(...children);
   }
-  generate() {
-    this.clearAnnotation();
-    if (pathAvailable && sourceMapAvailable && this.isMap()) {
-      return this.generateMap();
-    } else {
-      let result2 = "";
-      this.stringify(this.root, (i) => {
-        result2 += i;
-      });
-      return [result2];
-    }
+  prepend(...children) {
+    if (!this.proxyOf.nodes) this.nodes = [];
+    return super.prepend(...children);
   }
-  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];
+};
+var atRule$1 = AtRule$4;
+AtRule$4.default = AtRule$4;
+Container$7.registerAtRule(AtRule$4);
+let Container$6 = container;
+let LazyResult$4;
+let Processor$4;
+let Document$4 = class Document extends Container$6 {
+  constructor(defaults) {
+    super(__spreadValues({ type: "document" }, defaults));
+    if (!this.nodes) {
+      this.nodes = [];
     }
   }
-  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 lines, last;
-    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);
-          }
-        }
-      }
-    });
+  toResult(opts = {}) {
+    let lazy = new LazyResult$4(new Processor$4(), this, opts);
+    return lazy.stringify();
   }
-  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);
+};
+Document$4.registerLazyResult = (dependant) => {
+  LazyResult$4 = dependant;
+};
+Document$4.registerProcessor = (dependant) => {
+  Processor$4 = dependant;
+};
+var document$2 = Document$4;
+Document$4.default = Document$4;
+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 true;
+    return id;
+  };
+};
+let nanoid$1 = (size = 21) => {
+  let id = "";
+  let i = size | 0;
+  while (i--) {
+    id += urlAlphabet[Math.random() * 64 | 0];
   }
-  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 id;
+};
+var nonSecure = { nanoid: nanoid$1, customAlphabet };
+let { existsSync, readFileSync } = require$$2;
+let { dirname: dirname$1, join } = require$$2;
+let { SourceMapConsumer: SourceMapConsumer$2, SourceMapGenerator: SourceMapGenerator$2 } = require$$2;
+function fromBase64(str) {
+  if (Buffer) {
+    return Buffer.from(str, "base64").toString();
+  } else {
+    return window.atob(str);
+  }
+}
+let PreviousMap$2 = 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;
     }
-    return true;
+    if (this.mapFile) this.root = dirname$1(this.mapFile);
+    if (text) this.text = text;
   }
-  isMap() {
-    if (typeof this.opts.map !== "undefined") {
-      return !!this.opts.map;
+  consumer() {
+    if (!this.consumerCache) {
+      this.consumerCache = new SourceMapConsumer$2(this.text);
     }
-    return this.previous().length > 0;
+    return this.consumerCache;
   }
-  isSourcesContent() {
-    if (typeof this.mapOpts.sourcesContent !== "undefined") {
-      return this.mapOpts.sourcesContent;
+  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));
     }
-    if (this.previous().length) {
-      return this.previous().some((i) => i.withContent());
+    let baseUriMatch = text.match(baseCharsetUri) || text.match(baseUri);
+    if (baseUriMatch) {
+      return fromBase64(text.substr(baseUriMatch[0].length));
     }
-    return true;
+    let encoding = text.match(/data:application\/json;([^,]+),/)[1];
+    throw new Error("Unsupported source map encoding " + encoding);
   }
-  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";
+  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));
     }
   }
-  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));
+  loadFile(path) {
+    this.root = dirname$1(path);
+    if (existsSync(path)) {
+      this.mapFile = path;
+      return readFileSync(path, "utf-8").toString().trim();
     }
-    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);
-            }
+  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$2) {
+        return SourceMapGenerator$2.fromSourceMap(prev).toString();
+      } else if (prev instanceof SourceMapGenerator$2) {
+        return prev.toString();
+      } else if (this.isMap(prev)) {
+        return JSON.stringify(prev);
       } else {
-        let input2 = new Input$3(this.originalCSS, this.opts);
-        if (input2.map) this.previousMaps.push(input2.map);
+        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$1(file), map);
+      return this.loadFile(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);
+  startWith(string, start) {
+    if (!string) return false;
+    return string.substr(0, start.length) === start;
+  }
+  withContent() {
+    return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
+  }
+};
+var previousMap = PreviousMap$2;
+PreviousMap$2.default = PreviousMap$2;
+let { nanoid } = nonSecure;
+let { isAbsolute, resolve: resolve$1 } = require$$2;
+let { SourceMapConsumer: SourceMapConsumer$1, SourceMapGenerator: SourceMapGenerator$1 } = require$$2;
+let { fileURLToPath, pathToFileURL: pathToFileURL$1 } = require$$2;
+let CssSyntaxError$2 = cssSyntaxError;
+let PreviousMap$1 = previousMap;
+let terminalHighlight = require$$2;
+let fromOffsetCache = Symbol("fromOffsetCache");
+let sourceMapAvailable$1 = Boolean(SourceMapConsumer$1 && SourceMapGenerator$1);
+let pathAvailable$1 = Boolean(resolve$1 && isAbsolute);
+let Input$6 = 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$1 || /^\w+:\/\//.test(opts.from) || isAbsolute(opts.from)) {
+        this.file = opts.from;
+      } else {
+        this.file = resolve$1(opts.from);
+      }
+    }
+    if (pathAvailable$1 && sourceMapAvailable$1) {
+      let map = new PreviousMap$1(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;
     }
-  }
-  sourcePath(node2) {
-    if (this.mapOpts.from) {
-      return this.toUrl(this.mapOpts.from);
-    } else if (this.usesFileUrls) {
-      return this.toFileUrl(node2.source.input.from);
+    let origin = this.origin(line, column, endLine, endColumn);
+    if (origin) {
+      result2 = new CssSyntaxError$2(
+        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 {
-      return this.toUrl(this.path(node2.source.input.from));
+      result2 = new CssSyntaxError$2(
+        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$1) {
+        result2.input.url = pathToFileURL$1(this.file).toString();
+      }
+      result2.input.file = this.file;
     }
+    return result2;
   }
-  toBase64(str) {
-    if (Buffer) {
-      return Buffer.from(str).toString("base64");
+  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 {
-      return window.btoa(unescape(encodeURIComponent(str)));
+      lineToIndex = this[fromOffsetCache];
     }
-  }
-  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;
+    lastLine = lineToIndex[lineToIndex.length - 1];
+    let min = 0;
+    if (offset >= lastLine) {
+      min = lineToIndex.length - 1;
     } else {
-      throw new Error(
-        "`map.absolute` option is not available in this PostCSS build"
-      );
+      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
+    };
   }
-  toUrl(path) {
-    let cached = this.memoizedURLs.get(path);
-    if (cached) return cached;
-    if (sep === "\\") {
-      path = path.replace(/\\/g, "/");
+  mapResolve(file) {
+    if (/^\w+:\/\//.test(file)) {
+      return file;
     }
-    let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent);
-    this.memoizedURLs.set(path, url);
-    return url;
-  }
-};
-var mapGenerator = MapGenerator$2;
-let Node$2 = node;
-let Comment$4 = class Comment extends Node$2 {
-  constructor(defaults) {
-    super(defaults);
-    this.type = "comment";
+    return resolve$1(this.map.consumer().sourceRoot || this.map.root || ".", file);
   }
-};
-var comment = Comment$4;
-Comment$4.default = Comment$4;
-let { isClean: isClean$1, my: my$1 } = symbols;
-let Declaration$3 = declaration;
-let Comment$3 = comment;
-let Node$1 = node;
-let parse$4;
-let Rule$4;
-let AtRule$4;
-let Root$6;
-function cleanSource(nodes) {
-  return nodes.map((i) => {
-    if (i.nodes) i.nodes = cleanSource(i.nodes);
-    delete i.source;
-    return i;
-  });
-}
-function markDirtyUp(node2) {
-  node2[isClean$1] = false;
-  if (node2.proxyOf.nodes) {
-    for (let i of node2.proxyOf.nodes) {
-      markDirtyUp(i);
+  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 Container$7 = class Container extends Node$1 {
-  append(...children) {
-    for (let child of children) {
-      let nodes = this.normalize(child, this.last);
-      for (let node2 of nodes) this.proxyOf.nodes.push(node2);
+    let fromUrl;
+    if (isAbsolute(from.source)) {
+      fromUrl = pathToFileURL$1(from.source);
+    } else {
+      fromUrl = new URL(
+        from.source,
+        this.map.consumer().sourceRoot || pathToFileURL$1(this.map.mapFile)
+      );
     }
-    this.markDirty();
-    return this;
-  }
-  cleanRaws(keepBetween) {
-    super.cleanRaws(keepBetween);
-    if (this.nodes) {
-      for (let node2 of this.nodes) node2.cleanRaws(keepBetween);
+    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;
   }
-  each(callback) {
-    if (!this.proxyOf.nodes) return void 0;
-    let iterator = this.getIterator();
-    let index2, result2;
-    while (this.indexes[iterator] < this.proxyOf.nodes.length) {
-      index2 = this.indexes[iterator];
-      result2 = callback(this.proxyOf.nodes[index2], index2);
-      if (result2 === false) break;
-      this.indexes[iterator] += 1;
+  toJSON() {
+    let json = {};
+    for (let name of ["hasBOM", "css", "file", "id"]) {
+      if (this[name] != null) {
+        json[name] = this[name];
+      }
     }
-    delete this.indexes[iterator];
-    return result2;
+    if (this.map) {
+      json.map = __spreadValues({}, this.map);
+      if (json.map.consumerCache) {
+        json.map.consumerCache = void 0;
+      }
+    }
+    return json;
   }
-  every(condition) {
-    return this.nodes.every(condition);
+  get from() {
+    return this.file || this.id;
   }
-  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;
+};
+var input = Input$6;
+Input$6.default = Input$6;
+if (terminalHighlight && terminalHighlight.registerInput) {
+  terminalHighlight.registerInput(Input$6);
+}
+let Container$5 = container;
+let LazyResult$3;
+let Processor$3;
+let Root$6 = class Root extends Container$5 {
+  constructor(defaults) {
+    super(defaults);
+    this.type = "root";
+    if (!this.nodes) this.nodes = [];
   }
-  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, index2) => i(child.toProxy(), index2);
-                } 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();
+  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 {
-          return node2[prop];
+          delete sample.raws.before;
         }
-      },
-      set(node2, prop, value) {
-        if (node2[prop] === value) return true;
-        node2[prop] = value;
-        if (prop === "name" || prop === "params" || prop === "selector") {
-          node2.markDirty();
+      } else if (this.first !== sample) {
+        for (let node2 of nodes) {
+          node2.raws.before = sample.raws.before;
         }
-        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 index2;
-    for (let id in this.indexes) {
-      index2 = this.indexes[id];
-      if (existIndex < index2) {
-        this.indexes[id] = index2 + nodes.length;
       }
     }
-    this.markDirty();
-    return this;
+    return nodes;
   }
-  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 index2;
-    for (let id in this.indexes) {
-      index2 = this.indexes[id];
-      if (existIndex <= index2) {
-        this.indexes[id] = index2 + nodes.length;
-      }
+  removeChild(child, ignore) {
+    let index2 = this.index(child);
+    if (!ignore && index2 === 0 && this.nodes.length > 1) {
+      this.nodes[1].raws.before = this.nodes[index2].raws.before;
     }
-    this.markDirty();
-    return this;
+    return super.removeChild(child);
   }
-  normalize(nodes, sample) {
-    if (typeof nodes === "string") {
-      nodes = cleanSource(parse$4(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$3(nodes)];
-    } else if (nodes.selector) {
-      nodes = [new Rule$4(nodes)];
-    } else if (nodes.name) {
-      nodes = [new AtRule$4(nodes)];
-    } else if (nodes.text) {
-      nodes = [new Comment$3(nodes)];
-    } else {
-      throw new Error("Unknown node type in node creation");
-    }
-    let processed = nodes.map((i) => {
-      if (!i[my$1]) Container.rebuild(i);
-      i = i.proxyOf;
-      if (i.parent) i.parent.removeChild(i);
-      if (i[isClean$1]) markDirtyUp(i);
-      if (typeof i.raws.before === "undefined") {
-        if (sample && typeof sample.raws.before !== "undefined") {
-          i.raws.before = sample.raws.before.replace(/\S/g, "");
+  toResult(opts = {}) {
+    let lazy = new LazyResult$3(new Processor$3(), this, opts);
+    return lazy.stringify();
+  }
+};
+Root$6.registerLazyResult = (dependant) => {
+  LazyResult$3 = dependant;
+};
+Root$6.registerProcessor = (dependant) => {
+  Processor$3 = dependant;
+};
+var root$1 = Root$6;
+Root$6.default = Root$6;
+Container$5.registerRoot(Root$6);
+let list$3 = {
+  comma(string) {
+    return list$3.split(string, [","], true);
+  },
+  space(string) {
+    let spaces = [" ", "\n", "	"];
+    return list$3.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;
       }
-      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;
+      if (split) {
+        if (current !== "") array.push(current.trim());
+        current = "";
+        split = false;
+      } else {
+        current += letter;
       }
     }
-    this.markDirty();
-    return this;
+    if (last || current !== "") array.push(current.trim());
+    return array;
   }
-  push(child) {
-    child.parent = this;
-    this.proxyOf.nodes.push(child);
-    return this;
+};
+var list_1 = list$3;
+list$3.default = list$3;
+let Container$4 = container;
+let list$2 = list_1;
+let Rule$4 = class Rule extends Container$4 {
+  constructor(defaults) {
+    super(defaults);
+    this.type = "rule";
+    if (!this.nodes) this.nodes = [];
   }
-  removeAll() {
-    for (let node2 of this.proxyOf.nodes) node2.parent = void 0;
-    this.proxyOf.nodes = [];
-    this.markDirty();
-    return this;
+  get selectors() {
+    return list$2.comma(this.selector);
   }
-  removeChild(child) {
-    child = this.index(child);
-    this.proxyOf.nodes[child].parent = void 0;
-    this.proxyOf.nodes.splice(child, 1);
-    let index2;
-    for (let id in this.indexes) {
-      index2 = this.indexes[id];
-      if (index2 >= child) {
-        this.indexes[id] = index2 - 1;
+  set selectors(values) {
+    let match = this.selector ? this.selector.match(/,\s*/) : null;
+    let sep2 = match ? match[0] : "," + this.raw("between", "beforeOpen");
+    this.selector = values.join(sep2);
+  }
+};
+var rule$1 = Rule$4;
+Rule$4.default = Rule$4;
+Container$4.registerRule(Rule$4);
+let AtRule$3 = atRule$1;
+let Comment$4 = comment$1;
+let Declaration$3 = declaration;
+let Input$5 = input;
+let PreviousMap2 = previousMap;
+let Root$5 = root$1;
+let Rule$3 = rule$1;
+function fromJSON$2(json, inputs) {
+  if (Array.isArray(json)) return json.map((n) => fromJSON$2(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$5.prototype });
+      if (inputHydrated.map) {
+        inputHydrated.map = __spreadProps(__spreadValues({}, inputHydrated.map), {
+          __proto__: PreviousMap2.prototype
+        });
       }
+      inputs.push(inputHydrated);
     }
-    this.markDirty();
-    return this;
   }
-  replaceValues(pattern, opts, callback) {
-    if (!callback) {
-      callback = opts;
-      opts = {};
+  if (defaults.nodes) {
+    defaults.nodes = json.nodes.map((n) => fromJSON$2(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];
     }
-    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);
+  if (defaults.type === "root") {
+    return new Root$5(defaults);
+  } else if (defaults.type === "decl") {
+    return new Declaration$3(defaults);
+  } else if (defaults.type === "rule") {
+    return new Rule$3(defaults);
+  } else if (defaults.type === "comment") {
+    return new Comment$4(defaults);
+  } else if (defaults.type === "atrule") {
+    return new AtRule$3(defaults);
+  } else {
+    throw new Error("Unknown node type: " + json.type);
   }
-  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);
+}
+var fromJSON_1 = fromJSON$2;
+fromJSON$2.default = fromJSON$2;
+let { dirname, relative, resolve, sep } = require$$2;
+let { SourceMapConsumer, SourceMapGenerator } = require$$2;
+let { pathToFileURL } = require$$2;
+let Input$4 = input;
+let sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
+let pathAvailable = Boolean(dirname && resolve && relative && sep);
+let MapGenerator$2 = class MapGenerator {
+  constructor(stringify2, root2, opts, cssString) {
+    this.stringify = stringify2;
+    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();
       }
-      return result2;
-    });
+      this.map.applySourceMap(map, from, this.toUrl(this.path(root2)));
+    }
   }
-  walkAtRules(name, callback) {
-    if (!callback) {
-      callback = name;
-      return this.walk((child, i) => {
-        if (child.type === "atrule") {
-          return callback(child, i);
+  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, "");
     }
-    if (name instanceof RegExp) {
-      return this.walk((child, i) => {
-        if (child.type === "atrule" && name.test(child.name)) {
-          return callback(child, i);
-        }
+  }
+  generate() {
+    this.clearAnnotation();
+    if (pathAvailable && sourceMapAvailable && this.isMap()) {
+      return this.generateMap();
+    } else {
+      let result2 = "";
+      this.stringify(this.root, (i) => {
+        result2 += i;
       });
+      return [result2];
     }
-    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);
-        }
+  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
       });
-    }
-    if (prop instanceof RegExp) {
-      return this.walk((child, i) => {
-        if (child.type === "decl" && prop.test(child.prop)) {
-          return callback(child, i);
-        }
+    } 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>"
       });
     }
-    return this.walk((child, i) => {
-      if (child.type === "decl" && child.prop === prop) {
-        return callback(child, i);
-      }
-    });
+    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];
+    }
   }
-  walkRules(selector, callback) {
-    if (!callback) {
-      callback = selector;
-      return this.walk((child, i) => {
-        if (child.type === "rule") {
-          return callback(child, i);
+  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);
         }
-      });
-    }
-    if (selector instanceof RegExp) {
-      return this.walk((child, i) => {
-        if (child.type === "rule" && selector.test(child.selector)) {
-          return callback(child, i);
+      }
+      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);
+          }
         }
-      });
-    }
-    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$7.registerParse = (dependant) => {
-  parse$4 = dependant;
-};
-Container$7.registerRule = (dependant) => {
-  Rule$4 = dependant;
-};
-Container$7.registerAtRule = (dependant) => {
-  AtRule$4 = dependant;
-};
-Container$7.registerRoot = (dependant) => {
-  Root$6 = dependant;
-};
-var container = Container$7;
-Container$7.default = Container$7;
-Container$7.rebuild = (node2) => {
-  if (node2.type === "atrule") {
-    Object.setPrototypeOf(node2, AtRule$4.prototype);
-  } else if (node2.type === "rule") {
-    Object.setPrototypeOf(node2, Rule$4.prototype);
-  } else if (node2.type === "decl") {
-    Object.setPrototypeOf(node2, Declaration$3.prototype);
-  } else if (node2.type === "comment") {
-    Object.setPrototypeOf(node2, Comment$3.prototype);
-  } else if (node2.type === "root") {
-    Object.setPrototypeOf(node2, Root$6.prototype);
-  }
-  node2[my$1] = true;
-  if (node2.nodes) {
-    node2.nodes.forEach((child) => {
-      Container$7.rebuild(child);
-    });
-  }
-};
-let Container$6 = container;
-let LazyResult$4;
-let Processor$3;
-let Document$3 = class Document extends Container$6 {
-  constructor(defaults) {
-    super(__spreadValues({ type: "document" }, defaults));
-    if (!this.nodes) {
-      this.nodes = [];
+  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;
   }
-  toResult(opts = {}) {
-    let lazy = new LazyResult$4(new Processor$3(), this, opts);
-    return lazy.stringify();
+  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;
   }
-};
-Document$3.registerLazyResult = (dependant) => {
-  LazyResult$4 = dependant;
-};
-Document$3.registerProcessor = (dependant) => {
-  Processor$3 = dependant;
-};
-var document$1 = Document$3;
-Document$3.default = Document$3;
-let printed = {};
-var warnOnce$2 = function warnOnce(message) {
-  if (printed[message]) return;
-  printed[message] = true;
-  if (typeof console !== "undefined" && console.warn) {
-    console.warn(message);
+  isMap() {
+    if (typeof this.opts.map !== "undefined") {
+      return !!this.opts.map;
+    }
+    return this.previous().length > 0;
   }
-};
-let Warning$2 = 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;
+  isSourcesContent() {
+    if (typeof this.mapOpts.sourcesContent !== "undefined") {
+      return this.mapOpts.sourcesContent;
+    }
+    if (this.previous().length) {
+      return this.previous().some((i) => i.withContent());
     }
-    for (let opt in opts) this[opt] = opts[opt];
+    return true;
   }
-  toString() {
-    if (this.node) {
-      return this.node.error(this.text, {
-        index: this.index,
-        plugin: this.plugin,
-        word: this.word
-      }).message;
+  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";
     }
-    if (this.plugin) {
-      return this.plugin + ": " + this.text;
+  }
+  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));
     }
-    return this.text;
+    let path = relative(from, file);
+    this.memoizedPaths.set(file, path);
+    return path;
   }
-};
-var warning = Warning$2;
-Warning$2.default = Warning$2;
-let Warning$1 = warning;
-let Result$3 = 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;
+  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$4(this.originalCSS, this.opts);
+        if (input2.map) this.previousMaps.push(input2.map);
+      }
+    }
+    return this.previousMaps;
   }
-  toString() {
-    return this.css;
+  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);
+    }
   }
-  warn(text, opts = {}) {
-    if (!opts.plugin) {
-      if (this.lastPlugin && this.lastPlugin.postcssPlugin) {
-        opts.plugin = this.lastPlugin.postcssPlugin;
-      }
+  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));
     }
-    let warning2 = new Warning$1(text, opts);
-    this.messages.push(warning2);
-    return warning2;
   }
-  warnings() {
-    return this.messages.filter((i) => i.type === "warning");
+  toBase64(str) {
+    if (Buffer) {
+      return Buffer.from(str).toString("base64");
+    } else {
+      return window.btoa(unescape(encodeURIComponent(str)));
+    }
   }
-  get content() {
-    return this.css;
+  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;
   }
 };
-var result = Result$3;
-Result$3.default = Result$3;
+var mapGenerator = MapGenerator$2;
 const SINGLE_QUOTE = "'".charCodeAt(0);
 const DOUBLE_QUOTE = '"'.charCodeAt(0);
 const BACKSLASH = "\\".charCodeAt(0);
@@ -3455,8 +3625,8 @@ const RE_HEX_ESCAPE = /[\da-f]/i;
 var tokenize = function tokenizer(input2, options = {}) {
   let css = input2.css.valueOf();
   let ignore = options.ignoreErrors;
-  let code, next, quote, content, escape;
-  let escaped, escapePos, prev, n, currentToken;
+  let code, content, escape, next, quote;
+  let currentToken, escaped, escapePos, n, prev;
   let length = css.length;
   let pos = 0;
   let buffer = [];
@@ -3578,205 +3748,71 @@ var tokenize = function tokenizer(input2, options = {}) {
         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
-  };
-};
-let Container$5 = container;
-let AtRule$3 = class AtRule extends Container$5 {
-  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);
-  }
-};
-var atRule = AtRule$3;
-AtRule$3.default = AtRule$3;
-Container$5.registerAtRule(AtRule$3);
-let Container$4 = container;
-let LazyResult$3;
-let Processor$2;
-let Root$5 = class Root extends Container$4 {
-  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 index2 = this.index(child);
-    if (!ignore && index2 === 0 && this.nodes.length > 1) {
-      this.nodes[1].raws.before = this.nodes[index2].raws.before;
-    }
-    return super.removeChild(child);
-  }
-  toResult(opts = {}) {
-    let lazy = new LazyResult$3(new Processor$2(), this, opts);
-    return lazy.stringify();
-  }
-};
-Root$5.registerLazyResult = (dependant) => {
-  LazyResult$3 = dependant;
-};
-Root$5.registerProcessor = (dependant) => {
-  Processor$2 = dependant;
-};
-var root = Root$5;
-Root$5.default = Root$5;
-Container$4.registerRoot(Root$5);
-let list$2 = {
-  comma(string) {
-    return list$2.split(string, [","], true);
-  },
-  space(string) {
-    let spaces = [" ", "\n", "	"];
-    return list$2.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;
+          next += 1;
+          escape = !escape;
         }
-      } 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;
+        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;
       }
-      if (split) {
-        if (current !== "") array.push(current.trim());
-        current = "";
-        split = false;
-      } else {
-        current += letter;
+      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;
       }
     }
-    if (last || current !== "") array.push(current.trim());
-    return array;
-  }
-};
-var list_1 = list$2;
-list$2.default = list$2;
-let Container$3 = container;
-let list$1 = list_1;
-let Rule$3 = class Rule extends Container$3 {
-  constructor(defaults) {
-    super(defaults);
-    this.type = "rule";
-    if (!this.nodes) this.nodes = [];
-  }
-  get selectors() {
-    return list$1.comma(this.selector);
+    pos++;
+    return currentToken;
   }
-  set selectors(values) {
-    let match = this.selector ? this.selector.match(/,\s*/) : null;
-    let sep2 = match ? match[0] : "," + this.raw("between", "beforeOpen");
-    this.selector = values.join(sep2);
+  function back(token) {
+    returned.push(token);
   }
+  return {
+    back,
+    endOfFile,
+    nextToken,
+    position
+  };
 };
-var rule = Rule$3;
-Rule$3.default = Rule$3;
-Container$3.registerRule(Rule$3);
+let AtRule$2 = atRule$1;
+let Comment$3 = comment$1;
 let Declaration$2 = declaration;
-let tokenizer2 = tokenize;
-let Comment$2 = comment;
-let AtRule$2 = atRule;
-let Root$4 = root;
-let Rule$2 = rule;
+let Root$4 = root$1;
+let Rule$2 = rule$1;
+let tokenizer$1 = tokenize;
 const SAFE_COMMENT_NEIGHBOR = {
   empty: true,
   space: true
@@ -3788,7 +3824,7 @@ function findLastWithPosition(tokens) {
     if (pos) return pos;
   }
 }
-let Parser$1 = class Parser {
+let Parser$2 = class Parser {
   constructor(input2) {
     this.input = input2;
     this.root = new Root$4();
@@ -3895,7 +3931,7 @@ let Parser$1 = class Parser {
   }
   colon(tokens) {
     let brackets = 0;
-    let token, type, prev;
+    let prev, token, type;
     for (let [i, element] of tokens.entries()) {
       token = element;
       type = token[0];
@@ -3919,7 +3955,7 @@ let Parser$1 = class Parser {
     return false;
   }
   comment(token) {
-    let node2 = new Comment$2();
+    let node2 = new Comment$3();
     this.init(node2, token[2]);
     node2.source.end = this.getPosition(token[3] || token[2]);
     node2.source.end.offset++;
@@ -3936,7 +3972,7 @@ let Parser$1 = class Parser {
     }
   }
   createTokenizer() {
-    this.tokenizer = tokenizer2(this.input);
+    this.tokenizer = tokenizer$1(this.input);
   }
   decl(tokens, customProperty) {
     let node2 = new Declaration$2();
@@ -4002,12 +4038,12 @@ let Parser$1 = class Parser {
         let str = "";
         for (let j = i; j > 0; j--) {
           let type = cache[j][0];
-          if (str.trim().indexOf("!") === 0 && type !== "space") {
+          if (str.trim().startsWith("!") && type !== "space") {
             break;
           }
           str = cache.pop()[1] + str;
         }
-        if (str.trim().indexOf("!") === 0) {
+        if (str.trim().startsWith("!")) {
           node2.important = true;
           node2.raws.important = str;
           tokens = cache;
@@ -4295,13 +4331,13 @@ let Parser$1 = class Parser {
     );
   }
 };
-var parser = Parser$1;
-let Container$2 = container;
-let Parser2 = parser;
-let Input$2 = input;
-function parse$3(css, opts) {
-  let input2 = new Input$2(css, opts);
-  let parser2 = new Parser2(input2);
+var parser = Parser$2;
+let Container$3 = container;
+let Input$3 = input;
+let Parser$1 = parser;
+function parse$4(css, opts) {
+  let input2 = new Input$3(css, opts);
+  let parser2 = new Parser$1(input2);
   try {
     parser2.parse();
   } catch (e) {
@@ -4320,18 +4356,87 @@ function parse$3(css, opts) {
   }
   return parser2.root;
 }
-var parse_1 = parse$3;
-parse$3.default = parse$3;
-Container$2.registerParse(parse$3);
-let { isClean, my } = symbols;
+var parse_1 = parse$4;
+parse$4.default = parse$4;
+Container$3.registerParse(parse$4);
+let Warning$3 = 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;
+  }
+};
+var warning = Warning$3;
+Warning$3.default = Warning$3;
+let Warning$2 = warning;
+let Result$4 = 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$2(text, opts);
+    this.messages.push(warning2);
+    return warning2;
+  }
+  warnings() {
+    return this.messages.filter((i) => i.type === "warning");
+  }
+  get content() {
+    return this.css;
+  }
+};
+var result = Result$4;
+Result$4.default = Result$4;
+let printed = {};
+var warnOnce$2 = function warnOnce(message) {
+  if (printed[message]) return;
+  printed[message] = true;
+  if (typeof console !== "undefined" && console.warn) {
+    console.warn(message);
+  }
+};
+let Container$2 = container;
+let Document$3 = document$2;
 let MapGenerator$1 = mapGenerator;
-let stringify$2 = stringify_1;
-let Container$1 = container;
-let Document$2 = document$1;
+let parse$3 = parse_1;
+let Result$3 = result;
+let Root$3 = root$1;
+let stringify$3 = stringify_1;
+let { isClean, my } = symbols;
 let warnOnce$1 = warnOnce$2;
-let Result$2 = result;
-let parse$2 = parse_1;
-let Root$3 = root;
 const TYPE_TO_CLASS_NAME = {
   atrule: "AtRule",
   comment: "Comment",
@@ -4414,7 +4519,7 @@ function cleanMarks(node2) {
   if (node2.nodes) node2.nodes.forEach((i) => cleanMarks(i));
   return node2;
 }
-let postcss$2 = {};
+let postcss$3 = {};
 let LazyResult$2 = class LazyResult {
   constructor(processor2, css, opts) {
     this.stringified = false;
@@ -4422,7 +4527,7 @@ let LazyResult$2 = class LazyResult {
     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$2) {
+    } else if (css instanceof LazyResult || css instanceof Result$3) {
       root2 = cleanMarks(css.root);
       if (css.map) {
         if (typeof opts.map === "undefined") opts.map = {};
@@ -4430,7 +4535,7 @@ let LazyResult$2 = class LazyResult {
         opts.map.prev = css.map;
       }
     } else {
-      let parser2 = parse$2;
+      let parser2 = parse$3;
       if (opts.syntax) parser2 = opts.syntax.parse;
       if (opts.parser) parser2 = opts.parser;
       if (parser2.parse) parser2 = parser2.parse;
@@ -4441,16 +4546,16 @@ let LazyResult$2 = class LazyResult {
         this.error = error;
       }
       if (root2 && !root2[my]) {
-        Container$1.rebuild(root2);
+        Container$2.rebuild(root2);
       }
     }
-    this.result = new Result$2(processor2, root2, opts);
-    this.helpers = __spreadProps(__spreadValues({}, postcss$2), { postcss: postcss$2, result: this.result });
-    this.plugins = this.processor.plugins.map((plugin2) => {
-      if (typeof plugin2 === "object" && plugin2.prepare) {
-        return __spreadValues(__spreadValues({}, plugin2), plugin2.prepare(this.result));
+    this.result = new Result$3(processor2, root2, opts);
+    this.helpers = __spreadProps(__spreadValues({}, postcss$3), { postcss: postcss$3, result: this.result });
+    this.plugins = this.processor.plugins.map((plugin3) => {
+      if (typeof plugin3 === "object" && plugin3.prepare) {
+        return __spreadValues(__spreadValues({}, plugin3), plugin3.prepare(this.result));
       } else {
-        return plugin2;
+        return plugin3;
       }
     });
   }
@@ -4472,17 +4577,17 @@ let LazyResult$2 = class LazyResult {
     throw new Error("Use process(css).then(cb) to work with async plugins");
   }
   handleError(error, node2) {
-    let plugin2 = this.result.lastPlugin;
+    let plugin3 = this.result.lastPlugin;
     try {
       if (node2) node2.addToError(error);
       this.error = error;
       if (error.name === "CssSyntaxError" && !error.plugin) {
-        error.plugin = plugin2.postcssPlugin;
+        error.plugin = plugin3.postcssPlugin;
         error.setMessage();
-      } else if (plugin2.postcssVersion) {
+      } else if (plugin3.postcssVersion) {
         if (true) {
-          let pluginName = plugin2.postcssPlugin;
-          let pluginVer = plugin2.postcssVersion;
+          let pluginName = plugin3.postcssPlugin;
+          let pluginVer = plugin3.postcssVersion;
           let runtimeVer = this.result.processor.version;
           let a = pluginVer.split(".");
           let b = runtimeVer.split(".");
@@ -4500,33 +4605,33 @@ let LazyResult$2 = class LazyResult {
   }
   prepareVisitors() {
     this.listeners = {};
-    let add = (plugin2, type, cb) => {
+    let add = (plugin3, type, cb) => {
       if (!this.listeners[type]) this.listeners[type] = [];
-      this.listeners[type].push([plugin2, cb]);
+      this.listeners[type].push([plugin3, cb]);
     };
-    for (let plugin2 of this.plugins) {
-      if (typeof plugin2 === "object") {
-        for (let event in plugin2) {
+    for (let plugin3 of this.plugins) {
+      if (typeof plugin3 === "object") {
+        for (let event in plugin3) {
           if (!PLUGIN_PROPS[event] && /^[A-Z]/.test(event)) {
             throw new Error(
-              `Unknown event ${event} in ${plugin2.postcssPlugin}. Try to update PostCSS (${this.processor.version} now).`
+              `Unknown event ${event} in ${plugin3.postcssPlugin}. Try to update PostCSS (${this.processor.version} now).`
             );
           }
           if (!NOT_VISITORS[event]) {
-            if (typeof plugin2[event] === "object") {
-              for (let filter in plugin2[event]) {
+            if (typeof plugin3[event] === "object") {
+              for (let filter in plugin3[event]) {
                 if (filter === "*") {
-                  add(plugin2, event, plugin2[event][filter]);
+                  add(plugin3, event, plugin3[event][filter]);
                 } else {
                   add(
-                    plugin2,
+                    plugin3,
                     event + "-" + filter.toLowerCase(),
-                    plugin2[event][filter]
+                    plugin3[event][filter]
                   );
                 }
               }
-            } else if (typeof plugin2[event] === "function") {
-              add(plugin2, event, plugin2[event]);
+            } else if (typeof plugin3[event] === "function") {
+              add(plugin3, event, plugin3[event]);
             }
           }
         }
@@ -4537,8 +4642,8 @@ let LazyResult$2 = class LazyResult {
   async runAsync() {
     this.plugin = 0;
     for (let i = 0; i < this.plugins.length; i++) {
-      let plugin2 = this.plugins[i];
-      let promise = this.runOnRoot(plugin2);
+      let plugin3 = this.plugins[i];
+      let promise = this.runOnRoot(plugin3);
       if (isPromise(promise)) {
         try {
           await promise;
@@ -4566,8 +4671,8 @@ let LazyResult$2 = class LazyResult {
         }
       }
       if (this.listeners.OnceExit) {
-        for (let [plugin2, visitor] of this.listeners.OnceExit) {
-          this.result.lastPlugin = plugin2;
+        for (let [plugin3, visitor] of this.listeners.OnceExit) {
+          this.result.lastPlugin = plugin3;
           try {
             if (root2.type === "document") {
               let roots = root2.nodes.map(
@@ -4586,22 +4691,22 @@ let LazyResult$2 = class LazyResult {
     this.processed = true;
     return this.stringify();
   }
-  runOnRoot(plugin2) {
-    this.result.lastPlugin = plugin2;
+  runOnRoot(plugin3) {
+    this.result.lastPlugin = plugin3;
     try {
-      if (typeof plugin2 === "object" && plugin2.Once) {
+      if (typeof plugin3 === "object" && plugin3.Once) {
         if (this.result.root.type === "document") {
           let roots = this.result.root.nodes.map(
-            (root2) => plugin2.Once(root2, this.helpers)
+            (root2) => plugin3.Once(root2, this.helpers)
           );
           if (isPromise(roots[0])) {
             return Promise.all(roots);
           }
           return roots;
         }
-        return plugin2.Once(this.result.root, this.helpers);
-      } else if (typeof plugin2 === "function") {
-        return plugin2(this.result.root, this.result);
+        return plugin3.Once(this.result.root, this.helpers);
+      } else if (typeof plugin3 === "function") {
+        return plugin3(this.result.root, this.result);
       }
     } catch (error) {
       throw this.handleError(error);
@@ -4613,7 +4718,7 @@ let LazyResult$2 = class LazyResult {
     this.stringified = true;
     this.sync();
     let opts = this.result.opts;
-    let str = stringify$2;
+    let str = stringify$3;
     if (opts.syntax) str = opts.syntax.stringify;
     if (opts.stringifier) str = opts.stringifier;
     if (str.stringify) str = str.stringify;
@@ -4630,8 +4735,8 @@ let LazyResult$2 = class LazyResult {
     if (this.processing) {
       throw this.getAsyncError();
     }
-    for (let plugin2 of this.plugins) {
-      let promise = this.runOnRoot(plugin2);
+    for (let plugin3 of this.plugins) {
+      let promise = this.runOnRoot(plugin3);
       if (isPromise(promise)) {
         throw this.getAsyncError();
       }
@@ -4669,8 +4774,8 @@ let LazyResult$2 = class LazyResult {
     return this.css;
   }
   visitSync(visitors, node2) {
-    for (let [plugin2, visitor] of visitors) {
-      this.result.lastPlugin = plugin2;
+    for (let [plugin3, visitor] of visitors) {
+      this.result.lastPlugin = plugin3;
       let promise;
       try {
         promise = visitor(node2, this.helpers);
@@ -4693,13 +4798,13 @@ let LazyResult$2 = class LazyResult {
       return;
     }
     if (visitors.length > 0 && visit2.visitorIndex < visitors.length) {
-      let [plugin2, visitor] = visitors[visit2.visitorIndex];
+      let [plugin3, visitor] = visitors[visit2.visitorIndex];
       visit2.visitorIndex += 1;
       if (visit2.visitorIndex === visitors.length) {
         visit2.visitors = [];
         visit2.visitorIndex = 0;
       }
-      this.result.lastPlugin = plugin2;
+      this.result.lastPlugin = plugin3;
       try {
         return visitor(node2.toProxy(), this.helpers);
       } catch (e) {
@@ -4784,17 +4889,17 @@ let LazyResult$2 = class LazyResult {
   }
 };
 LazyResult$2.registerPostcss = (dependant) => {
-  postcss$2 = dependant;
+  postcss$3 = dependant;
 };
 var lazyResult = LazyResult$2;
 LazyResult$2.default = LazyResult$2;
 Root$3.registerLazyResult(LazyResult$2);
-Document$2.registerLazyResult(LazyResult$2);
+Document$3.registerLazyResult(LazyResult$2);
 let MapGenerator2 = mapGenerator;
-let stringify$1 = stringify_1;
+let parse$2 = parse_1;
+const Result$2 = result;
+let stringify$2 = stringify_1;
 let warnOnce2 = warnOnce$2;
-let parse$1 = parse_1;
-const Result$1 = result;
 let NoWorkResult$1 = class NoWorkResult {
   constructor(processor2, css, opts) {
     css = css.toString();
@@ -4804,8 +4909,8 @@ let NoWorkResult$1 = class NoWorkResult {
     this._opts = opts;
     this._map = void 0;
     let root2;
-    let str = stringify$1;
-    this.result = new Result$1(this._processor, root2, this._opts);
+    let str = stringify$2;
+    this.result = new Result$2(this._processor, root2, this._opts);
     this.result.css = css;
     let self = this;
     Object.defineProperty(this.result, "root", {
@@ -4880,7 +4985,7 @@ let NoWorkResult$1 = class NoWorkResult {
       return this._root;
     }
     let root2;
-    let parser2 = parse$1;
+    let parser2 = parse$2;
     try {
       root2 = parser2(this._css, this._opts);
     } catch (error) {
@@ -4899,13 +5004,13 @@ let NoWorkResult$1 = class NoWorkResult {
 };
 var noWorkResult = NoWorkResult$1;
 NoWorkResult$1.default = NoWorkResult$1;
-let NoWorkResult2 = noWorkResult;
+let Document$2 = document$2;
 let LazyResult$1 = lazyResult;
-let Document$1 = document$1;
-let Root$2 = root;
-let Processor$1 = class Processor {
+let NoWorkResult2 = noWorkResult;
+let Root$2 = root$1;
+let Processor$2 = class Processor {
   constructor(plugins = []) {
-    this.version = "8.4.38";
+    this.version = "8.5.1";
     this.plugins = this.normalize(plugins);
   }
   normalize(plugins) {
@@ -4941,88 +5046,40 @@ let Processor$1 = class Processor {
       return new LazyResult$1(this, css, opts);
     }
   }
-  use(plugin2) {
-    this.plugins = this.plugins.concat(this.normalize([plugin2]));
+  use(plugin3) {
+    this.plugins = this.plugins.concat(this.normalize([plugin3]));
     return this;
   }
 };
-var processor = Processor$1;
-Processor$1.default = Processor$1;
-Root$2.registerProcessor(Processor$1);
-Document$1.registerProcessor(Processor$1);
+var processor = Processor$2;
+Processor$2.default = Processor$2;
+Root$2.registerProcessor(Processor$2);
+Document$2.registerProcessor(Processor$2);
+let AtRule$1 = atRule$1;
+let Comment$2 = comment$1;
+let Container$1 = container;
+let CssSyntaxError$1 = cssSyntaxError;
 let Declaration$1 = declaration;
-let PreviousMap2 = previousMap;
-let Comment$1 = comment;
-let AtRule$1 = atRule;
-let Input$1 = input;
-let Root$1 = root;
-let Rule$1 = rule;
-function fromJSON$1(json, inputs) {
-  if (Array.isArray(json)) return json.map((n) => fromJSON$1(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$1.prototype });
-      if (inputHydrated.map) {
-        inputHydrated.map = __spreadProps(__spreadValues({}, inputHydrated.map), {
-          __proto__: PreviousMap2.prototype
-        });
-      }
-      inputs.push(inputHydrated);
-    }
-  }
-  if (defaults.nodes) {
-    defaults.nodes = json.nodes.map((n) => fromJSON$1(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$1(defaults);
-  } else if (defaults.type === "decl") {
-    return new Declaration$1(defaults);
-  } else if (defaults.type === "rule") {
-    return new Rule$1(defaults);
-  } else if (defaults.type === "comment") {
-    return new Comment$1(defaults);
-  } else if (defaults.type === "atrule") {
-    return new AtRule$1(defaults);
-  } else {
-    throw new Error("Unknown node type: " + json.type);
-  }
-}
-var fromJSON_1 = fromJSON$1;
-fromJSON$1.default = fromJSON$1;
-let CssSyntaxError2 = cssSyntaxError;
-let Declaration2 = declaration;
+let Document$1 = document$2;
+let fromJSON$1 = fromJSON_1;
+let Input$2 = input;
 let LazyResult2 = lazyResult;
-let Container2 = container;
-let Processor2 = processor;
-let stringify = stringify_1;
-let fromJSON = fromJSON_1;
-let Document2 = document$1;
-let Warning2 = warning;
-let Comment2 = comment;
-let AtRule2 = atRule;
-let Result2 = result;
-let Input2 = input;
-let parse = parse_1;
-let list = list_1;
-let Rule2 = rule;
-let Root2 = root;
-let Node2 = node;
-function postcss(...plugins) {
+let list$1 = list_1;
+let Node$1 = node;
+let parse$1 = parse_1;
+let Processor$1 = processor;
+let Result$1 = result;
+let Root$1 = root$1;
+let Rule$1 = rule$1;
+let stringify$1 = stringify_1;
+let Warning$1 = warning;
+function postcss$1(...plugins) {
   if (plugins.length === 1 && Array.isArray(plugins[0])) {
     plugins = plugins[0];
   }
-  return new Processor2(plugins);
+  return new Processor$1(plugins);
 }
-postcss.plugin = function plugin(name, initializer) {
+postcss$1.plugin = function plugin(name, initializer) {
   let warningPrinted = false;
   function creator(...args) {
     if (console && console.warn && !warningPrinted) {
@@ -5038,7 +5095,7 @@ postcss.plugin = function plugin(name, initializer) {
     }
     let transformer = initializer(...args);
     transformer.postcssPlugin = name;
-    transformer.postcssVersion = new Processor2().version;
+    transformer.postcssVersion = new Processor$1().version;
     return transformer;
   }
   let cache;
@@ -5049,61 +5106,181 @@ postcss.plugin = function plugin(name, initializer) {
     }
   });
   creator.process = function(css, processOpts, pluginOpts) {
-    return postcss([creator(pluginOpts)]).process(css, processOpts);
+    return postcss$1([creator(pluginOpts)]).process(css, processOpts);
   };
   return creator;
 };
-postcss.stringify = stringify;
-postcss.parse = parse;
-postcss.fromJSON = fromJSON;
-postcss.list = list;
-postcss.comment = (defaults) => new Comment2(defaults);
-postcss.atRule = (defaults) => new AtRule2(defaults);
-postcss.decl = (defaults) => new Declaration2(defaults);
-postcss.rule = (defaults) => new Rule2(defaults);
-postcss.root = (defaults) => new Root2(defaults);
-postcss.document = (defaults) => new Document2(defaults);
-postcss.CssSyntaxError = CssSyntaxError2;
-postcss.Declaration = Declaration2;
-postcss.Container = Container2;
-postcss.Processor = Processor2;
-postcss.Document = Document2;
-postcss.Comment = Comment2;
-postcss.Warning = Warning2;
-postcss.AtRule = AtRule2;
-postcss.Result = Result2;
-postcss.Input = Input2;
-postcss.Rule = Rule2;
-postcss.Root = Root2;
-postcss.Node = Node2;
-LazyResult2.registerPostcss(postcss);
-var postcss_1 = postcss;
-postcss.default = postcss;
-const postcss$1 = /* @__PURE__ */ getDefaultExportFromCjs(postcss_1);
-postcss$1.stringify;
-postcss$1.fromJSON;
-postcss$1.plugin;
-postcss$1.parse;
-postcss$1.list;
-postcss$1.document;
-postcss$1.comment;
-postcss$1.atRule;
-postcss$1.rule;
-postcss$1.decl;
-postcss$1.root;
-postcss$1.CssSyntaxError;
-postcss$1.Declaration;
-postcss$1.Container;
-postcss$1.Processor;
-postcss$1.Document;
-postcss$1.Comment;
-postcss$1.Warning;
-postcss$1.AtRule;
-postcss$1.Result;
-postcss$1.Input;
-postcss$1.Rule;
-postcss$1.Root;
-postcss$1.Node;
+postcss$1.stringify = stringify$1;
+postcss$1.parse = parse$1;
+postcss$1.fromJSON = fromJSON$1;
+postcss$1.list = list$1;
+postcss$1.comment = (defaults) => new Comment$2(defaults);
+postcss$1.atRule = (defaults) => new AtRule$1(defaults);
+postcss$1.decl = (defaults) => new Declaration$1(defaults);
+postcss$1.rule = (defaults) => new Rule$1(defaults);
+postcss$1.root = (defaults) => new Root$1(defaults);
+postcss$1.document = (defaults) => new Document$1(defaults);
+postcss$1.CssSyntaxError = CssSyntaxError$1;
+postcss$1.Declaration = Declaration$1;
+postcss$1.Container = Container$1;
+postcss$1.Processor = Processor$1;
+postcss$1.Document = Document$1;
+postcss$1.Comment = Comment$2;
+postcss$1.Warning = Warning$1;
+postcss$1.AtRule = AtRule$1;
+postcss$1.Result = Result$1;
+postcss$1.Input = Input$2;
+postcss$1.Rule = Rule$1;
+postcss$1.Root = Root$1;
+postcss$1.Node = Node$1;
+LazyResult2.registerPostcss(postcss$1);
+var postcss_1 = postcss$1;
+postcss$1.default = postcss$1;
+const postcss$2 = /* @__PURE__ */ getDefaultExportFromCjs(postcss_1);
+const stringify = postcss$2.stringify;
+const fromJSON = postcss$2.fromJSON;
+const plugin2 = postcss$2.plugin;
+const parse = postcss$2.parse;
+const list = postcss$2.list;
+const document$1 = postcss$2.document;
+const comment = postcss$2.comment;
+const atRule = postcss$2.atRule;
+const rule = postcss$2.rule;
+const decl = postcss$2.decl;
+const root = postcss$2.root;
+const CssSyntaxError2 = postcss$2.CssSyntaxError;
+const Declaration2 = postcss$2.Declaration;
+const Container2 = postcss$2.Container;
+const Processor2 = postcss$2.Processor;
+const Document2 = postcss$2.Document;
+const Comment$1 = postcss$2.Comment;
+const Warning2 = postcss$2.Warning;
+const AtRule2 = postcss$2.AtRule;
+const Result2 = postcss$2.Result;
+const Input$1 = postcss$2.Input;
+const Rule2 = postcss$2.Rule;
+const Root2 = postcss$2.Root;
+const Node2 = postcss$2.Node;
+const postcss = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AtRule: AtRule2,
+  Comment: Comment$1,
+  Container: Container2,
+  CssSyntaxError: CssSyntaxError2,
+  Declaration: Declaration2,
+  Document: Document2,
+  Input: Input$1,
+  Node: Node2,
+  Processor: Processor2,
+  Result: Result2,
+  Root: Root2,
+  Rule: Rule2,
+  Warning: Warning2,
+  atRule,
+  comment,
+  decl,
+  default: postcss$2,
+  document: document$1,
+  fromJSON,
+  list,
+  parse,
+  plugin: plugin2,
+  root,
+  rule,
+  stringify
+}, Symbol.toStringTag, { value: "Module" }));
+const require$$0 = /* @__PURE__ */ getAugmentedNamespace(postcss);
+let Comment2 = comment$1;
+let Parser2 = parser;
+let tokenizer2 = tokenize;
+let SafeParser$1 = class SafeParser extends Parser2 {
+  checkMissedSemicolon() {
+  }
+  comment(token) {
+    let node2 = new Comment2();
+    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 = tokenizer2(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 = "";
+  }
+};
+var safeParser$1 = SafeParser$1;
+let { Input: Input2 } = require$$0;
+let SafeParser2 = safeParser$1;
+var safeParse = function safeParse2(css, opts) {
+  let input2 = new Input2(css, opts);
+  let parser2 = new SafeParser2(input2);
+  parser2.parse();
+  return parser2.root;
+};
+const safeParser = /* @__PURE__ */ getDefaultExportFromCjs(safeParse);
 const tagMap = {
   script: "noscript",
   // camel case svg element tag names
@@ -5154,11 +5331,16 @@ function getTagName(n) {
 function adaptCssForReplay(cssText, cache) {
   const cachedStyle = cache == null ? void 0 : cache.stylesWithHoverClass.get(cssText);
   if (cachedStyle) return cachedStyle;
-  const ast = postcss$1([
-    mediaSelectorPlugin,
-    pseudoClassPlugin
-  ]).process(cssText);
-  const result2 = ast.css;
+  let result2 = cssText;
+  try {
+    const ast = postcss$2([
+      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;
 }