@betterbugs/rrdom-nodejs 2.0.0-alpha.19

package/dist/rrdom-nodejs.js

@@ -0,0 +1,4446 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp2 = Object.defineProperty;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+function getDefaultExportFromCjs(x2) {
+  return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
+}
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+  if (typeof f == "function") {
+    var a = function a2() {
+      if (this instanceof a2) {
+        return Reflect.construct(f, arguments, this.constructor);
+      }
+      return f.apply(this, arguments);
+    };
+    a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, "__esModule", { value: true });
+  Object.keys(n).forEach(function(k) {
+    var d = Object.getOwnPropertyDescriptor(n, k);
+    Object.defineProperty(a, k, d.get ? d : {
+      enumerable: true,
+      get: function() {
+        return n[k];
+      }
+    });
+  });
+  return a;
+}
+var picocolors_browser = { exports: {} };
+var 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 };
+};
+picocolors_browser.exports = create();
+picocolors_browser.exports.createColors = create;
+var picocolors_browserExports = picocolors_browser.exports;
+const __viteBrowserExternal = {};
+const __viteBrowserExternal$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: __viteBrowserExternal
+}, Symbol.toStringTag, { value: "Module" }));
+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) {
+    super(message);
+    this.name = "CssSyntaxError";
+    this.reason = message;
+    if (file) {
+      this.file = file;
+    }
+    if (source) {
+      this.source = source;
+    }
+    if (plugin2) {
+      this.plugin = plugin2;
+    }
+    if (typeof line !== "undefined" && typeof column !== "undefined") {
+      if (typeof line === "number") {
+        this.line = line;
+        this.column = column;
+      } else {
+        this.line = line.line;
+        this.column = line.column;
+        this.endLine = column.line;
+        this.endColumn = column.column;
+      }
+    }
+    this.setMessage();
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, CssSyntaxError);
+    }
+  }
+  setMessage() {
+    this.message = this.plugin ? this.plugin + ": " : "";
+    this.message += this.file ? this.file : "<css input>";
+    if (typeof this.line !== "undefined") {
+      this.message += ":" + this.line + ":" + this.column;
+    }
+    this.message += ": " + this.reason;
+  }
+  showSourceCode(color) {
+    if (!this.source) return "";
+    let css = this.source;
+    if (color == null) color = pico.isColorSupported;
+    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;
+    if (color) {
+      let { bold, gray, red } = pico.createColors(true);
+      mark = (text) => bold(red(text));
+      aside = (text) => gray(text);
+    } else {
+      mark = aside = (str) => str;
+    }
+    return lines.slice(start, end).map((line, index2) => {
+      let number = start + 1 + index2;
+      let gutter = " " + (" " + number).slice(-maxWidth) + " | ";
+      if (number === this.line) {
+        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 " " + aside(gutter) + line;
+    }).join("\n");
+  }
+  toString() {
+    let code = this.showSourceCode();
+    if (code) {
+      code = "\n\n" + code + "\n";
+    }
+    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");
+const DEFAULT_RAW = {
+  after: "\n",
+  beforeClose: "\n",
+  beforeComment: "\n",
+  beforeDecl: "\n",
+  beforeOpen: " ",
+  beforeRule: "\n",
+  colon: ": ",
+  commentLeft: " ",
+  commentRight: " ",
+  emptyBody: "",
+  indent: "    ",
+  semicolon: false
+};
+function capitalize(str) {
+  return str[0].toUpperCase() + str.slice(1);
+}
+let Stringifier$2 = class Stringifier {
+  constructor(builder) {
+    this.builder = builder;
+  }
+  atrule(node2, semicolon) {
+    let name = "@" + node2.name;
+    let params = node2.params ? this.rawValue(node2, "params") : "";
+    if (typeof node2.raws.afterName !== "undefined") {
+      name += node2.raws.afterName;
+    } else if (params) {
+      name += " ";
+    }
+    if (node2.nodes) {
+      this.block(node2, name + params);
+    } else {
+      let end = (node2.raws.between || "") + (semicolon ? ";" : "");
+      this.builder(name + params + end, node2);
+    }
+  }
+  beforeAfter(node2, detect) {
+    let value;
+    if (node2.type === "decl") {
+      value = this.raw(node2, null, "beforeDecl");
+    } else if (node2.type === "comment") {
+      value = this.raw(node2, null, "beforeComment");
+    } else if (detect === "before") {
+      value = this.raw(node2, null, "beforeRule");
+    } else {
+      value = this.raw(node2, null, "beforeClose");
+    }
+    let buf = node2.parent;
+    let depth = 0;
+    while (buf && buf.type !== "root") {
+      depth += 1;
+      buf = buf.parent;
+    }
+    if (value.includes("\n")) {
+      let indent = this.raw(node2, null, "indent");
+      if (indent.length) {
+        for (let step = 0; step < depth; step++) value += indent;
+      }
+    }
+    return value;
+  }
+  block(node2, start) {
+    let between = this.raw(node2, "between", "beforeOpen");
+    this.builder(start + between + "{", node2, "start");
+    let after;
+    if (node2.nodes && node2.nodes.length) {
+      this.body(node2);
+      after = this.raw(node2, "after");
+    } else {
+      after = this.raw(node2, "after", "emptyBody");
+    }
+    if (after) this.builder(after);
+    this.builder("}", node2, "end");
+  }
+  body(node2) {
+    let last = node2.nodes.length - 1;
+    while (last > 0) {
+      if (node2.nodes[last].type !== "comment") break;
+      last -= 1;
+    }
+    let semicolon = this.raw(node2, "semicolon");
+    for (let i = 0; i < node2.nodes.length; i++) {
+      let child = node2.nodes[i];
+      let before = this.raw(child, "before");
+      if (before) this.builder(before);
+      this.stringify(child, last !== i || semicolon);
+    }
+  }
+  comment(node2) {
+    let left = this.raw(node2, "left", "commentLeft");
+    let right = this.raw(node2, "right", "commentRight");
+    this.builder("/*" + left + node2.text + right + "*/", node2);
+  }
+  decl(node2, semicolon) {
+    let between = this.raw(node2, "between", "colon");
+    let string = node2.prop + between + this.rawValue(node2, "value");
+    if (node2.important) {
+      string += node2.raws.important || " !important";
+    }
+    if (semicolon) string += ";";
+    this.builder(string, node2);
+  }
+  document(node2) {
+    this.body(node2);
+  }
+  raw(node2, own, detect) {
+    let value;
+    if (!detect) detect = own;
+    if (own) {
+      value = node2.raws[own];
+      if (typeof value !== "undefined") return value;
+    }
+    let parent = node2.parent;
+    if (detect === "before") {
+      if (!parent || parent.type === "root" && parent.first === node2) {
+        return "";
+      }
+      if (parent && parent.type === "document") {
+        return "";
+      }
+    }
+    if (!parent) return DEFAULT_RAW[detect];
+    let root2 = node2.root();
+    if (!root2.rawCache) root2.rawCache = {};
+    if (typeof root2.rawCache[detect] !== "undefined") {
+      return root2.rawCache[detect];
+    }
+    if (detect === "before" || detect === "after") {
+      return this.beforeAfter(node2, detect);
+    } else {
+      let method = "raw" + capitalize(detect);
+      if (this[method]) {
+        value = this[method](root2, node2);
+      } else {
+        root2.walk((i) => {
+          value = i.raws[own];
+          if (typeof value !== "undefined") return false;
+        });
+      }
+    }
+    if (typeof value === "undefined") value = DEFAULT_RAW[detect];
+    root2.rawCache[detect] = value;
+    return value;
+  }
+  rawBeforeClose(root2) {
+    let value;
+    root2.walk((i) => {
+      if (i.nodes && i.nodes.length > 0) {
+        if (typeof i.raws.after !== "undefined") {
+          value = i.raws.after;
+          if (value.includes("\n")) {
+            value = value.replace(/[^\n]+$/, "");
+          }
+          return false;
+        }
+      }
+    });
+    if (value) value = value.replace(/\S/g, "");
+    return value;
+  }
+  rawBeforeComment(root2, node2) {
+    let value;
+    root2.walkComments((i) => {
+      if (typeof i.raws.before !== "undefined") {
+        value = i.raws.before;
+        if (value.includes("\n")) {
+          value = value.replace(/[^\n]+$/, "");
+        }
+        return false;
+      }
+    });
+    if (typeof value === "undefined") {
+      value = this.raw(node2, null, "beforeDecl");
+    } else if (value) {
+      value = value.replace(/\S/g, "");
+    }
+    return value;
+  }
+  rawBeforeDecl(root2, node2) {
+    let value;
+    root2.walkDecls((i) => {
+      if (typeof i.raws.before !== "undefined") {
+        value = i.raws.before;
+        if (value.includes("\n")) {
+          value = value.replace(/[^\n]+$/, "");
+        }
+        return false;
+      }
+    });
+    if (typeof value === "undefined") {
+      value = this.raw(node2, null, "beforeRule");
+    } else if (value) {
+      value = value.replace(/\S/g, "");
+    }
+    return value;
+  }
+  rawBeforeOpen(root2) {
+    let value;
+    root2.walk((i) => {
+      if (i.type !== "decl") {
+        value = i.raws.between;
+        if (typeof value !== "undefined") return false;
+      }
+    });
+    return value;
+  }
+  rawBeforeRule(root2) {
+    let value;
+    root2.walk((i) => {
+      if (i.nodes && (i.parent !== root2 || root2.first !== i)) {
+        if (typeof i.raws.before !== "undefined") {
+          value = i.raws.before;
+          if (value.includes("\n")) {
+            value = value.replace(/[^\n]+$/, "");
+          }
+          return false;
+        }
+      }
+    });
+    if (value) value = value.replace(/\S/g, "");
+    return value;
+  }
+  rawColon(root2) {
+    let value;
+    root2.walkDecls((i) => {
+      if (typeof i.raws.between !== "undefined") {
+        value = i.raws.between.replace(/[^\s:]/g, "");
+        return false;
+      }
+    });
+    return value;
+  }
+  rawEmptyBody(root2) {
+    let value;
+    root2.walk((i) => {
+      if (i.nodes && i.nodes.length === 0) {
+        value = i.raws.after;
+        if (typeof value !== "undefined") return false;
+      }
+    });
+    return value;
+  }
+  rawIndent(root2) {
+    if (root2.raws.indent) return root2.raws.indent;
+    let value;
+    root2.walk((i) => {
+      let p = i.parent;
+      if (p && p !== root2 && p.parent && p.parent === root2) {
+        if (typeof i.raws.before !== "undefined") {
+          let parts = i.raws.before.split("\n");
+          value = parts[parts.length - 1];
+          value = value.replace(/\S/g, "");
+          return false;
+        }
+      }
+    });
+    return value;
+  }
+  rawSemicolon(root2) {
+    let value;
+    root2.walk((i) => {
+      if (i.nodes && i.nodes.length && i.last.type === "decl") {
+        value = i.raws.semicolon;
+        if (typeof value !== "undefined") return false;
+      }
+    });
+    return value;
+  }
+  rawValue(node2, prop) {
+    let value = node2[prop];
+    let raw = node2.raws[prop];
+    if (raw && raw.value === value) {
+      return raw.raw;
+    }
+    return value;
+  }
+  root(node2) {
+    this.body(node2);
+    if (node2.raws.after) this.builder(node2.raws.after);
+  }
+  rule(node2) {
+    this.block(node2, this.rawValue(node2, "selector"));
+    if (node2.raws.ownSemicolon) {
+      this.builder(node2.raws.ownSemicolon, node2, "end");
+    }
+  }
+  stringify(node2, semicolon) {
+    if (!this[node2.type]) {
+      throw new Error(
+        "Unknown AST node type " + node2.type + ". Maybe you need to change PostCSS stringifier."
+      );
+    }
+    this[node2.type](node2, semicolon);
+  }
+};
+var stringifier = Stringifier$2;
+Stringifier$2.default = Stringifier$2;
+let Stringifier$1 = stringifier;
+function stringify$4(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;
+let Stringifier2 = stringifier;
+let stringify$3 = stringify_1;
+function cloneNode(obj, parent) {
+  let cloned = new obj.constructor();
+  for (let i in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, i)) {
+      continue;
+    }
+    if (i === "proxyCache") continue;
+    let value = obj[i];
+    let type = typeof value;
+    if (i === "parent" && type === "object") {
+      if (parent) cloned[i] = parent;
+    } else if (i === "source") {
+      cloned[i] = value;
+    } else if (Array.isArray(value)) {
+      cloned[i] = value.map((j) => cloneNode(j, cloned));
+    } else {
+      if (type === "object" && value !== null) value = cloneNode(value);
+      cloned[i] = value;
+    }
+  }
+  return cloned;
+}
+let Node$4 = class Node2 {
+  constructor(defaults = {}) {
+    this.raws = {};
+    this[isClean$2] = false;
+    this[my$2] = true;
+    for (let name in defaults) {
+      if (name === "nodes") {
+        this.nodes = [];
+        for (let node2 of defaults[name]) {
+          if (typeof node2.clone === "function") {
+            this.append(node2.clone());
+          } else {
+            this.append(node2);
+          }
+        }
+      } else {
+        this[name] = defaults[name];
+      }
+    }
+  }
+  addToError(error) {
+    error.postcssNode = this;
+    if (error.stack && this.source && /\n\s{4}at /.test(error.stack)) {
+      let s = this.source;
+      error.stack = error.stack.replace(
+        /\n\s{4}at /,
+        `$&${s.input.from}:${s.start.line}:${s.start.column}$&`
+      );
+    }
+    return error;
+  }
+  after(add) {
+    this.parent.insertAfter(this, add);
+    return this;
+  }
+  assign(overrides = {}) {
+    for (let name in overrides) {
+      this[name] = overrides[name];
+    }
+    return this;
+  }
+  before(add) {
+    this.parent.insertBefore(this, add);
+    return this;
+  }
+  cleanRaws(keepBetween) {
+    delete this.raws.before;
+    delete this.raws.after;
+    if (!keepBetween) delete this.raws.between;
+  }
+  clone(overrides = {}) {
+    let cloned = cloneNode(this);
+    for (let name in overrides) {
+      cloned[name] = overrides[name];
+    }
+    return cloned;
+  }
+  cloneAfter(overrides = {}) {
+    let cloned = this.clone(overrides);
+    this.parent.insertAfter(this, cloned);
+    return cloned;
+  }
+  cloneBefore(overrides = {}) {
+    let cloned = this.clone(overrides);
+    this.parent.insertBefore(this, cloned);
+    return cloned;
+  }
+  error(message, opts = {}) {
+    if (this.source) {
+      let { end, start } = this.rangeBy(opts);
+      return this.source.input.error(
+        message,
+        { column: start.column, line: start.line },
+        { column: end.column, line: end.line },
+        opts
+      );
+    }
+    return new CssSyntaxError$2(message);
+  }
+  getProxyProcessor() {
+    return {
+      get(node2, prop) {
+        if (prop === "proxyOf") {
+          return node2;
+        } else if (prop === "root") {
+          return () => node2.root().toProxy();
+        } else {
+          return node2[prop];
+        }
+      },
+      set(node2, prop, value) {
+        if (node2[prop] === value) return true;
+        node2[prop] = value;
+        if (prop === "prop" || prop === "value" || prop === "name" || prop === "params" || prop === "important" || /* c8 ignore next */
+        prop === "text") {
+          node2.markDirty();
+        }
+        return true;
+      }
+    };
+  }
+  markDirty() {
+    if (this[isClean$2]) {
+      this[isClean$2] = false;
+      let next = this;
+      while (next = next.parent) {
+        next[isClean$2] = false;
+      }
+    }
+  }
+  next() {
+    if (!this.parent) return void 0;
+    let index2 = this.parent.index(this);
+    return this.parent.nodes[index2 + 1];
+  }
+  positionBy(opts, stringRepresentation) {
+    let pos = this.source.start;
+    if (opts.index) {
+      pos = this.positionInside(opts.index, stringRepresentation);
+    } else if (opts.word) {
+      stringRepresentation = this.toString();
+      let index2 = stringRepresentation.indexOf(opts.word);
+      if (index2 !== -1) pos = this.positionInside(index2, stringRepresentation);
+    }
+    return pos;
+  }
+  positionInside(index2, stringRepresentation) {
+    let string = stringRepresentation || this.toString();
+    let column = this.source.start.column;
+    let line = this.source.start.line;
+    for (let i = 0; i < index2; i++) {
+      if (string[i] === "\n") {
+        column = 1;
+        line += 1;
+      } else {
+        column += 1;
+      }
+    }
+    return { column, line };
+  }
+  prev() {
+    if (!this.parent) return void 0;
+    let index2 = this.parent.index(this);
+    return this.parent.nodes[index2 - 1];
+  }
+  rangeBy(opts) {
+    let start = {
+      column: this.source.start.column,
+      line: this.source.start.line
+    };
+    let end = this.source.end ? {
+      column: this.source.end.column + 1,
+      line: this.source.end.line
+    } : {
+      column: start.column + 1,
+      line: start.line
+    };
+    if (opts.word) {
+      let stringRepresentation = this.toString();
+      let index2 = stringRepresentation.indexOf(opts.word);
+      if (index2 !== -1) {
+        start = this.positionInside(index2, stringRepresentation);
+        end = this.positionInside(index2 + opts.word.length, stringRepresentation);
+      }
+    } else {
+      if (opts.start) {
+        start = {
+          column: opts.start.column,
+          line: opts.start.line
+        };
+      } else if (opts.index) {
+        start = this.positionInside(opts.index);
+      }
+      if (opts.end) {
+        end = {
+          column: opts.end.column,
+          line: opts.end.line
+        };
+      } else if (typeof opts.endIndex === "number") {
+        end = this.positionInside(opts.endIndex);
+      } else if (opts.index) {
+        end = this.positionInside(opts.index + 1);
+      }
+    }
+    if (end.line < start.line || end.line === start.line && end.column <= start.column) {
+      end = { column: start.column + 1, line: start.line };
+    }
+    return { end, start };
+  }
+  raw(prop, defaultType) {
+    let str = new Stringifier2();
+    return str.raw(this, prop, defaultType);
+  }
+  remove() {
+    if (this.parent) {
+      this.parent.removeChild(this);
+    }
+    this.parent = void 0;
+    return this;
+  }
+  replaceWith(...nodes) {
+    if (this.parent) {
+      let bookmark = this;
+      let foundSelf = false;
+      for (let node2 of nodes) {
+        if (node2 === this) {
+          foundSelf = true;
+        } else if (foundSelf) {
+          this.parent.insertAfter(bookmark, node2);
+          bookmark = node2;
+        } else {
+          this.parent.insertBefore(bookmark, node2);
+        }
+      }
+      if (!foundSelf) {
+        this.remove();
+      }
+    }
+    return this;
+  }
+  root() {
+    let result2 = this;
+    while (result2.parent && result2.parent.type !== "document") {
+      result2 = result2.parent;
+    }
+    return result2;
+  }
+  toJSON(_, inputs) {
+    let fixed = {};
+    let emitInputs = inputs == null;
+    inputs = inputs || /* @__PURE__ */ new Map();
+    let inputsNextIndex = 0;
+    for (let name in this) {
+      if (!Object.prototype.hasOwnProperty.call(this, name)) {
+        continue;
+      }
+      if (name === "parent" || name === "proxyCache") continue;
+      let value = this[name];
+      if (Array.isArray(value)) {
+        fixed[name] = value.map((i) => {
+          if (typeof i === "object" && i.toJSON) {
+            return i.toJSON(null, inputs);
+          } else {
+            return i;
+          }
+        });
+      } else if (typeof value === "object" && value.toJSON) {
+        fixed[name] = value.toJSON(null, inputs);
+      } else if (name === "source") {
+        let inputId = inputs.get(value.input);
+        if (inputId == null) {
+          inputId = inputsNextIndex;
+          inputs.set(value.input, inputsNextIndex);
+          inputsNextIndex++;
+        }
+        fixed[name] = {
+          end: value.end,
+          inputId,
+          start: value.start
+        };
+      } else {
+        fixed[name] = value;
+      }
+    }
+    if (emitInputs) {
+      fixed.inputs = [...inputs.keys()].map((input2) => input2.toJSON());
+    }
+    return fixed;
+  }
+  toProxy() {
+    if (!this.proxyCache) {
+      this.proxyCache = new Proxy(this, this.getProxyProcessor());
+    }
+    return this.proxyCache;
+  }
+  toString(stringifier2 = stringify$3) {
+    if (stringifier2.stringify) stringifier2 = stringifier2.stringify;
+    let result2 = "";
+    stringifier2(this, (i) => {
+      result2 += i;
+    });
+    return result2;
+  }
+  warn(result2, text, opts) {
+    let data = { node: this };
+    for (let i in opts) data[i] = opts[i];
+    return result2.warn(text, data);
+  }
+  get proxyOf() {
+    return this;
+  }
+};
+var node = Node$4;
+Node$4.default = Node$4;
+let Node$3 = node;
+let Declaration$4 = class Declaration extends Node$3 {
+  constructor(defaults) {
+    if (defaults && typeof defaults.value !== "undefined" && typeof defaults.value !== "string") {
+      defaults = { ...defaults, value: String(defaults.value) };
+    }
+    super(defaults);
+    this.type = "decl";
+  }
+  get variable() {
+    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];
+    }
+    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;
+    }
+    if (this.mapFile) this.root = dirname$1(this.mapFile);
+    if (text) this.text = text;
+  }
+  consumer() {
+    if (!this.consumerCache) {
+      this.consumerCache = new SourceMapConsumer$2(this.text);
+    }
+    return this.consumerCache;
+  }
+  decodeInline(text) {
+    let baseCharsetUri = /^data:application\/json;charset=utf-?8;base64,/;
+    let baseUri = /^data:application\/json;base64,/;
+    let charsetUri = /^data:application\/json;charset=utf-?8,/;
+    let uri = /^data:application\/json,/;
+    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));
+    }
+    let encoding = text.match(/data:application\/json;([^,]+),/)[1];
+    throw new Error("Unsupported source map encoding " + encoding);
+  }
+  getAnnotationURL(sourceMapString) {
+    return sourceMapString.replace(/^\/\*\s*# sourceMappingURL=/, "").trim();
+  }
+  isMap(map) {
+    if (typeof map !== "object") return false;
+    return typeof map.mappings === "string" || typeof map._mappings === "string" || Array.isArray(map.sections);
+  }
+  loadAnnotation(css) {
+    let comments = css.match(/\/\*\s*# sourceMappingURL=/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));
+    }
+  }
+  loadFile(path) {
+    this.root = dirname$1(path);
+    if (existsSync(path)) {
+      this.mapFile = path;
+      return readFileSync(path, "utf-8").toString().trim();
+    }
+  }
+  loadMap(file, prev) {
+    if (prev === false) return false;
+    if (prev) {
+      if (typeof prev === "string") {
+        return prev;
+      } else if (typeof prev === "function") {
+        let prevPath = prev(file);
+        if (prevPath) {
+          let map = this.loadFile(prevPath);
+          if (!map) {
+            throw new Error(
+              "Unable to load previous source map: " + prevPath.toString()
+            );
+          }
+          return map;
+        }
+      } else if (prev instanceof SourceMapConsumer$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()
+        );
+      }
+    } 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;
+  }
+  withContent() {
+    return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
+  }
+};
+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`);
+    }
+    this.css = css.toString();
+    if (this.css[0] === "\uFEFF" || this.css[0] === "￾") {
+      this.hasBOM = true;
+      this.css = this.css.slice(1);
+    } else {
+      this.hasBOM = false;
+    }
+    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 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;
+      }
+      if (typeof end.offset === "number") {
+        let pos = this.fromOffset(end.offset);
+        endLine = pos.line;
+        endColumn = pos.col;
+      } else {
+        endLine = end.line;
+        endColumn = end.column;
+      }
+    } else if (!column) {
+      let pos = this.fromOffset(line);
+      line = pos.line;
+      column = pos.col;
+    }
+    let origin = this.origin(line, column, endLine, endColumn);
+    if (origin) {
+      result2 = new CssSyntaxError$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
+      );
+    }
+    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;
+  }
+  fromOffset(offset) {
+    let lastLine, lineToIndex;
+    if (!this[fromOffsetCache]) {
+      let lines = this.css.split("\n");
+      lineToIndex = new Array(lines.length);
+      let prevIndex = 0;
+      for (let i = 0, l = lines.length; i < l; i++) {
+        lineToIndex[i] = prevIndex;
+        prevIndex += lines[i].length + 1;
+      }
+      this[fromOffsetCache] = lineToIndex;
+    } else {
+      lineToIndex = this[fromOffsetCache];
+    }
+    lastLine = lineToIndex[lineToIndex.length - 1];
+    let min = 0;
+    if (offset >= lastLine) {
+      min = lineToIndex.length - 1;
+    } else {
+      let max = lineToIndex.length - 2;
+      let mid;
+      while (min < max) {
+        mid = min + (max - min >> 1);
+        if (offset < lineToIndex[mid]) {
+          max = mid - 1;
+        } else if (offset >= lineToIndex[mid + 1]) {
+          min = mid + 1;
+        } else {
+          min = mid;
+          break;
+        }
+      }
+    }
+    return {
+      col: offset - lineToIndex[min] + 1,
+      line: min + 1
+    };
+  }
+  mapResolve(file) {
+    if (/^\w+:\/\//.test(file)) {
+      return file;
+    }
+    return resolve$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 });
+    }
+    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)
+      );
+    }
+    let result2 = {
+      column: from.column,
+      endColumn: to && to.column,
+      endLine: to && to.line,
+      line: from.line,
+      url: fromUrl.toString()
+    };
+    if (fromUrl.protocol === "file:") {
+      if (fileURLToPath) {
+        result2.file = fileURLToPath(fromUrl);
+      } else {
+        throw new Error(`file: protocol is not available in this PostCSS build`);
+      }
+    }
+    let source = consumer.sourceContentFor(from.source);
+    if (source) result2.source = source;
+    return result2;
+  }
+  toJSON() {
+    let json = {};
+    for (let name of ["hasBOM", "css", "file", "id"]) {
+      if (this[name] != null) {
+        json[name] = this[name];
+      }
+    }
+    if (this.map) {
+      json.map = { ...this.map };
+      if (json.map.consumerCache) {
+        json.map.consumerCache = void 0;
+      }
+    }
+    return json;
+  }
+  get from() {
+    return this.file || this.id;
+  }
+};
+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();
+  }
+  addAnnotation() {
+    let content;
+    if (this.isInline()) {
+      content = "data:application/json;base64," + this.toBase64(this.map.toString());
+    } else if (typeof this.mapOpts.annotation === "string") {
+      content = this.mapOpts.annotation;
+    } else if (typeof this.mapOpts.annotation === "function") {
+      content = this.mapOpts.annotation(this.opts.to, this.root);
+    } else {
+      content = this.outputFile() + ".map";
+    }
+    let eol = "\n";
+    if (this.css.includes("\r\n")) eol = "\r\n";
+    this.css += eol + "/*# sourceMappingURL=" + content + " */";
+  }
+  applyPrevMaps() {
+    for (let prev of this.previous()) {
+      let from = this.toUrl(this.path(prev.file));
+      let root2 = prev.root || dirname(prev.file);
+      let map;
+      if (this.mapOpts.sourcesContent === false) {
+        map = new SourceMapConsumer(prev.text);
+        if (map.sourcesContent) {
+          map.sourcesContent = null;
+        }
+      } else {
+        map = prev.consumer();
+      }
+      this.map.applySourceMap(map, from, this.toUrl(this.path(root2)));
+    }
+  }
+  clearAnnotation() {
+    if (this.mapOpts.annotation === false) return;
+    if (this.root) {
+      let node2;
+      for (let i = this.root.nodes.length - 1; i >= 0; i--) {
+        node2 = this.root.nodes[i];
+        if (node2.type !== "comment") continue;
+        if (node2.text.indexOf("# sourceMappingURL=") === 0) {
+          this.root.removeChild(i);
+        }
+      }
+    } else if (this.css) {
+      this.css = this.css.replace(/\n*?\/\*#[\S\s]*?\*\/$/gm, "");
+    }
+  }
+  generate() {
+    this.clearAnnotation();
+    if (pathAvailable && sourceMapAvailable && this.isMap()) {
+      return this.generateMap();
+    } else {
+      let result2 = "";
+      this.stringify(this.root, (i) => {
+        result2 += i;
+      });
+      return [result2];
+    }
+  }
+  generateMap() {
+    if (this.root) {
+      this.generateString();
+    } else if (this.previous().length === 1) {
+      let prev = this.previous()[0].consumer();
+      prev.file = this.outputFile();
+      this.map = SourceMapGenerator.fromSourceMap(prev, {
+        ignoreInvalidMapping: true
+      });
+    } else {
+      this.map = new SourceMapGenerator({
+        file: this.outputFile(),
+        ignoreInvalidMapping: true
+      });
+      this.map.addMapping({
+        generated: { column: 0, line: 1 },
+        original: { column: 0, line: 1 },
+        source: this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>"
+      });
+    }
+    if (this.isSourcesContent()) this.setSourcesContent();
+    if (this.root && this.previous().length > 0) this.applyPrevMaps();
+    if (this.isAnnotation()) this.addAnnotation();
+    if (this.isInline()) {
+      return [this.css];
+    } else {
+      return [this.css, this.map];
+    }
+  }
+  generateString() {
+    this.css = "";
+    this.map = new SourceMapGenerator({
+      file: this.outputFile(),
+      ignoreInvalidMapping: true
+    });
+    let line = 1;
+    let column = 1;
+    let noSource = "<no source>";
+    let mapping = {
+      generated: { column: 0, line: 0 },
+      original: { column: 0, line: 0 },
+      source: ""
+    };
+    let 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);
+          }
+        }
+      }
+    });
+  }
+  isAnnotation() {
+    if (this.isInline()) {
+      return true;
+    }
+    if (typeof this.mapOpts.annotation !== "undefined") {
+      return this.mapOpts.annotation;
+    }
+    if (this.previous().length) {
+      return this.previous().some((i) => i.annotation);
+    }
+    return true;
+  }
+  isInline() {
+    if (typeof this.mapOpts.inline !== "undefined") {
+      return this.mapOpts.inline;
+    }
+    let annotation = this.mapOpts.annotation;
+    if (typeof annotation !== "undefined" && annotation !== true) {
+      return false;
+    }
+    if (this.previous().length) {
+      return this.previous().some((i) => i.inline);
+    }
+    return true;
+  }
+  isMap() {
+    if (typeof this.opts.map !== "undefined") {
+      return !!this.opts.map;
+    }
+    return this.previous().length > 0;
+  }
+  isSourcesContent() {
+    if (typeof this.mapOpts.sourcesContent !== "undefined") {
+      return this.mapOpts.sourcesContent;
+    }
+    if (this.previous().length) {
+      return this.previous().some((i) => i.withContent());
+    }
+    return true;
+  }
+  outputFile() {
+    if (this.opts.to) {
+      return this.path(this.opts.to);
+    } else if (this.opts.from) {
+      return this.path(this.opts.from);
+    } else {
+      return "to.css";
+    }
+  }
+  path(file) {
+    if (this.mapOpts.absolute) return file;
+    if (file.charCodeAt(0) === 60) return file;
+    if (/^\w+:\/\//.test(file)) return file;
+    let cached = this.memoizedPaths.get(file);
+    if (cached) return cached;
+    let from = this.opts.to ? dirname(this.opts.to) : ".";
+    if (typeof this.mapOpts.annotation === "string") {
+      from = dirname(resolve(from, this.mapOpts.annotation));
+    }
+    let path = relative(from, file);
+    this.memoizedPaths.set(file, path);
+    return path;
+  }
+  previous() {
+    if (!this.previousMaps) {
+      this.previousMaps = [];
+      if (this.root) {
+        this.root.walk((node2) => {
+          if (node2.source && node2.source.input.map) {
+            let map = node2.source.input.map;
+            if (!this.previousMaps.includes(map)) {
+              this.previousMaps.push(map);
+            }
+          }
+        });
+      } else {
+        let input2 = new Input$3(this.originalCSS, this.opts);
+        if (input2.map) this.previousMaps.push(input2.map);
+      }
+    }
+    return this.previousMaps;
+  }
+  setSourcesContent() {
+    let already = {};
+    if (this.root) {
+      this.root.walk((node2) => {
+        if (node2.source) {
+          let from = node2.source.input.from;
+          if (from && !already[from]) {
+            already[from] = true;
+            let fromUrl = this.usesFileUrls ? this.toFileUrl(from) : this.toUrl(this.path(from));
+            this.map.setSourceContent(fromUrl, node2.source.input.css);
+          }
+        }
+      });
+    } else if (this.css) {
+      let from = this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>";
+      this.map.setSourceContent(from, this.css);
+    }
+  }
+  sourcePath(node2) {
+    if (this.mapOpts.from) {
+      return this.toUrl(this.mapOpts.from);
+    } else if (this.usesFileUrls) {
+      return this.toFileUrl(node2.source.input.from);
+    } else {
+      return this.toUrl(this.path(node2.source.input.from));
+    }
+  }
+  toBase64(str) {
+    if (Buffer) {
+      return Buffer.from(str).toString("base64");
+    } else {
+      return window.btoa(unescape(encodeURIComponent(str)));
+    }
+  }
+  toFileUrl(path) {
+    let cached = this.memoizedFileURLs.get(path);
+    if (cached) return cached;
+    if (pathToFileURL) {
+      let fileURL = pathToFileURL(path).toString();
+      this.memoizedFileURLs.set(path, fileURL);
+      return fileURL;
+    } else {
+      throw new Error(
+        "`map.absolute` option is not available in this PostCSS build"
+      );
+    }
+  }
+  toUrl(path) {
+    let cached = this.memoizedURLs.get(path);
+    if (cached) return cached;
+    if (sep === "\\") {
+      path = path.replace(/\\/g, "/");
+    }
+    let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent);
+    this.memoizedURLs.set(path, url);
+    return url;
+  }
+};
+var mapGenerator = MapGenerator$2;
+let Node$2 = node;
+let Comment$4 = class Comment extends Node$2 {
+  constructor(defaults) {
+    super(defaults);
+    this.type = "comment";
+  }
+};
+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, Rule$4, AtRule$4, 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);
+    }
+  }
+}
+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);
+    }
+    this.markDirty();
+    return this;
+  }
+  cleanRaws(keepBetween) {
+    super.cleanRaws(keepBetween);
+    if (this.nodes) {
+      for (let node2 of this.nodes) node2.cleanRaws(keepBetween);
+    }
+  }
+  each(callback) {
+    if (!this.proxyOf.nodes) return void 0;
+    let iterator = this.getIterator();
+    let 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;
+    }
+    delete this.indexes[iterator];
+    return result2;
+  }
+  every(condition) {
+    return this.nodes.every(condition);
+  }
+  getIterator() {
+    if (!this.lastEach) this.lastEach = 0;
+    if (!this.indexes) this.indexes = {};
+    this.lastEach += 1;
+    let iterator = this.lastEach;
+    this.indexes[iterator] = 0;
+    return iterator;
+  }
+  getProxyProcessor() {
+    return {
+      get(node2, prop) {
+        if (prop === "proxyOf") {
+          return node2;
+        } else if (!node2[prop]) {
+          return node2[prop];
+        } else if (prop === "each" || typeof prop === "string" && prop.startsWith("walk")) {
+          return (...args) => {
+            return node2[prop](
+              ...args.map((i) => {
+                if (typeof i === "function") {
+                  return (child, 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();
+        } else {
+          return node2[prop];
+        }
+      },
+      set(node2, prop, value) {
+        if (node2[prop] === value) return true;
+        node2[prop] = value;
+        if (prop === "name" || prop === "params" || prop === "selector") {
+          node2.markDirty();
+        }
+        return true;
+      }
+    };
+  }
+  index(child) {
+    if (typeof child === "number") return child;
+    if (child.proxyOf) child = child.proxyOf;
+    return this.proxyOf.nodes.indexOf(child);
+  }
+  insertAfter(exist, add) {
+    let existIndex = this.index(exist);
+    let nodes = this.normalize(add, this.proxyOf.nodes[existIndex]).reverse();
+    existIndex = this.index(exist);
+    for (let node2 of nodes) this.proxyOf.nodes.splice(existIndex + 1, 0, node2);
+    let index2;
+    for (let id in this.indexes) {
+      index2 = this.indexes[id];
+      if (existIndex < index2) {
+        this.indexes[id] = index2 + nodes.length;
+      }
+    }
+    this.markDirty();
+    return this;
+  }
+  insertBefore(exist, add) {
+    let existIndex = this.index(exist);
+    let type = existIndex === 0 ? "prepend" : false;
+    let nodes = this.normalize(add, this.proxyOf.nodes[existIndex], type).reverse();
+    existIndex = this.index(exist);
+    for (let node2 of nodes) this.proxyOf.nodes.splice(existIndex, 0, node2);
+    let index2;
+    for (let id in this.indexes) {
+      index2 = this.indexes[id];
+      if (existIndex <= index2) {
+        this.indexes[id] = index2 + nodes.length;
+      }
+    }
+    this.markDirty();
+    return this;
+  }
+  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, "");
+        }
+      }
+      i.parent = this.proxyOf;
+      return i;
+    });
+    return processed;
+  }
+  prepend(...children) {
+    children = children.reverse();
+    for (let child of children) {
+      let nodes = this.normalize(child, this.first, "prepend").reverse();
+      for (let node2 of nodes) this.proxyOf.nodes.unshift(node2);
+      for (let id in this.indexes) {
+        this.indexes[id] = this.indexes[id] + nodes.length;
+      }
+    }
+    this.markDirty();
+    return this;
+  }
+  push(child) {
+    child.parent = this;
+    this.proxyOf.nodes.push(child);
+    return this;
+  }
+  removeAll() {
+    for (let node2 of this.proxyOf.nodes) node2.parent = void 0;
+    this.proxyOf.nodes = [];
+    this.markDirty();
+    return this;
+  }
+  removeChild(child) {
+    child = this.index(child);
+    this.proxyOf.nodes[child].parent = void 0;
+    this.proxyOf.nodes.splice(child, 1);
+    let index2;
+    for (let id in this.indexes) {
+      index2 = this.indexes[id];
+      if (index2 >= child) {
+        this.indexes[id] = index2 - 1;
+      }
+    }
+    this.markDirty();
+    return this;
+  }
+  replaceValues(pattern, opts, callback) {
+    if (!callback) {
+      callback = opts;
+      opts = {};
+    }
+    this.walkDecls((decl) => {
+      if (opts.props && !opts.props.includes(decl.prop)) return;
+      if (opts.fast && !decl.value.includes(opts.fast)) return;
+      decl.value = decl.value.replace(pattern, callback);
+    });
+    this.markDirty();
+    return this;
+  }
+  some(condition) {
+    return this.nodes.some(condition);
+  }
+  walk(callback) {
+    return this.each((child, i) => {
+      let result2;
+      try {
+        result2 = callback(child, i);
+      } catch (e) {
+        throw child.addToError(e);
+      }
+      if (result2 !== false && child.walk) {
+        result2 = child.walk(callback);
+      }
+      return result2;
+    });
+  }
+  walkAtRules(name, callback) {
+    if (!callback) {
+      callback = name;
+      return this.walk((child, i) => {
+        if (child.type === "atrule") {
+          return callback(child, i);
+        }
+      });
+    }
+    if (name instanceof RegExp) {
+      return this.walk((child, i) => {
+        if (child.type === "atrule" && name.test(child.name)) {
+          return callback(child, i);
+        }
+      });
+    }
+    return this.walk((child, i) => {
+      if (child.type === "atrule" && child.name === name) {
+        return callback(child, i);
+      }
+    });
+  }
+  walkComments(callback) {
+    return this.walk((child, i) => {
+      if (child.type === "comment") {
+        return callback(child, i);
+      }
+    });
+  }
+  walkDecls(prop, callback) {
+    if (!callback) {
+      callback = prop;
+      return this.walk((child, i) => {
+        if (child.type === "decl") {
+          return callback(child, i);
+        }
+      });
+    }
+    if (prop instanceof RegExp) {
+      return this.walk((child, i) => {
+        if (child.type === "decl" && prop.test(child.prop)) {
+          return callback(child, i);
+        }
+      });
+    }
+    return this.walk((child, i) => {
+      if (child.type === "decl" && child.prop === prop) {
+        return callback(child, i);
+      }
+    });
+  }
+  walkRules(selector, callback) {
+    if (!callback) {
+      callback = selector;
+      return this.walk((child, i) => {
+        if (child.type === "rule") {
+          return callback(child, i);
+        }
+      });
+    }
+    if (selector instanceof RegExp) {
+      return this.walk((child, i) => {
+        if (child.type === "rule" && selector.test(child.selector)) {
+          return callback(child, i);
+        }
+      });
+    }
+    return this.walk((child, i) => {
+      if (child.type === "rule" && child.selector === selector) {
+        return callback(child, i);
+      }
+    });
+  }
+  get first() {
+    if (!this.proxyOf.nodes) return void 0;
+    return this.proxyOf.nodes[0];
+  }
+  get last() {
+    if (!this.proxyOf.nodes) return void 0;
+    return this.proxyOf.nodes[this.proxyOf.nodes.length - 1];
+  }
+};
+Container$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, Processor$3;
+let Document$3 = class Document2 extends Container$6 {
+  constructor(defaults) {
+    super({ type: "document", ...defaults });
+    if (!this.nodes) {
+      this.nodes = [];
+    }
+  }
+  toResult(opts = {}) {
+    let lazy = new LazyResult$4(new Processor$3(), this, opts);
+    return lazy.stringify();
+  }
+};
+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);
+  }
+};
+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;
+    }
+    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$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;
+  }
+  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$1(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$3;
+Result$3.default = Result$3;
+const SINGLE_QUOTE = "'".charCodeAt(0);
+const DOUBLE_QUOTE = '"'.charCodeAt(0);
+const BACKSLASH = "\\".charCodeAt(0);
+const SLASH = "/".charCodeAt(0);
+const NEWLINE = "\n".charCodeAt(0);
+const SPACE = " ".charCodeAt(0);
+const FEED = "\f".charCodeAt(0);
+const TAB = "	".charCodeAt(0);
+const CR = "\r".charCodeAt(0);
+const OPEN_SQUARE = "[".charCodeAt(0);
+const CLOSE_SQUARE = "]".charCodeAt(0);
+const OPEN_PARENTHESES = "(".charCodeAt(0);
+const CLOSE_PARENTHESES = ")".charCodeAt(0);
+const OPEN_CURLY = "{".charCodeAt(0);
+const CLOSE_CURLY = "}".charCodeAt(0);
+const SEMICOLON = ";".charCodeAt(0);
+const ASTERISK = "*".charCodeAt(0);
+const COLON = ":".charCodeAt(0);
+const AT = "@".charCodeAt(0);
+const RE_AT_END = /[\t\n\f\r "#'()/;[\\\]{}]/g;
+const RE_WORD_END = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g;
+const RE_BAD_BRACKET = /.[\r\n"'(/\\]/;
+const RE_HEX_ESCAPE = /[\da-f]/i;
+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 length = css.length;
+  let pos = 0;
+  let buffer = [];
+  let returned = [];
+  function position() {
+    return pos;
+  }
+  function unclosed(what) {
+    throw input2.error("Unclosed " + what, pos);
+  }
+  function endOfFile() {
+    return returned.length === 0 && pos >= length;
+  }
+  function nextToken(opts) {
+    if (returned.length) return returned.pop();
+    if (pos >= length) return;
+    let ignoreUnclosed = opts ? opts.ignoreUnclosed : false;
+    code = css.charCodeAt(pos);
+    switch (code) {
+      case NEWLINE:
+      case SPACE:
+      case TAB:
+      case CR:
+      case FEED: {
+        next = pos;
+        do {
+          next += 1;
+          code = css.charCodeAt(next);
+        } while (code === SPACE || code === NEWLINE || code === TAB || code === CR || code === FEED);
+        currentToken = ["space", css.slice(pos, next)];
+        pos = next - 1;
+        break;
+      }
+      case OPEN_SQUARE:
+      case CLOSE_SQUARE:
+      case OPEN_CURLY:
+      case CLOSE_CURLY:
+      case COLON:
+      case SEMICOLON:
+      case CLOSE_PARENTHESES: {
+        let controlChar = String.fromCharCode(code);
+        currentToken = [controlChar, controlChar, pos];
+        break;
+      }
+      case OPEN_PARENTHESES: {
+        prev = buffer.length ? buffer.pop()[1] : "";
+        n = css.charCodeAt(pos + 1);
+        if (prev === "url" && n !== SINGLE_QUOTE && n !== DOUBLE_QUOTE && n !== SPACE && n !== NEWLINE && n !== TAB && n !== FEED && n !== CR) {
+          next = pos;
+          do {
+            escaped = false;
+            next = css.indexOf(")", next + 1);
+            if (next === -1) {
+              if (ignore || ignoreUnclosed) {
+                next = pos;
+                break;
+              } else {
+                unclosed("bracket");
+              }
+            }
+            escapePos = next;
+            while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
+              escapePos -= 1;
+              escaped = !escaped;
+            }
+          } while (escaped);
+          currentToken = ["brackets", css.slice(pos, next + 1), pos, next];
+          pos = next;
+        } else {
+          next = css.indexOf(")", pos + 1);
+          content = css.slice(pos, next + 1);
+          if (next === -1 || RE_BAD_BRACKET.test(content)) {
+            currentToken = ["(", "(", pos];
+          } else {
+            currentToken = ["brackets", content, pos, next];
+            pos = next;
+          }
+        }
+        break;
+      }
+      case SINGLE_QUOTE:
+      case DOUBLE_QUOTE: {
+        quote = code === SINGLE_QUOTE ? "'" : '"';
+        next = pos;
+        do {
+          escaped = false;
+          next = css.indexOf(quote, next + 1);
+          if (next === -1) {
+            if (ignore || ignoreUnclosed) {
+              next = pos + 1;
+              break;
+            } else {
+              unclosed("string");
+            }
+          }
+          escapePos = next;
+          while (css.charCodeAt(escapePos - 1) === BACKSLASH) {
+            escapePos -= 1;
+            escaped = !escaped;
+          }
+        } while (escaped);
+        currentToken = ["string", css.slice(pos, next + 1), pos, next];
+        pos = next;
+        break;
+      }
+      case AT: {
+        RE_AT_END.lastIndex = pos + 1;
+        RE_AT_END.test(css);
+        if (RE_AT_END.lastIndex === 0) {
+          next = css.length - 1;
+        } else {
+          next = RE_AT_END.lastIndex - 2;
+        }
+        currentToken = ["at-word", css.slice(pos, next + 1), pos, next];
+        pos = next;
+        break;
+      }
+      case BACKSLASH: {
+        next = pos;
+        escape = true;
+        while (css.charCodeAt(next + 1) === BACKSLASH) {
+          next += 1;
+          escape = !escape;
+        }
+        code = css.charCodeAt(next + 1);
+        if (escape && code !== SLASH && code !== SPACE && code !== NEWLINE && code !== TAB && code !== CR && code !== FEED) {
+          next += 1;
+          if (RE_HEX_ESCAPE.test(css.charAt(next))) {
+            while (RE_HEX_ESCAPE.test(css.charAt(next + 1))) {
+              next += 1;
+            }
+            if (css.charCodeAt(next + 1) === SPACE) {
+              next += 1;
+            }
+          }
+        }
+        currentToken = ["word", css.slice(pos, next + 1), pos, next];
+        pos = next;
+        break;
+      }
+      default: {
+        if (code === SLASH && css.charCodeAt(pos + 1) === ASTERISK) {
+          next = css.indexOf("*/", pos + 2) + 1;
+          if (next === 0) {
+            if (ignore || ignoreUnclosed) {
+              next = css.length;
+            } else {
+              unclosed("comment");
+            }
+          }
+          currentToken = ["comment", css.slice(pos, next + 1), pos, next];
+          pos = next;
+        } else {
+          RE_WORD_END.lastIndex = pos + 1;
+          RE_WORD_END.test(css);
+          if (RE_WORD_END.lastIndex === 0) {
+            next = css.length - 1;
+          } else {
+            next = RE_WORD_END.lastIndex - 2;
+          }
+          currentToken = ["word", css.slice(pos, next + 1), pos, next];
+          buffer.push(currentToken);
+          pos = next;
+        }
+        break;
+      }
+    }
+    pos++;
+    return currentToken;
+  }
+  function back(token) {
+    returned.push(token);
+  }
+  return {
+    back,
+    endOfFile,
+    nextToken,
+    position
+  };
+};
+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, 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;
+        }
+      } else if (letter === '"' || letter === "'") {
+        inQuote = true;
+        prevQuote = letter;
+      } else if (letter === "(") {
+        func += 1;
+      } else if (letter === ")") {
+        if (func > 0) func -= 1;
+      } else if (func === 0) {
+        if (separators.includes(letter)) split = true;
+      }
+      if (split) {
+        if (current !== "") array.push(current.trim());
+        current = "";
+        split = false;
+      } else {
+        current += letter;
+      }
+    }
+    if (last || current !== "") array.push(current.trim());
+    return array;
+  }
+};
+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);
+  }
+  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 = Rule$3;
+Rule$3.default = Rule$3;
+Container$3.registerRule(Rule$3);
+let Declaration$2 = declaration;
+let tokenizer2 = tokenize;
+let Comment$2 = comment;
+let AtRule$2 = atRule;
+let Root$4 = root;
+let Rule$2 = rule;
+const SAFE_COMMENT_NEIGHBOR = {
+  empty: true,
+  space: true
+};
+function findLastWithPosition(tokens) {
+  for (let i = tokens.length - 1; i >= 0; i--) {
+    let token = tokens[i];
+    let pos = token[3] || token[2];
+    if (pos) return pos;
+  }
+}
+let Parser$1 = class Parser {
+  constructor(input2) {
+    this.input = input2;
+    this.root = new Root$4();
+    this.current = this.root;
+    this.spaces = "";
+    this.semicolon = false;
+    this.createTokenizer();
+    this.root.source = { input: input2, start: { column: 1, line: 1, offset: 0 } };
+  }
+  atrule(token) {
+    let node2 = new AtRule$2();
+    node2.name = token[1].slice(1);
+    if (node2.name === "") {
+      this.unnamedAtrule(node2, token);
+    }
+    this.init(node2, token[2]);
+    let type;
+    let prev;
+    let shift;
+    let last = false;
+    let open = false;
+    let params = [];
+    let brackets = [];
+    while (!this.tokenizer.endOfFile()) {
+      token = this.tokenizer.nextToken();
+      type = token[0];
+      if (type === "(" || type === "[") {
+        brackets.push(type === "(" ? ")" : "]");
+      } else if (type === "{" && brackets.length > 0) {
+        brackets.push("}");
+      } else if (type === brackets[brackets.length - 1]) {
+        brackets.pop();
+      }
+      if (brackets.length === 0) {
+        if (type === ";") {
+          node2.source.end = this.getPosition(token[2]);
+          node2.source.end.offset++;
+          this.semicolon = true;
+          break;
+        } else if (type === "{") {
+          open = true;
+          break;
+        } else if (type === "}") {
+          if (params.length > 0) {
+            shift = params.length - 1;
+            prev = params[shift];
+            while (prev && prev[0] === "space") {
+              prev = params[--shift];
+            }
+            if (prev) {
+              node2.source.end = this.getPosition(prev[3] || prev[2]);
+              node2.source.end.offset++;
+            }
+          }
+          this.end(token);
+          break;
+        } else {
+          params.push(token);
+        }
+      } else {
+        params.push(token);
+      }
+      if (this.tokenizer.endOfFile()) {
+        last = true;
+        break;
+      }
+    }
+    node2.raws.between = this.spacesAndCommentsFromEnd(params);
+    if (params.length) {
+      node2.raws.afterName = this.spacesAndCommentsFromStart(params);
+      this.raw(node2, "params", params);
+      if (last) {
+        token = params[params.length - 1];
+        node2.source.end = this.getPosition(token[3] || token[2]);
+        node2.source.end.offset++;
+        this.spaces = node2.raws.between;
+        node2.raws.between = "";
+      }
+    } else {
+      node2.raws.afterName = "";
+      node2.params = "";
+    }
+    if (open) {
+      node2.nodes = [];
+      this.current = node2;
+    }
+  }
+  checkMissedSemicolon(tokens) {
+    let colon = this.colon(tokens);
+    if (colon === false) return;
+    let founded = 0;
+    let token;
+    for (let j = colon - 1; j >= 0; j--) {
+      token = tokens[j];
+      if (token[0] !== "space") {
+        founded += 1;
+        if (founded === 2) break;
+      }
+    }
+    throw this.input.error(
+      "Missed semicolon",
+      token[0] === "word" ? token[3] + 1 : token[2]
+    );
+  }
+  colon(tokens) {
+    let brackets = 0;
+    let token, type, prev;
+    for (let [i, element] of tokens.entries()) {
+      token = element;
+      type = token[0];
+      if (type === "(") {
+        brackets += 1;
+      }
+      if (type === ")") {
+        brackets -= 1;
+      }
+      if (brackets === 0 && type === ":") {
+        if (!prev) {
+          this.doubleColon(token);
+        } else if (prev[0] === "word" && prev[1] === "progid") {
+          continue;
+        } else {
+          return i;
+        }
+      }
+      prev = token;
+    }
+    return false;
+  }
+  comment(token) {
+    let node2 = new Comment$2();
+    this.init(node2, token[2]);
+    node2.source.end = this.getPosition(token[3] || token[2]);
+    node2.source.end.offset++;
+    let text = token[1].slice(2, -2);
+    if (/^\s*$/.test(text)) {
+      node2.text = "";
+      node2.raws.left = text;
+      node2.raws.right = "";
+    } else {
+      let match = text.match(/^(\s*)([^]*\S)(\s*)$/);
+      node2.text = match[2];
+      node2.raws.left = match[1];
+      node2.raws.right = match[3];
+    }
+  }
+  createTokenizer() {
+    this.tokenizer = tokenizer2(this.input);
+  }
+  decl(tokens, customProperty) {
+    let node2 = new Declaration$2();
+    this.init(node2, tokens[0][2]);
+    let last = tokens[tokens.length - 1];
+    if (last[0] === ";") {
+      this.semicolon = true;
+      tokens.pop();
+    }
+    node2.source.end = this.getPosition(
+      last[3] || last[2] || findLastWithPosition(tokens)
+    );
+    node2.source.end.offset++;
+    while (tokens[0][0] !== "word") {
+      if (tokens.length === 1) this.unknownWord(tokens);
+      node2.raws.before += tokens.shift()[1];
+    }
+    node2.source.start = this.getPosition(tokens[0][2]);
+    node2.prop = "";
+    while (tokens.length) {
+      let type = tokens[0][0];
+      if (type === ":" || type === "space" || type === "comment") {
+        break;
+      }
+      node2.prop += tokens.shift()[1];
+    }
+    node2.raws.between = "";
+    let token;
+    while (tokens.length) {
+      token = tokens.shift();
+      if (token[0] === ":") {
+        node2.raws.between += token[1];
+        break;
+      } else {
+        if (token[0] === "word" && /\w/.test(token[1])) {
+          this.unknownWord([token]);
+        }
+        node2.raws.between += token[1];
+      }
+    }
+    if (node2.prop[0] === "_" || node2.prop[0] === "*") {
+      node2.raws.before += node2.prop[0];
+      node2.prop = node2.prop.slice(1);
+    }
+    let firstSpaces = [];
+    let next;
+    while (tokens.length) {
+      next = tokens[0][0];
+      if (next !== "space" && next !== "comment") break;
+      firstSpaces.push(tokens.shift());
+    }
+    this.precheckMissedSemicolon(tokens);
+    for (let i = tokens.length - 1; i >= 0; i--) {
+      token = tokens[i];
+      if (token[1].toLowerCase() === "!important") {
+        node2.important = true;
+        let string = this.stringFrom(tokens, i);
+        string = this.spacesFromEnd(tokens) + string;
+        if (string !== " !important") node2.raws.important = string;
+        break;
+      } else if (token[1].toLowerCase() === "important") {
+        let cache = tokens.slice(0);
+        let str = "";
+        for (let j = i; j > 0; j--) {
+          let type = cache[j][0];
+          if (str.trim().indexOf("!") === 0 && type !== "space") {
+            break;
+          }
+          str = cache.pop()[1] + str;
+        }
+        if (str.trim().indexOf("!") === 0) {
+          node2.important = true;
+          node2.raws.important = str;
+          tokens = cache;
+        }
+      }
+      if (token[0] !== "space" && token[0] !== "comment") {
+        break;
+      }
+    }
+    let hasWord = tokens.some((i) => i[0] !== "space" && i[0] !== "comment");
+    if (hasWord) {
+      node2.raws.between += firstSpaces.map((i) => i[1]).join("");
+      firstSpaces = [];
+    }
+    this.raw(node2, "value", firstSpaces.concat(tokens), customProperty);
+    if (node2.value.includes(":") && !customProperty) {
+      this.checkMissedSemicolon(tokens);
+    }
+  }
+  doubleColon(token) {
+    throw this.input.error(
+      "Double colon",
+      { offset: token[2] },
+      { offset: token[2] + token[1].length }
+    );
+  }
+  emptyRule(token) {
+    let node2 = new Rule$2();
+    this.init(node2, token[2]);
+    node2.selector = "";
+    node2.raws.between = "";
+    this.current = node2;
+  }
+  end(token) {
+    if (this.current.nodes && this.current.nodes.length) {
+      this.current.raws.semicolon = this.semicolon;
+    }
+    this.semicolon = false;
+    this.current.raws.after = (this.current.raws.after || "") + this.spaces;
+    this.spaces = "";
+    if (this.current.parent) {
+      this.current.source.end = this.getPosition(token[2]);
+      this.current.source.end.offset++;
+      this.current = this.current.parent;
+    } else {
+      this.unexpectedClose(token);
+    }
+  }
+  endFile() {
+    if (this.current.parent) this.unclosedBlock();
+    if (this.current.nodes && this.current.nodes.length) {
+      this.current.raws.semicolon = this.semicolon;
+    }
+    this.current.raws.after = (this.current.raws.after || "") + this.spaces;
+    this.root.source.end = this.getPosition(this.tokenizer.position());
+  }
+  freeSemicolon(token) {
+    this.spaces += token[1];
+    if (this.current.nodes) {
+      let prev = this.current.nodes[this.current.nodes.length - 1];
+      if (prev && prev.type === "rule" && !prev.raws.ownSemicolon) {
+        prev.raws.ownSemicolon = this.spaces;
+        this.spaces = "";
+      }
+    }
+  }
+  // Helpers
+  getPosition(offset) {
+    let pos = this.input.fromOffset(offset);
+    return {
+      column: pos.col,
+      line: pos.line,
+      offset
+    };
+  }
+  init(node2, offset) {
+    this.current.push(node2);
+    node2.source = {
+      input: this.input,
+      start: this.getPosition(offset)
+    };
+    node2.raws.before = this.spaces;
+    this.spaces = "";
+    if (node2.type !== "comment") this.semicolon = false;
+  }
+  other(start) {
+    let end = false;
+    let type = null;
+    let colon = false;
+    let bracket = null;
+    let brackets = [];
+    let customProperty = start[1].startsWith("--");
+    let tokens = [];
+    let token = start;
+    while (token) {
+      type = token[0];
+      tokens.push(token);
+      if (type === "(" || type === "[") {
+        if (!bracket) bracket = token;
+        brackets.push(type === "(" ? ")" : "]");
+      } else if (customProperty && colon && type === "{") {
+        if (!bracket) bracket = token;
+        brackets.push("}");
+      } else if (brackets.length === 0) {
+        if (type === ";") {
+          if (colon) {
+            this.decl(tokens, customProperty);
+            return;
+          } else {
+            break;
+          }
+        } else if (type === "{") {
+          this.rule(tokens);
+          return;
+        } else if (type === "}") {
+          this.tokenizer.back(tokens.pop());
+          end = true;
+          break;
+        } else if (type === ":") {
+          colon = true;
+        }
+      } else if (type === brackets[brackets.length - 1]) {
+        brackets.pop();
+        if (brackets.length === 0) bracket = null;
+      }
+      token = this.tokenizer.nextToken();
+    }
+    if (this.tokenizer.endOfFile()) end = true;
+    if (brackets.length > 0) this.unclosedBracket(bracket);
+    if (end && colon) {
+      if (!customProperty) {
+        while (tokens.length) {
+          token = tokens[tokens.length - 1][0];
+          if (token !== "space" && token !== "comment") break;
+          this.tokenizer.back(tokens.pop());
+        }
+      }
+      this.decl(tokens, customProperty);
+    } else {
+      this.unknownWord(tokens);
+    }
+  }
+  parse() {
+    let token;
+    while (!this.tokenizer.endOfFile()) {
+      token = this.tokenizer.nextToken();
+      switch (token[0]) {
+        case "space":
+          this.spaces += token[1];
+          break;
+        case ";":
+          this.freeSemicolon(token);
+          break;
+        case "}":
+          this.end(token);
+          break;
+        case "comment":
+          this.comment(token);
+          break;
+        case "at-word":
+          this.atrule(token);
+          break;
+        case "{":
+          this.emptyRule(token);
+          break;
+        default:
+          this.other(token);
+          break;
+      }
+    }
+    this.endFile();
+  }
+  precheckMissedSemicolon() {
+  }
+  raw(node2, prop, tokens, customProperty) {
+    let token, type;
+    let length = tokens.length;
+    let value = "";
+    let clean = true;
+    let next, prev;
+    for (let i = 0; i < length; i += 1) {
+      token = tokens[i];
+      type = token[0];
+      if (type === "space" && i === length - 1 && !customProperty) {
+        clean = false;
+      } else if (type === "comment") {
+        prev = tokens[i - 1] ? tokens[i - 1][0] : "empty";
+        next = tokens[i + 1] ? tokens[i + 1][0] : "empty";
+        if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) {
+          if (value.slice(-1) === ",") {
+            clean = false;
+          } else {
+            value += token[1];
+          }
+        } else {
+          clean = false;
+        }
+      } else {
+        value += token[1];
+      }
+    }
+    if (!clean) {
+      let raw = tokens.reduce((all, i) => all + i[1], "");
+      node2.raws[prop] = { raw, value };
+    }
+    node2[prop] = value;
+  }
+  rule(tokens) {
+    tokens.pop();
+    let node2 = new Rule$2();
+    this.init(node2, tokens[0][2]);
+    node2.raws.between = this.spacesAndCommentsFromEnd(tokens);
+    this.raw(node2, "selector", tokens);
+    this.current = node2;
+  }
+  spacesAndCommentsFromEnd(tokens) {
+    let lastTokenType;
+    let spaces = "";
+    while (tokens.length) {
+      lastTokenType = tokens[tokens.length - 1][0];
+      if (lastTokenType !== "space" && lastTokenType !== "comment") break;
+      spaces = tokens.pop()[1] + spaces;
+    }
+    return spaces;
+  }
+  // Errors
+  spacesAndCommentsFromStart(tokens) {
+    let next;
+    let spaces = "";
+    while (tokens.length) {
+      next = tokens[0][0];
+      if (next !== "space" && next !== "comment") break;
+      spaces += tokens.shift()[1];
+    }
+    return spaces;
+  }
+  spacesFromEnd(tokens) {
+    let lastTokenType;
+    let spaces = "";
+    while (tokens.length) {
+      lastTokenType = tokens[tokens.length - 1][0];
+      if (lastTokenType !== "space") break;
+      spaces = tokens.pop()[1] + spaces;
+    }
+    return spaces;
+  }
+  stringFrom(tokens, from) {
+    let result2 = "";
+    for (let i = from; i < tokens.length; i++) {
+      result2 += tokens[i][1];
+    }
+    tokens.splice(from, tokens.length - from);
+    return result2;
+  }
+  unclosedBlock() {
+    let pos = this.current.source.start;
+    throw this.input.error("Unclosed block", pos.line, pos.column);
+  }
+  unclosedBracket(bracket) {
+    throw this.input.error(
+      "Unclosed bracket",
+      { offset: bracket[2] },
+      { offset: bracket[2] + 1 }
+    );
+  }
+  unexpectedClose(token) {
+    throw this.input.error(
+      "Unexpected }",
+      { offset: token[2] },
+      { offset: token[2] + 1 }
+    );
+  }
+  unknownWord(tokens) {
+    throw this.input.error(
+      "Unknown word",
+      { offset: tokens[0][2] },
+      { offset: tokens[0][2] + tokens[0][1].length }
+    );
+  }
+  unnamedAtrule(node2, token) {
+    throw this.input.error(
+      "At-rule without name",
+      { offset: token[2] },
+      { offset: token[2] + token[1].length }
+    );
+  }
+};
+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);
+  try {
+    parser2.parse();
+  } catch (e) {
+    if (process.env.NODE_ENV !== "production") {
+      if (e.name === "CssSyntaxError" && opts && opts.from) {
+        if (/\.scss$/i.test(opts.from)) {
+          e.message += "\nYou tried to parse SCSS with the standard CSS parser; try again with the postcss-scss parser";
+        } else if (/\.sass/i.test(opts.from)) {
+          e.message += "\nYou tried to parse Sass with the standard CSS parser; try again with the postcss-sass parser";
+        } else if (/\.less$/i.test(opts.from)) {
+          e.message += "\nYou tried to parse Less with the standard CSS parser; try again with the postcss-less parser";
+        }
+      }
+    }
+    throw e;
+  }
+  return parser2.root;
+}
+var parse_1 = parse$3;
+parse$3.default = parse$3;
+Container$2.registerParse(parse$3);
+let { isClean, my } = symbols;
+let MapGenerator$1 = mapGenerator;
+let stringify$2 = stringify_1;
+let Container$1 = container;
+let Document$2 = document$1;
+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",
+  decl: "Declaration",
+  document: "Document",
+  root: "Root",
+  rule: "Rule"
+};
+const PLUGIN_PROPS = {
+  AtRule: true,
+  AtRuleExit: true,
+  Comment: true,
+  CommentExit: true,
+  Declaration: true,
+  DeclarationExit: true,
+  Document: true,
+  DocumentExit: true,
+  Once: true,
+  OnceExit: true,
+  postcssPlugin: true,
+  prepare: true,
+  Root: true,
+  RootExit: true,
+  Rule: true,
+  RuleExit: true
+};
+const NOT_VISITORS = {
+  Once: true,
+  postcssPlugin: true,
+  prepare: true
+};
+const CHILDREN = 0;
+function isPromise(obj) {
+  return typeof obj === "object" && typeof obj.then === "function";
+}
+function getEvents(node2) {
+  let key = false;
+  let type = TYPE_TO_CLASS_NAME[node2.type];
+  if (node2.type === "decl") {
+    key = node2.prop.toLowerCase();
+  } else if (node2.type === "atrule") {
+    key = node2.name.toLowerCase();
+  }
+  if (key && node2.append) {
+    return [
+      type,
+      type + "-" + key,
+      CHILDREN,
+      type + "Exit",
+      type + "Exit-" + key
+    ];
+  } else if (key) {
+    return [type, type + "-" + key, type + "Exit", type + "Exit-" + key];
+  } else if (node2.append) {
+    return [type, CHILDREN, type + "Exit"];
+  } else {
+    return [type, type + "Exit"];
+  }
+}
+function toStack(node2) {
+  let events;
+  if (node2.type === "document") {
+    events = ["Document", CHILDREN, "DocumentExit"];
+  } else if (node2.type === "root") {
+    events = ["Root", CHILDREN, "RootExit"];
+  } else {
+    events = getEvents(node2);
+  }
+  return {
+    eventIndex: 0,
+    events,
+    iterator: 0,
+    node: node2,
+    visitorIndex: 0,
+    visitors: []
+  };
+}
+function cleanMarks(node2) {
+  node2[isClean] = false;
+  if (node2.nodes) node2.nodes.forEach((i) => cleanMarks(i));
+  return node2;
+}
+let postcss$2 = {};
+let LazyResult$2 = class LazyResult {
+  constructor(processor2, css, opts) {
+    this.stringified = false;
+    this.processed = false;
+    let root2;
+    if (typeof css === "object" && css !== null && (css.type === "root" || css.type === "document")) {
+      root2 = cleanMarks(css);
+    } else if (css instanceof LazyResult || css instanceof Result$2) {
+      root2 = cleanMarks(css.root);
+      if (css.map) {
+        if (typeof opts.map === "undefined") opts.map = {};
+        if (!opts.map.inline) opts.map.inline = false;
+        opts.map.prev = css.map;
+      }
+    } else {
+      let parser2 = parse$2;
+      if (opts.syntax) parser2 = opts.syntax.parse;
+      if (opts.parser) parser2 = opts.parser;
+      if (parser2.parse) parser2 = parser2.parse;
+      try {
+        root2 = parser2(css, opts);
+      } catch (error) {
+        this.processed = true;
+        this.error = error;
+      }
+      if (root2 && !root2[my]) {
+        Container$1.rebuild(root2);
+      }
+    }
+    this.result = new Result$2(processor2, root2, opts);
+    this.helpers = { ...postcss$2, postcss: postcss$2, result: this.result };
+    this.plugins = this.processor.plugins.map((plugin2) => {
+      if (typeof plugin2 === "object" && plugin2.prepare) {
+        return { ...plugin2, ...plugin2.prepare(this.result) };
+      } else {
+        return plugin2;
+      }
+    });
+  }
+  async() {
+    if (this.error) return Promise.reject(this.error);
+    if (this.processed) return Promise.resolve(this.result);
+    if (!this.processing) {
+      this.processing = this.runAsync();
+    }
+    return this.processing;
+  }
+  catch(onRejected) {
+    return this.async().catch(onRejected);
+  }
+  finally(onFinally) {
+    return this.async().then(onFinally, onFinally);
+  }
+  getAsyncError() {
+    throw new Error("Use process(css).then(cb) to work with async plugins");
+  }
+  handleError(error, node2) {
+    let plugin2 = this.result.lastPlugin;
+    try {
+      if (node2) node2.addToError(error);
+      this.error = error;
+      if (error.name === "CssSyntaxError" && !error.plugin) {
+        error.plugin = plugin2.postcssPlugin;
+        error.setMessage();
+      } else if (plugin2.postcssVersion) {
+        if (process.env.NODE_ENV !== "production") {
+          let pluginName = plugin2.postcssPlugin;
+          let pluginVer = plugin2.postcssVersion;
+          let runtimeVer = this.result.processor.version;
+          let a = pluginVer.split(".");
+          let b = runtimeVer.split(".");
+          if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {
+            console.error(
+              "Unknown error from PostCSS plugin. Your current PostCSS version is " + runtimeVer + ", but " + pluginName + " uses " + pluginVer + ". Perhaps this is the source of the error below."
+            );
+          }
+        }
+      }
+    } catch (err) {
+      if (console && console.error) console.error(err);
+    }
+    return error;
+  }
+  prepareVisitors() {
+    this.listeners = {};
+    let add = (plugin2, type, cb) => {
+      if (!this.listeners[type]) this.listeners[type] = [];
+      this.listeners[type].push([plugin2, cb]);
+    };
+    for (let plugin2 of this.plugins) {
+      if (typeof plugin2 === "object") {
+        for (let event in plugin2) {
+          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).`
+            );
+          }
+          if (!NOT_VISITORS[event]) {
+            if (typeof plugin2[event] === "object") {
+              for (let filter in plugin2[event]) {
+                if (filter === "*") {
+                  add(plugin2, event, plugin2[event][filter]);
+                } else {
+                  add(
+                    plugin2,
+                    event + "-" + filter.toLowerCase(),
+                    plugin2[event][filter]
+                  );
+                }
+              }
+            } else if (typeof plugin2[event] === "function") {
+              add(plugin2, event, plugin2[event]);
+            }
+          }
+        }
+      }
+    }
+    this.hasListener = Object.keys(this.listeners).length > 0;
+  }
+  async runAsync() {
+    this.plugin = 0;
+    for (let i = 0; i < this.plugins.length; i++) {
+      let plugin2 = this.plugins[i];
+      let promise = this.runOnRoot(plugin2);
+      if (isPromise(promise)) {
+        try {
+          await promise;
+        } catch (error) {
+          throw this.handleError(error);
+        }
+      }
+    }
+    this.prepareVisitors();
+    if (this.hasListener) {
+      let root2 = this.result.root;
+      while (!root2[isClean]) {
+        root2[isClean] = true;
+        let stack = [toStack(root2)];
+        while (stack.length > 0) {
+          let promise = this.visitTick(stack);
+          if (isPromise(promise)) {
+            try {
+              await promise;
+            } catch (e) {
+              let node2 = stack[stack.length - 1].node;
+              throw this.handleError(e, node2);
+            }
+          }
+        }
+      }
+      if (this.listeners.OnceExit) {
+        for (let [plugin2, visitor] of this.listeners.OnceExit) {
+          this.result.lastPlugin = plugin2;
+          try {
+            if (root2.type === "document") {
+              let roots = root2.nodes.map(
+                (subRoot) => visitor(subRoot, this.helpers)
+              );
+              await Promise.all(roots);
+            } else {
+              await visitor(root2, this.helpers);
+            }
+          } catch (e) {
+            throw this.handleError(e);
+          }
+        }
+      }
+    }
+    this.processed = true;
+    return this.stringify();
+  }
+  runOnRoot(plugin2) {
+    this.result.lastPlugin = plugin2;
+    try {
+      if (typeof plugin2 === "object" && plugin2.Once) {
+        if (this.result.root.type === "document") {
+          let roots = this.result.root.nodes.map(
+            (root2) => plugin2.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);
+      }
+    } catch (error) {
+      throw this.handleError(error);
+    }
+  }
+  stringify() {
+    if (this.error) throw this.error;
+    if (this.stringified) return this.result;
+    this.stringified = true;
+    this.sync();
+    let opts = this.result.opts;
+    let str = stringify$2;
+    if (opts.syntax) str = opts.syntax.stringify;
+    if (opts.stringifier) str = opts.stringifier;
+    if (str.stringify) str = str.stringify;
+    let map = new MapGenerator$1(str, this.result.root, this.result.opts);
+    let data = map.generate();
+    this.result.css = data[0];
+    this.result.map = data[1];
+    return this.result;
+  }
+  sync() {
+    if (this.error) throw this.error;
+    if (this.processed) return this.result;
+    this.processed = true;
+    if (this.processing) {
+      throw this.getAsyncError();
+    }
+    for (let plugin2 of this.plugins) {
+      let promise = this.runOnRoot(plugin2);
+      if (isPromise(promise)) {
+        throw this.getAsyncError();
+      }
+    }
+    this.prepareVisitors();
+    if (this.hasListener) {
+      let root2 = this.result.root;
+      while (!root2[isClean]) {
+        root2[isClean] = true;
+        this.walkSync(root2);
+      }
+      if (this.listeners.OnceExit) {
+        if (root2.type === "document") {
+          for (let subRoot of root2.nodes) {
+            this.visitSync(this.listeners.OnceExit, subRoot);
+          }
+        } else {
+          this.visitSync(this.listeners.OnceExit, root2);
+        }
+      }
+    }
+    return this.result;
+  }
+  then(onFulfilled, onRejected) {
+    if (process.env.NODE_ENV !== "production") {
+      if (!("from" in this.opts)) {
+        warnOnce$1(
+          "Without `from` option PostCSS could generate wrong source map and will not find Browserslist config. Set it to CSS file path or to `undefined` to prevent this warning."
+        );
+      }
+    }
+    return this.async().then(onFulfilled, onRejected);
+  }
+  toString() {
+    return this.css;
+  }
+  visitSync(visitors, node2) {
+    for (let [plugin2, visitor] of visitors) {
+      this.result.lastPlugin = plugin2;
+      let promise;
+      try {
+        promise = visitor(node2, this.helpers);
+      } catch (e) {
+        throw this.handleError(e, node2.proxyOf);
+      }
+      if (node2.type !== "root" && node2.type !== "document" && !node2.parent) {
+        return true;
+      }
+      if (isPromise(promise)) {
+        throw this.getAsyncError();
+      }
+    }
+  }
+  visitTick(stack) {
+    let visit2 = stack[stack.length - 1];
+    let { node: node2, visitors } = visit2;
+    if (node2.type !== "root" && node2.type !== "document" && !node2.parent) {
+      stack.pop();
+      return;
+    }
+    if (visitors.length > 0 && visit2.visitorIndex < visitors.length) {
+      let [plugin2, visitor] = visitors[visit2.visitorIndex];
+      visit2.visitorIndex += 1;
+      if (visit2.visitorIndex === visitors.length) {
+        visit2.visitors = [];
+        visit2.visitorIndex = 0;
+      }
+      this.result.lastPlugin = plugin2;
+      try {
+        return visitor(node2.toProxy(), this.helpers);
+      } catch (e) {
+        throw this.handleError(e, node2);
+      }
+    }
+    if (visit2.iterator !== 0) {
+      let iterator = visit2.iterator;
+      let child;
+      while (child = node2.nodes[node2.indexes[iterator]]) {
+        node2.indexes[iterator] += 1;
+        if (!child[isClean]) {
+          child[isClean] = true;
+          stack.push(toStack(child));
+          return;
+        }
+      }
+      visit2.iterator = 0;
+      delete node2.indexes[iterator];
+    }
+    let events = visit2.events;
+    while (visit2.eventIndex < events.length) {
+      let event = events[visit2.eventIndex];
+      visit2.eventIndex += 1;
+      if (event === CHILDREN) {
+        if (node2.nodes && node2.nodes.length) {
+          node2[isClean] = true;
+          visit2.iterator = node2.getIterator();
+        }
+        return;
+      } else if (this.listeners[event]) {
+        visit2.visitors = this.listeners[event];
+        return;
+      }
+    }
+    stack.pop();
+  }
+  walkSync(node2) {
+    node2[isClean] = true;
+    let events = getEvents(node2);
+    for (let event of events) {
+      if (event === CHILDREN) {
+        if (node2.nodes) {
+          node2.each((child) => {
+            if (!child[isClean]) this.walkSync(child);
+          });
+        }
+      } else {
+        let visitors = this.listeners[event];
+        if (visitors) {
+          if (this.visitSync(visitors, node2.toProxy())) return;
+        }
+      }
+    }
+  }
+  warnings() {
+    return this.sync().warnings();
+  }
+  get content() {
+    return this.stringify().content;
+  }
+  get css() {
+    return this.stringify().css;
+  }
+  get map() {
+    return this.stringify().map;
+  }
+  get messages() {
+    return this.sync().messages;
+  }
+  get opts() {
+    return this.result.opts;
+  }
+  get processor() {
+    return this.result.processor;
+  }
+  get root() {
+    return this.sync().root;
+  }
+  get [Symbol.toStringTag]() {
+    return "LazyResult";
+  }
+};
+LazyResult$2.registerPostcss = (dependant) => {
+  postcss$2 = dependant;
+};
+var lazyResult = LazyResult$2;
+LazyResult$2.default = LazyResult$2;
+Root$3.registerLazyResult(LazyResult$2);
+Document$2.registerLazyResult(LazyResult$2);
+let MapGenerator2 = mapGenerator;
+let stringify$1 = 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();
+    this.stringified = false;
+    this._processor = processor2;
+    this._css = css;
+    this._opts = opts;
+    this._map = void 0;
+    let root2;
+    let str = stringify$1;
+    this.result = new Result$1(this._processor, root2, this._opts);
+    this.result.css = css;
+    let self = this;
+    Object.defineProperty(this.result, "root", {
+      get() {
+        return self.root;
+      }
+    });
+    let map = new MapGenerator2(str, root2, this._opts, css);
+    if (map.isMap()) {
+      let [generatedCSS, generatedMap] = map.generate();
+      if (generatedCSS) {
+        this.result.css = generatedCSS;
+      }
+      if (generatedMap) {
+        this.result.map = generatedMap;
+      }
+    } else {
+      map.clearAnnotation();
+      this.result.css = map.css;
+    }
+  }
+  async() {
+    if (this.error) return Promise.reject(this.error);
+    return Promise.resolve(this.result);
+  }
+  catch(onRejected) {
+    return this.async().catch(onRejected);
+  }
+  finally(onFinally) {
+    return this.async().then(onFinally, onFinally);
+  }
+  sync() {
+    if (this.error) throw this.error;
+    return this.result;
+  }
+  then(onFulfilled, onRejected) {
+    if (process.env.NODE_ENV !== "production") {
+      if (!("from" in this._opts)) {
+        warnOnce2(
+          "Without `from` option PostCSS could generate wrong source map and will not find Browserslist config. Set it to CSS file path or to `undefined` to prevent this warning."
+        );
+      }
+    }
+    return this.async().then(onFulfilled, onRejected);
+  }
+  toString() {
+    return this._css;
+  }
+  warnings() {
+    return [];
+  }
+  get content() {
+    return this.result.css;
+  }
+  get css() {
+    return this.result.css;
+  }
+  get map() {
+    return this.result.map;
+  }
+  get messages() {
+    return [];
+  }
+  get opts() {
+    return this.result.opts;
+  }
+  get processor() {
+    return this.result.processor;
+  }
+  get root() {
+    if (this._root) {
+      return this._root;
+    }
+    let root2;
+    let parser2 = parse$1;
+    try {
+      root2 = parser2(this._css, this._opts);
+    } catch (error) {
+      this.error = error;
+    }
+    if (this.error) {
+      throw this.error;
+    } else {
+      this._root = root2;
+      return root2;
+    }
+  }
+  get [Symbol.toStringTag]() {
+    return "NoWorkResult";
+  }
+};
+var noWorkResult = NoWorkResult$1;
+NoWorkResult$1.default = NoWorkResult$1;
+let NoWorkResult2 = noWorkResult;
+let LazyResult$1 = lazyResult;
+let Document$1 = document$1;
+let Root$2 = root;
+let Processor$1 = class Processor {
+  constructor(plugins = []) {
+    this.version = "8.4.38";
+    this.plugins = this.normalize(plugins);
+  }
+  normalize(plugins) {
+    let normalized = [];
+    for (let i of plugins) {
+      if (i.postcss === true) {
+        i = i();
+      } else if (i.postcss) {
+        i = i.postcss;
+      }
+      if (typeof i === "object" && Array.isArray(i.plugins)) {
+        normalized = normalized.concat(i.plugins);
+      } else if (typeof i === "object" && i.postcssPlugin) {
+        normalized.push(i);
+      } else if (typeof i === "function") {
+        normalized.push(i);
+      } else if (typeof i === "object" && (i.parse || i.stringify)) {
+        if (process.env.NODE_ENV !== "production") {
+          throw new Error(
+            "PostCSS syntaxes cannot be used as plugins. Instead, please use one of the syntax/parser/stringifier options as outlined in your PostCSS runner documentation."
+          );
+        }
+      } else {
+        throw new Error(i + " is not a PostCSS plugin");
+      }
+    }
+    return normalized;
+  }
+  process(css, opts = {}) {
+    if (!this.plugins.length && !opts.parser && !opts.stringifier && !opts.syntax) {
+      return new NoWorkResult2(this, css, opts);
+    } else {
+      return new LazyResult$1(this, css, opts);
+    }
+  }
+  use(plugin2) {
+    this.plugins = this.plugins.concat(this.normalize([plugin2]));
+    return this;
+  }
+};
+var processor = Processor$1;
+Processor$1.default = Processor$1;
+Root$2.registerProcessor(Processor$1);
+Document$1.registerProcessor(Processor$1);
+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 { inputs: ownInputs, ...defaults } = json;
+  if (ownInputs) {
+    inputs = [];
+    for (let input2 of ownInputs) {
+      let inputHydrated = { ...input2, __proto__: Input$1.prototype };
+      if (inputHydrated.map) {
+        inputHydrated.map = {
+          ...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 { inputId, ...source } = defaults.source;
+    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 LazyResult2 = lazyResult;
+let Container2 = container;
+let Processor2 = processor;
+let stringify = stringify_1;
+let fromJSON = fromJSON_1;
+let Document22 = 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 Node22 = node;
+function postcss(...plugins) {
+  if (plugins.length === 1 && Array.isArray(plugins[0])) {
+    plugins = plugins[0];
+  }
+  return new Processor2(plugins);
+}
+postcss.plugin = function plugin(name, initializer) {
+  let warningPrinted = false;
+  function creator(...args) {
+    if (console && console.warn && !warningPrinted) {
+      warningPrinted = true;
+      console.warn(
+        name + ": postcss.plugin was deprecated. Migration guide:\nhttps://evilmartians.com/chronicles/postcss-8-plugin-migration"
+      );
+      if (process.env.LANG && process.env.LANG.startsWith("cn")) {
+        console.warn(
+          name + ": 里面 postcss.plugin 被弃用. 迁移指南:\nhttps://www.w3ctech.com/topic/2226"
+        );
+      }
+    }
+    let transformer = initializer(...args);
+    transformer.postcssPlugin = name;
+    transformer.postcssVersion = new Processor2().version;
+    return transformer;
+  }
+  let cache;
+  Object.defineProperty(creator, "postcss", {
+    get() {
+      if (!cache) cache = creator();
+      return cache;
+    }
+  });
+  creator.process = function(css, processOpts, pluginOpts) {
+    return postcss([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 Document22(defaults);
+postcss.CssSyntaxError = CssSyntaxError2;
+postcss.Declaration = Declaration2;
+postcss.Container = Container2;
+postcss.Processor = Processor2;
+postcss.Document = Document22;
+postcss.Comment = Comment2;
+postcss.Warning = Warning2;
+postcss.AtRule = AtRule2;
+postcss.Result = Result2;
+postcss.Input = Input2;
+postcss.Rule = Rule2;
+postcss.Root = Root2;
+postcss.Node = Node22;
+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;
+var NodeType$1 = /* @__PURE__ */ ((NodeType2) => {
+  NodeType2[NodeType2["Document"] = 0] = "Document";
+  NodeType2[NodeType2["DocumentType"] = 1] = "DocumentType";
+  NodeType2[NodeType2["Element"] = 2] = "Element";
+  NodeType2[NodeType2["Text"] = 3] = "Text";
+  NodeType2[NodeType2["CDATA"] = 4] = "CDATA";
+  NodeType2[NodeType2["Comment"] = 5] = "Comment";
+  return NodeType2;
+})(NodeType$1 || {});
+function parseCSSText(cssText) {
+  const res = {};
+  const listDelimiter = /;(?![^(]*\))/g;
+  const propertyDelimiter = /:(.+)/;
+  const comment2 = /\/\*.*?\*\//g;
+  cssText.replace(comment2, "").split(listDelimiter).forEach(function(item) {
+    if (item) {
+      const tmp = item.split(propertyDelimiter);
+      tmp.length > 1 && (res[camelize(tmp[0].trim())] = tmp[1].trim());
+    }
+  });
+  return res;
+}
+function toCSSText(style) {
+  const properties = [];
+  for (const name in style) {
+    const value = style[name];
+    if (typeof value !== "string") continue;
+    const normalizedName = hyphenate(name);
+    properties.push(`${normalizedName}: ${value};`);
+  }
+  return properties.join(" ");
+}
+const camelizeRE = /-([a-z])/g;
+const CUSTOM_PROPERTY_REGEX = /^--[a-zA-Z0-9-]+$/;
+const camelize = (str) => {
+  if (CUSTOM_PROPERTY_REGEX.test(str)) return str;
+  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
+};
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = (str) => {
+  return str.replace(hyphenateRE, "-$1").toLowerCase();
+};
+class BaseRRNode {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any
+  constructor(..._args) {
+    __publicField2(this, "parentElement", null);
+    __publicField2(this, "parentNode", null);
+    __publicField2(this, "ownerDocument");
+    __publicField2(this, "firstChild", null);
+    __publicField2(this, "lastChild", null);
+    __publicField2(this, "previousSibling", null);
+    __publicField2(this, "nextSibling", null);
+    __publicField2(this, "ELEMENT_NODE", 1);
+    __publicField2(this, "TEXT_NODE", 3);
+    __publicField2(this, "nodeType");
+    __publicField2(this, "nodeName");
+    __publicField2(this, "RRNodeType");
+  }
+  get childNodes() {
+    const childNodes = [];
+    let childIterator = this.firstChild;
+    while (childIterator) {
+      childNodes.push(childIterator);
+      childIterator = childIterator.nextSibling;
+    }
+    return childNodes;
+  }
+  contains(node2) {
+    if (!(node2 instanceof BaseRRNode)) return false;
+    else if (node2.ownerDocument !== this.ownerDocument) return false;
+    else if (node2 === this) return true;
+    while (node2.parentNode) {
+      if (node2.parentNode === this) return true;
+      node2 = node2.parentNode;
+    }
+    return false;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  appendChild(_newChild) {
+    throw new Error(
+      `RRDomException: Failed to execute 'appendChild' on 'RRNode': This RRNode type does not support this method.`
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  insertBefore(_newChild, _refChild) {
+    throw new Error(
+      `RRDomException: Failed to execute 'insertBefore' on 'RRNode': This RRNode type does not support this method.`
+    );
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  removeChild(_node) {
+    throw new Error(
+      `RRDomException: Failed to execute 'removeChild' on 'RRNode': This RRNode type does not support this method.`
+    );
+  }
+  toString() {
+    return "RRNode";
+  }
+}
+class BaseRRDocument extends BaseRRNode {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor(...args) {
+    super(args);
+    __publicField2(this, "nodeType", 9);
+    __publicField2(this, "nodeName", "#document");
+    __publicField2(this, "compatMode", "CSS1Compat");
+    __publicField2(this, "RRNodeType", NodeType$1.Document);
+    __publicField2(this, "textContent", null);
+    this.ownerDocument = this;
+  }
+  get documentElement() {
+    return this.childNodes.find(
+      (node2) => node2.RRNodeType === NodeType$1.Element && node2.tagName === "HTML"
+    ) || null;
+  }
+  get body() {
+    var _a;
+    return ((_a = this.documentElement) == null ? void 0 : _a.childNodes.find(
+      (node2) => node2.RRNodeType === NodeType$1.Element && node2.tagName === "BODY"
+    )) || null;
+  }
+  get head() {
+    var _a;
+    return ((_a = this.documentElement) == null ? void 0 : _a.childNodes.find(
+      (node2) => node2.RRNodeType === NodeType$1.Element && node2.tagName === "HEAD"
+    )) || null;
+  }
+  get implementation() {
+    return this;
+  }
+  get firstElementChild() {
+    return this.documentElement;
+  }
+  appendChild(newChild) {
+    const nodeType = newChild.RRNodeType;
+    if (nodeType === NodeType$1.Element || nodeType === NodeType$1.DocumentType) {
+      if (this.childNodes.some((s) => s.RRNodeType === nodeType)) {
+        throw new Error(
+          `RRDomException: Failed to execute 'appendChild' on 'RRNode': Only one ${nodeType === NodeType$1.Element ? "RRElement" : "RRDoctype"} on RRDocument allowed.`
+        );
+      }
+    }
+    const child = appendChild(this, newChild);
+    child.parentElement = null;
+    return child;
+  }
+  insertBefore(newChild, refChild) {
+    const nodeType = newChild.RRNodeType;
+    if (nodeType === NodeType$1.Element || nodeType === NodeType$1.DocumentType) {
+      if (this.childNodes.some((s) => s.RRNodeType === nodeType)) {
+        throw new Error(
+          `RRDomException: Failed to execute 'insertBefore' on 'RRNode': Only one ${nodeType === NodeType$1.Element ? "RRElement" : "RRDoctype"} on RRDocument allowed.`
+        );
+      }
+    }
+    const child = insertBefore(this, newChild, refChild);
+    child.parentElement = null;
+    return child;
+  }
+  removeChild(node2) {
+    return removeChild(this, node2);
+  }
+  open() {
+    this.firstChild = null;
+    this.lastChild = null;
+  }
+  close() {
+  }
+  /**
+   * Adhoc implementation for setting xhtml namespace in rebuilt.ts (rrweb-snapshot).
+   * There are two lines used this function:
+   * 1. doc.write('\<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" ""\>')
+   * 2. doc.write('\<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" ""\>')
+   */
+  write(content) {
+    let publicId;
+    if (content === '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "">')
+      publicId = "-//W3C//DTD XHTML 1.0 Transitional//EN";
+    else if (content === '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "">')
+      publicId = "-//W3C//DTD HTML 4.0 Transitional//EN";
+    if (publicId) {
+      const doctype = this.createDocumentType("html", publicId, "");
+      this.open();
+      this.appendChild(doctype);
+    }
+  }
+  createDocument(_namespace, _qualifiedName, _doctype) {
+    return new BaseRRDocument();
+  }
+  createDocumentType(qualifiedName, publicId, systemId) {
+    const doctype = new BaseRRDocumentType(qualifiedName, publicId, systemId);
+    doctype.ownerDocument = this;
+    return doctype;
+  }
+  createElement(tagName) {
+    const element = new BaseRRElement(tagName);
+    element.ownerDocument = this;
+    return element;
+  }
+  createElementNS(_namespaceURI, qualifiedName) {
+    return this.createElement(qualifiedName);
+  }
+  createTextNode(data) {
+    const text = new BaseRRText(data);
+    text.ownerDocument = this;
+    return text;
+  }
+  createComment(data) {
+    const comment2 = new BaseRRComment(data);
+    comment2.ownerDocument = this;
+    return comment2;
+  }
+  createCDATASection(data) {
+    const CDATASection = new BaseRRCDATASection(data);
+    CDATASection.ownerDocument = this;
+    return CDATASection;
+  }
+  toString() {
+    return "RRDocument";
+  }
+}
+class BaseRRDocumentType extends BaseRRNode {
+  constructor(qualifiedName, publicId, systemId) {
+    super();
+    __publicField2(this, "nodeType", 10);
+    __publicField2(this, "RRNodeType", NodeType$1.DocumentType);
+    __publicField2(this, "name");
+    __publicField2(this, "publicId");
+    __publicField2(this, "systemId");
+    __publicField2(this, "textContent", null);
+    this.name = qualifiedName;
+    this.publicId = publicId;
+    this.systemId = systemId;
+    this.nodeName = qualifiedName;
+  }
+  toString() {
+    return "RRDocumentType";
+  }
+}
+class BaseRRElement extends BaseRRNode {
+  constructor(tagName) {
+    super();
+    __publicField2(this, "nodeType", 1);
+    __publicField2(this, "RRNodeType", NodeType$1.Element);
+    __publicField2(this, "tagName");
+    __publicField2(this, "attributes", {});
+    __publicField2(this, "shadowRoot", null);
+    __publicField2(this, "scrollLeft");
+    __publicField2(this, "scrollTop");
+    this.tagName = tagName.toUpperCase();
+    this.nodeName = tagName.toUpperCase();
+  }
+  get textContent() {
+    let result2 = "";
+    this.childNodes.forEach((node2) => result2 += node2.textContent);
+    return result2;
+  }
+  set textContent(textContent) {
+    this.firstChild = null;
+    this.lastChild = null;
+    this.appendChild(this.ownerDocument.createTextNode(textContent));
+  }
+  get classList() {
+    return new ClassList(
+      this.attributes.class,
+      (newClassName) => {
+        this.attributes.class = newClassName;
+      }
+    );
+  }
+  get id() {
+    return this.attributes.id || "";
+  }
+  get className() {
+    return this.attributes.class || "";
+  }
+  get style() {
+    const style = this.attributes.style ? parseCSSText(this.attributes.style) : {};
+    const hyphenateRE2 = /\B([A-Z])/g;
+    style.setProperty = (name, value, priority) => {
+      if (hyphenateRE2.test(name)) return;
+      const normalizedName = camelize(name);
+      if (!value) delete style[normalizedName];
+      else style[normalizedName] = value;
+      if (priority === "important") style[normalizedName] += " !important";
+      this.attributes.style = toCSSText(style);
+    };
+    style.removeProperty = (name) => {
+      if (hyphenateRE2.test(name)) return "";
+      const normalizedName = camelize(name);
+      const value = style[normalizedName] || "";
+      delete style[normalizedName];
+      this.attributes.style = toCSSText(style);
+      return value;
+    };
+    return style;
+  }
+  getAttribute(name) {
+    if (this.attributes[name] === void 0) return null;
+    return this.attributes[name];
+  }
+  setAttribute(name, attribute) {
+    this.attributes[name] = attribute;
+  }
+  setAttributeNS(_namespace, qualifiedName, value) {
+    this.setAttribute(qualifiedName, value);
+  }
+  removeAttribute(name) {
+    delete this.attributes[name];
+  }
+  appendChild(newChild) {
+    return appendChild(this, newChild);
+  }
+  insertBefore(newChild, refChild) {
+    return insertBefore(this, newChild, refChild);
+  }
+  removeChild(node2) {
+    return removeChild(this, node2);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  attachShadow(_init) {
+    const shadowRoot = this.ownerDocument.createElement("SHADOWROOT");
+    this.shadowRoot = shadowRoot;
+    return shadowRoot;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  dispatchEvent(_event) {
+    return true;
+  }
+  toString() {
+    let attributeString = "";
+    for (const attribute in this.attributes) {
+      attributeString += `${attribute}="${this.attributes[attribute]}" `;
+    }
+    return `${this.tagName} ${attributeString}`;
+  }
+}
+class BaseRRMediaElement extends BaseRRElement {
+  constructor() {
+    super(...arguments);
+    __publicField2(this, "currentTime");
+    __publicField2(this, "volume");
+    __publicField2(this, "paused");
+    __publicField2(this, "muted");
+    __publicField2(this, "playbackRate");
+    __publicField2(this, "loop");
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  attachShadow(_init) {
+    throw new Error(
+      `RRDomException: Failed to execute 'attachShadow' on 'RRElement': This RRElement does not support attachShadow`
+    );
+  }
+  play() {
+    this.paused = false;
+  }
+  pause() {
+    this.paused = true;
+  }
+}
+class BaseRRText extends BaseRRNode {
+  constructor(data) {
+    super();
+    __publicField2(this, "nodeType", 3);
+    __publicField2(this, "nodeName", "#text");
+    __publicField2(this, "RRNodeType", NodeType$1.Text);
+    __publicField2(this, "data");
+    this.data = data;
+  }
+  get textContent() {
+    return this.data;
+  }
+  set textContent(textContent) {
+    this.data = textContent;
+  }
+  toString() {
+    return `RRText text=${JSON.stringify(this.data)}`;
+  }
+}
+class BaseRRComment extends BaseRRNode {
+  constructor(data) {
+    super();
+    __publicField2(this, "nodeType", 8);
+    __publicField2(this, "nodeName", "#comment");
+    __publicField2(this, "RRNodeType", NodeType$1.Comment);
+    __publicField2(this, "data");
+    this.data = data;
+  }
+  get textContent() {
+    return this.data;
+  }
+  set textContent(textContent) {
+    this.data = textContent;
+  }
+  toString() {
+    return `RRComment text=${JSON.stringify(this.data)}`;
+  }
+}
+class BaseRRCDATASection extends BaseRRNode {
+  constructor(data) {
+    super();
+    __publicField2(this, "nodeName", "#cdata-section");
+    __publicField2(this, "nodeType", 4);
+    __publicField2(this, "RRNodeType", NodeType$1.CDATA);
+    __publicField2(this, "data");
+    this.data = data;
+  }
+  get textContent() {
+    return this.data;
+  }
+  set textContent(textContent) {
+    this.data = textContent;
+  }
+  toString() {
+    return `RRCDATASection data=${JSON.stringify(this.data)}`;
+  }
+}
+class ClassList {
+  constructor(classText, onChange) {
+    __publicField2(this, "onChange");
+    __publicField2(this, "classes", []);
+    __publicField2(this, "add", (...classNames) => {
+      for (const item of classNames) {
+        const className = String(item);
+        if (this.classes.indexOf(className) >= 0) continue;
+        this.classes.push(className);
+      }
+      this.onChange && this.onChange(this.classes.join(" "));
+    });
+    __publicField2(this, "remove", (...classNames) => {
+      this.classes = this.classes.filter(
+        (item) => classNames.indexOf(item) === -1
+      );
+      this.onChange && this.onChange(this.classes.join(" "));
+    });
+    if (classText) {
+      const classes = classText.trim().split(/\s+/);
+      this.classes.push(...classes);
+    }
+    this.onChange = onChange;
+  }
+}
+function appendChild(parent, newChild) {
+  if (newChild.parentNode) newChild.parentNode.removeChild(newChild);
+  if (parent.lastChild) {
+    parent.lastChild.nextSibling = newChild;
+    newChild.previousSibling = parent.lastChild;
+  } else {
+    parent.firstChild = newChild;
+    newChild.previousSibling = null;
+  }
+  parent.lastChild = newChild;
+  newChild.nextSibling = null;
+  newChild.parentNode = parent;
+  newChild.parentElement = parent;
+  newChild.ownerDocument = parent.ownerDocument;
+  return newChild;
+}
+function insertBefore(parent, newChild, refChild) {
+  if (!refChild) return appendChild(parent, newChild);
+  if (refChild.parentNode !== parent)
+    throw new Error(
+      "Failed to execute 'insertBefore' on 'RRNode': The RRNode before which the new node is to be inserted is not a child of this RRNode."
+    );
+  if (newChild === refChild) return newChild;
+  if (newChild.parentNode) newChild.parentNode.removeChild(newChild);
+  newChild.previousSibling = refChild.previousSibling;
+  refChild.previousSibling = newChild;
+  newChild.nextSibling = refChild;
+  if (newChild.previousSibling) newChild.previousSibling.nextSibling = newChild;
+  else parent.firstChild = newChild;
+  newChild.parentElement = parent;
+  newChild.parentNode = parent;
+  newChild.ownerDocument = parent.ownerDocument;
+  return newChild;
+}
+function removeChild(parent, child) {
+  if (child.parentNode !== parent)
+    throw new Error(
+      "Failed to execute 'removeChild' on 'RRNode': The RRNode to be removed is not a child of this RRNode."
+    );
+  if (child.previousSibling)
+    child.previousSibling.nextSibling = child.nextSibling;
+  else parent.firstChild = child.nextSibling;
+  if (child.nextSibling)
+    child.nextSibling.previousSibling = child.previousSibling;
+  else parent.lastChild = child.previousSibling;
+  child.previousSibling = null;
+  child.nextSibling = null;
+  child.parentElement = null;
+  child.parentNode = null;
+  return child;
+}
+var NodeType = /* @__PURE__ */ ((NodeType2) => {
+  NodeType2[NodeType2["Document"] = 0] = "Document";
+  NodeType2[NodeType2["DocumentType"] = 1] = "DocumentType";
+  NodeType2[NodeType2["Element"] = 2] = "Element";
+  NodeType2[NodeType2["Text"] = 3] = "Text";
+  NodeType2[NodeType2["CDATA"] = 4] = "CDATA";
+  NodeType2[NodeType2["Comment"] = 5] = "Comment";
+  return NodeType2;
+})(NodeType || {});
+const nwsapi = require("nwsapi");
+const cssom = require("cssom");
+const cssstyle = require("cssstyle");
+class RRWindow {
+  constructor() {
+    __publicField(this, "scrollLeft", 0);
+    __publicField(this, "scrollTop", 0);
+  }
+  scrollTo(options) {
+    if (!options) return;
+    if (typeof options.left === "number") this.scrollLeft = options.left;
+    if (typeof options.top === "number") this.scrollTop = options.top;
+  }
+}
+class RRDocument extends BaseRRDocument {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "nodeName", "#document");
+    __publicField(this, "_nwsapi");
+  }
+  get nwsapi() {
+    if (!this._nwsapi) {
+      this._nwsapi = nwsapi({
+        document: this,
+        DOMException: null
+      });
+      this._nwsapi.configure({
+        LOGERRORS: false,
+        IDS_DUPES: true,
+        MIXEDCASE: true
+      });
+    }
+    return this._nwsapi;
+  }
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  get documentElement() {
+    return super.documentElement;
+  }
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  get body() {
+    return super.body;
+  }
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  get head() {
+    return super.head;
+  }
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  get implementation() {
+    return this;
+  }
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  get firstElementChild() {
+    return this.documentElement;
+  }
+  appendChild(childNode) {
+    return super.appendChild(childNode);
+  }
+  insertBefore(newChild, refChild) {
+    return super.insertBefore(newChild, refChild);
+  }
+  querySelectorAll(selectors) {
+    return this.nwsapi.select(selectors);
+  }
+  getElementsByTagName(tagName) {
+    if (this.documentElement)
+      return this.documentElement.getElementsByTagName(tagName);
+    return [];
+  }
+  getElementsByClassName(className) {
+    if (this.documentElement)
+      return this.documentElement.getElementsByClassName(className);
+    return [];
+  }
+  getElementById(elementId) {
+    if (this.documentElement)
+      return this.documentElement.getElementById(elementId);
+    return null;
+  }
+  createDocument(_namespace, _qualifiedName, _doctype) {
+    return new RRDocument();
+  }
+  createDocumentType(qualifiedName, publicId, systemId) {
+    const documentTypeNode = new RRDocumentType(
+      qualifiedName,
+      publicId,
+      systemId
+    );
+    documentTypeNode.ownerDocument = this;
+    return documentTypeNode;
+  }
+  createElement(tagName) {
+    const upperTagName = tagName.toUpperCase();
+    let element;
+    switch (upperTagName) {
+      case "AUDIO":
+      case "VIDEO":
+        element = new RRMediaElement(upperTagName);
+        break;
+      case "IFRAME":
+        element = new RRIFrameElement(upperTagName);
+        break;
+      case "IMG":
+        element = new RRImageElement(upperTagName);
+        break;
+      case "CANVAS":
+        element = new RRCanvasElement(upperTagName);
+        break;
+      case "STYLE":
+        element = new RRStyleElement(upperTagName);
+        break;
+      default:
+        element = new RRElement(upperTagName);
+        break;
+    }
+    element.ownerDocument = this;
+    return element;
+  }
+  createElementNS(_namespaceURI, qualifiedName) {
+    return this.createElement(qualifiedName);
+  }
+  createComment(data) {
+    const commentNode = new RRComment(data);
+    commentNode.ownerDocument = this;
+    return commentNode;
+  }
+  createCDATASection(data) {
+    const sectionNode = new RRCDATASection(data);
+    sectionNode.ownerDocument = this;
+    return sectionNode;
+  }
+  createTextNode(data) {
+    const textNode = new RRText(data);
+    textNode.ownerDocument = this;
+    return textNode;
+  }
+}
+class RRDocumentType extends BaseRRDocumentType {
+}
+class RRElement extends BaseRRElement {
+  constructor(tagName) {
+    super(tagName);
+    __publicField(this, "_style");
+    this._style = new cssstyle.CSSStyleDeclaration();
+    const style = this._style;
+    Object.defineProperty(this.attributes, "style", {
+      get() {
+        return style.cssText;
+      },
+      set(cssText) {
+        style.cssText = cssText;
+      }
+    });
+  }
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore
+  get style() {
+    return this._style;
+  }
+  attachShadow(_init) {
+    return super.attachShadow(_init);
+  }
+  appendChild(newChild) {
+    return super.appendChild(newChild);
+  }
+  insertBefore(newChild, refChild) {
+    return super.insertBefore(newChild, refChild);
+  }
+  getAttribute(name) {
+    const upperName = name && name.toLowerCase();
+    if (upperName in this.attributes) return this.attributes[upperName];
+    return null;
+  }
+  setAttribute(name, attribute) {
+    this.attributes[name.toLowerCase()] = attribute;
+  }
+  removeAttribute(name) {
+    delete this.attributes[name.toLowerCase()];
+  }
+  get firstElementChild() {
+    for (const child of this.childNodes)
+      if (child.RRNodeType === NodeType.Element) return child;
+    return null;
+  }
+  get nextElementSibling() {
+    const parentNode = this.parentNode;
+    if (!parentNode) return null;
+    const siblings = parentNode.childNodes;
+    const index = siblings.indexOf(this);
+    for (let i = index + 1; i < siblings.length; i++)
+      if (siblings[i] instanceof RRElement) return siblings[i];
+    return null;
+  }
+  querySelectorAll(selectors) {
+    const result2 = [];
+    if (this.ownerDocument !== null) {
+      this.ownerDocument.nwsapi.select(
+        selectors,
+        this,
+        (element) => {
+          if (element !== this)
+            result2.push(element);
+        }
+      );
+    }
+    return result2;
+  }
+  getElementById(elementId) {
+    if (this.id === elementId) return this;
+    for (const child of this.childNodes) {
+      if (child instanceof RRElement) {
+        const result2 = child.getElementById(elementId);
+        if (result2 !== null) return result2;
+      }
+    }
+    return null;
+  }
+  getElementsByClassName(className) {
+    let elements = [];
+    const queryClassList = new ClassList(className);
+    if (this instanceof RRElement && queryClassList.classes.filter(
+      (queriedClassName) => this.classList.classes.some((name) => name === queriedClassName)
+    ).length == queryClassList.classes.length)
+      elements.push(this);
+    for (const child of this.childNodes) {
+      if (child instanceof RRElement)
+        elements = elements.concat(child.getElementsByClassName(className));
+    }
+    return elements;
+  }
+  getElementsByTagName(tagName) {
+    let elements = [];
+    const normalizedTagName = tagName.toUpperCase();
+    if (this instanceof RRElement && this.tagName === normalizedTagName)
+      elements.push(this);
+    for (const child of this.childNodes) {
+      if (child instanceof RRElement)
+        elements = elements.concat(child.getElementsByTagName(tagName));
+    }
+    return elements;
+  }
+}
+class RRImageElement extends RRElement {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "src", "");
+    __publicField(this, "width", 0);
+    __publicField(this, "height", 0);
+    __publicField(this, "onload", null);
+  }
+}
+class RRMediaElement extends BaseRRMediaElement {
+}
+class RRCanvasElement extends RRElement {
+  /**
+   * This is just a dummy implementation to prevent rrweb replayer from drawing mouse tail. If further analysis of canvas is needed, we may implement it with node-canvas.
+   */
+  getContext() {
+    return null;
+  }
+}
+class RRStyleElement extends RRElement {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "_sheet", null);
+  }
+  get sheet() {
+    if (!this._sheet) {
+      let result2 = "";
+      for (const child of this.childNodes)
+        if (child.RRNodeType === NodeType.Text)
+          result2 += child.textContent;
+      this._sheet = cssom.parse(result2);
+    }
+    return this._sheet;
+  }
+}
+class RRIFrameElement extends RRElement {
+  constructor(tagName) {
+    super(tagName);
+    __publicField(this, "width", "");
+    __publicField(this, "height", "");
+    __publicField(this, "src", "");
+    __publicField(this, "contentDocument", new RRDocument());
+    __publicField(this, "contentWindow", new RRWindow());
+    const htmlElement = this.contentDocument.createElement("HTML");
+    this.contentDocument.appendChild(htmlElement);
+    htmlElement.appendChild(this.contentDocument.createElement("HEAD"));
+    htmlElement.appendChild(this.contentDocument.createElement("BODY"));
+  }
+}
+class RRText extends BaseRRText {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "nodeName", "#text");
+  }
+}
+class RRComment extends BaseRRComment {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "nodeName", "#comment");
+  }
+}
+class RRCDATASection extends BaseRRCDATASection {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "nodeName", "#cdata-section");
+  }
+}
+function polyfillPerformance() {
+  if (typeof window !== "undefined" || "performance" in global) return;
+  const performance = require("perf_hooks").performance;
+  global.performance = performance;
+}
+function polyfillRAF() {
+  if (typeof window !== "undefined" || "requestAnimationFrame" in global)
+    return;
+  const FPS = 60, INTERVAL = 1e3 / FPS;
+  let timeoutHandle = null, rafCount = 0, requests = /* @__PURE__ */ Object.create(null);
+  function onFrameTimer() {
+    const currentRequests = requests;
+    requests = /* @__PURE__ */ Object.create(null);
+    timeoutHandle = null;
+    Object.keys(currentRequests).forEach(function(id) {
+      const request = currentRequests[id];
+      if (request) request(Date.now());
+    });
+  }
+  function requestAnimationFrame(callback) {
+    const cbHandle = ++rafCount;
+    requests[cbHandle] = callback;
+    if (timeoutHandle === null)
+      timeoutHandle = setTimeout(onFrameTimer, INTERVAL);
+    return cbHandle;
+  }
+  function cancelAnimationFrame(handleId) {
+    delete requests[handleId];
+    if (Object.keys(requests).length === 0 && timeoutHandle !== null) {
+      clearTimeout(timeoutHandle);
+      timeoutHandle = null;
+    }
+  }
+  global.requestAnimationFrame = requestAnimationFrame;
+  global.cancelAnimationFrame = cancelAnimationFrame;
+}
+function polyfillEvent() {
+  if (typeof Event !== "undefined") return;
+  global.Event = function() {
+  };
+}
+function polyfillNode() {
+  if (typeof Node !== "undefined") return;
+  global.Node = BaseRRNode;
+}
+function polyfillDocument() {
+  if (typeof document !== "undefined") return;
+  const rrdom = new RRDocument();
+  (() => {
+    var _a, _b;
+    rrdom.appendChild(rrdom.createElement("html"));
+    (_a = rrdom.documentElement) == null ? void 0 : _a.appendChild(rrdom.createElement("head"));
+    (_b = rrdom.documentElement) == null ? void 0 : _b.appendChild(rrdom.createElement("body"));
+  })();
+  global.document = rrdom;
+}
+polyfillPerformance();
+polyfillRAF();
+polyfillEvent();
+polyfillNode();
+polyfillDocument();
+export {
+  RRCDATASection,
+  RRCanvasElement,
+  RRComment,
+  RRDocument,
+  RRDocumentType,
+  RRElement,
+  RRIFrameElement,
+  RRImageElement,
+  RRMediaElement,
+  RRStyleElement,
+  RRText,
+  RRWindow
+};
+//# sourceMappingURL=rrdom-nodejs.js.map