hldesigner 0.0.1

package/postcss-2c4d92ea.js

@@ -0,0 +1,2285 @@
+import { N as y } from "./baseImp-8c4be88e.js";
+import { g as Dt } from "./_commonjsHelpers-e7ea1525.js";
+import "./enum-type-287a50b6.js";
+import "./uuid-39f0308a.js";
+import "./enum-type-255ade69.js";
+import "./icon-2bb9fa65.js";
+import "vue";
+import "./template-c30585f4.js";
+import "./dialog-5e196819.js";
+import "element-plus";
+var q = {}, zt = {
+  get exports() {
+    return q;
+  },
+  set exports(o) {
+    q = o;
+  }
+}, c = String, tt = function() {
+  return { isColorSupported: !1, reset: c, bold: c, dim: c, italic: c, underline: c, inverse: c, hidden: c, strikethrough: c, black: c, red: c, green: c, yellow: c, blue: c, magenta: c, cyan: c, white: c, gray: c, bgBlack: c, bgRed: c, bgGreen: c, bgYellow: c, bgBlue: c, bgMagenta: c, bgCyan: c, bgWhite: c, blackBright: c, redBright: c, greenBright: c, yellowBright: c, blueBright: c, magentaBright: c, cyanBright: c, whiteBright: c, bgBlackBright: c, bgRedBright: c, bgGreenBright: c, bgYellowBright: c, bgBlueBright: c, bgMagentaBright: c, bgCyanBright: c, bgWhiteBright: c };
+};
+zt.exports = tt();
+q.createColors = tt;
+let De = q, ze = y, K = class extends Error {
+  constructor(e, t, r, s, i, l) {
+    super(e), this.name = "CssSyntaxError", this.reason = e, i && (this.file = i), s && (this.source = s), l && (this.plugin = l), typeof t < "u" && typeof r < "u" && (typeof t == "number" ? (this.line = t, this.column = r) : (this.line = t.line, this.column = t.column, this.endLine = r.line, this.endColumn = r.column)), this.setMessage(), Error.captureStackTrace && Error.captureStackTrace(this, K);
+  }
+  setMessage() {
+    this.message = this.plugin ? this.plugin + ": " : "", this.message += this.file ? this.file : "<css input>", typeof this.line < "u" && (this.message += ":" + this.line + ":" + this.column), this.message += ": " + this.reason;
+  }
+  showSourceCode(e) {
+    if (!this.source)
+      return "";
+    let t = this.source;
+    e == null && (e = De.isColorSupported);
+    let r = (h) => h, s = (h) => h, i = (h) => h;
+    if (e) {
+      let { bold: h, gray: m, red: d } = De.createColors(!0);
+      s = (g) => h(d(g)), r = (g) => m(g), ze && (i = (g) => ze(g));
+    }
+    let l = t.split(/\r?\n/), a = Math.max(this.line - 3, 0), n = Math.min(this.line + 2, l.length), u = String(n).length;
+    return l.slice(a, n).map((h, m) => {
+      let d = a + 1 + m, g = " " + (" " + d).slice(-u) + " | ";
+      if (d === this.line) {
+        if (h.length > 160) {
+          let S = 20, f = Math.max(0, this.column - S), P = Math.max(
+            this.column + S,
+            this.endColumn + S
+          ), R = h.slice(f, P), le = r(g.replace(/\d/g, " ")) + h.slice(0, Math.min(this.column - 1, S - 1)).replace(/[^\t]/g, " ");
+          return s(">") + r(g) + i(R) + `
+ ` + le + s("^");
+        }
+        let O = r(g.replace(/\d/g, " ")) + h.slice(0, this.column - 1).replace(/[^\t]/g, " ");
+        return s(">") + r(g) + i(h) + `
+ ` + O + s("^");
+      }
+      return " " + r(g) + i(h);
+    }).join(`
+`);
+  }
+  toString() {
+    let e = this.showSourceCode();
+    return e && (e = `
+
+` + e + `
+`), this.name + ": " + this.message + e;
+  }
+};
+var Ae = K;
+K.default = K;
+const Fe = {
+  after: `
+`,
+  beforeClose: `
+`,
+  beforeComment: `
+`,
+  beforeDecl: `
+`,
+  beforeOpen: " ",
+  beforeRule: `
+`,
+  colon: ": ",
+  commentLeft: " ",
+  commentRight: " ",
+  emptyBody: "",
+  indent: "    ",
+  semicolon: !1
+};
+function Ft(o) {
+  return o[0].toUpperCase() + o.slice(1);
+}
+let me = class {
+  constructor(e) {
+    this.builder = e;
+  }
+  atrule(e, t) {
+    let r = "@" + e.name, s = e.params ? this.rawValue(e, "params") : "";
+    if (typeof e.raws.afterName < "u" ? r += e.raws.afterName : s && (r += " "), e.nodes)
+      this.block(e, r + s);
+    else {
+      let i = (e.raws.between || "") + (t ? ";" : "");
+      this.builder(r + s + i, e);
+    }
+  }
+  beforeAfter(e, t) {
+    let r;
+    e.type === "decl" ? r = this.raw(e, null, "beforeDecl") : e.type === "comment" ? r = this.raw(e, null, "beforeComment") : t === "before" ? r = this.raw(e, null, "beforeRule") : r = this.raw(e, null, "beforeClose");
+    let s = e.parent, i = 0;
+    for (; s && s.type !== "root"; )
+      i += 1, s = s.parent;
+    if (r.includes(`
+`)) {
+      let l = this.raw(e, null, "indent");
+      if (l.length)
+        for (let a = 0; a < i; a++)
+          r += l;
+    }
+    return r;
+  }
+  block(e, t) {
+    let r = this.raw(e, "between", "beforeOpen");
+    this.builder(t + r + "{", e, "start");
+    let s;
+    e.nodes && e.nodes.length ? (this.body(e), s = this.raw(e, "after")) : s = this.raw(e, "after", "emptyBody"), s && this.builder(s), this.builder("}", e, "end");
+  }
+  body(e) {
+    let t = e.nodes.length - 1;
+    for (; t > 0 && e.nodes[t].type === "comment"; )
+      t -= 1;
+    let r = this.raw(e, "semicolon");
+    for (let s = 0; s < e.nodes.length; s++) {
+      let i = e.nodes[s], l = this.raw(i, "before");
+      l && this.builder(l), this.stringify(i, t !== s || r);
+    }
+  }
+  comment(e) {
+    let t = this.raw(e, "left", "commentLeft"), r = this.raw(e, "right", "commentRight");
+    this.builder("/*" + t + e.text + r + "*/", e);
+  }
+  decl(e, t) {
+    let r = this.raw(e, "between", "colon"), s = e.prop + r + this.rawValue(e, "value");
+    e.important && (s += e.raws.important || " !important"), t && (s += ";"), this.builder(s, e);
+  }
+  document(e) {
+    this.body(e);
+  }
+  raw(e, t, r) {
+    let s;
+    if (r || (r = t), t && (s = e.raws[t], typeof s < "u"))
+      return s;
+    let i = e.parent;
+    if (r === "before" && (!i || i.type === "root" && i.first === e || i && i.type === "document"))
+      return "";
+    if (!i)
+      return Fe[r];
+    let l = e.root();
+    if (l.rawCache || (l.rawCache = {}), typeof l.rawCache[r] < "u")
+      return l.rawCache[r];
+    if (r === "before" || r === "after")
+      return this.beforeAfter(e, r);
+    {
+      let a = "raw" + Ft(r);
+      this[a] ? s = this[a](l, e) : l.walk((n) => {
+        if (s = n.raws[t], typeof s < "u")
+          return !1;
+      });
+    }
+    return typeof s > "u" && (s = Fe[r]), l.rawCache[r] = s, s;
+  }
+  rawBeforeClose(e) {
+    let t;
+    return e.walk((r) => {
+      if (r.nodes && r.nodes.length > 0 && typeof r.raws.after < "u")
+        return t = r.raws.after, t.includes(`
+`) && (t = t.replace(/[^\n]+$/, "")), !1;
+    }), t && (t = t.replace(/\S/g, "")), t;
+  }
+  rawBeforeComment(e, t) {
+    let r;
+    return e.walkComments((s) => {
+      if (typeof s.raws.before < "u")
+        return r = s.raws.before, r.includes(`
+`) && (r = r.replace(/[^\n]+$/, "")), !1;
+    }), typeof r > "u" ? r = this.raw(t, null, "beforeDecl") : r && (r = r.replace(/\S/g, "")), r;
+  }
+  rawBeforeDecl(e, t) {
+    let r;
+    return e.walkDecls((s) => {
+      if (typeof s.raws.before < "u")
+        return r = s.raws.before, r.includes(`
+`) && (r = r.replace(/[^\n]+$/, "")), !1;
+    }), typeof r > "u" ? r = this.raw(t, null, "beforeRule") : r && (r = r.replace(/\S/g, "")), r;
+  }
+  rawBeforeOpen(e) {
+    let t;
+    return e.walk((r) => {
+      if (r.type !== "decl" && (t = r.raws.between, typeof t < "u"))
+        return !1;
+    }), t;
+  }
+  rawBeforeRule(e) {
+    let t;
+    return e.walk((r) => {
+      if (r.nodes && (r.parent !== e || e.first !== r) && typeof r.raws.before < "u")
+        return t = r.raws.before, t.includes(`
+`) && (t = t.replace(/[^\n]+$/, "")), !1;
+    }), t && (t = t.replace(/\S/g, "")), t;
+  }
+  rawColon(e) {
+    let t;
+    return e.walkDecls((r) => {
+      if (typeof r.raws.between < "u")
+        return t = r.raws.between.replace(/[^\s:]/g, ""), !1;
+    }), t;
+  }
+  rawEmptyBody(e) {
+    let t;
+    return e.walk((r) => {
+      if (r.nodes && r.nodes.length === 0 && (t = r.raws.after, typeof t < "u"))
+        return !1;
+    }), t;
+  }
+  rawIndent(e) {
+    if (e.raws.indent)
+      return e.raws.indent;
+    let t;
+    return e.walk((r) => {
+      let s = r.parent;
+      if (s && s !== e && s.parent && s.parent === e && typeof r.raws.before < "u") {
+        let i = r.raws.before.split(`
+`);
+        return t = i[i.length - 1], t = t.replace(/\S/g, ""), !1;
+      }
+    }), t;
+  }
+  rawSemicolon(e) {
+    let t;
+    return e.walk((r) => {
+      if (r.nodes && r.nodes.length && r.last.type === "decl" && (t = r.raws.semicolon, typeof t < "u"))
+        return !1;
+    }), t;
+  }
+  rawValue(e, t) {
+    let r = e[t], s = e.raws[t];
+    return s && s.value === r ? s.raw : r;
+  }
+  root(e) {
+    this.body(e), e.raws.after && this.builder(e.raws.after);
+  }
+  rule(e) {
+    this.block(e, this.rawValue(e, "selector")), e.raws.ownSemicolon && this.builder(e.raws.ownSemicolon, e, "end");
+  }
+  stringify(e, t) {
+    if (!this[e.type])
+      throw new Error(
+        "Unknown AST node type " + e.type + ". Maybe you need to change PostCSS stringifier."
+      );
+    this[e.type](e, t);
+  }
+};
+var rt = me;
+me.default = me;
+let Tt = rt;
+function de(o, e) {
+  new Tt(e).stringify(o);
+}
+var re = de;
+de.default = de;
+var D = {};
+D.isClean = Symbol("isClean");
+D.my = Symbol("my");
+let Wt = Ae, jt = rt, Vt = re, { isClean: M, my: Gt } = D;
+function ge(o, e) {
+  let t = new o.constructor();
+  for (let r in o) {
+    if (!Object.prototype.hasOwnProperty.call(o, r) || r === "proxyCache")
+      continue;
+    let s = o[r], i = typeof s;
+    r === "parent" && i === "object" ? e && (t[r] = e) : r === "source" ? t[r] = s : Array.isArray(s) ? t[r] = s.map((l) => ge(l, t)) : (i === "object" && s !== null && (s = ge(s)), t[r] = s);
+  }
+  return t;
+}
+function k(o, e) {
+  if (e && typeof e.offset < "u")
+    return e.offset;
+  let t = 1, r = 1, s = 0;
+  for (let i = 0; i < o.length; i++) {
+    if (r === e.line && t === e.column) {
+      s = i;
+      break;
+    }
+    o[i] === `
+` ? (t = 1, r += 1) : t += 1;
+  }
+  return s;
+}
+let we = class {
+  constructor(e = {}) {
+    this.raws = {}, this[M] = !1, this[Gt] = !0;
+    for (let t in e)
+      if (t === "nodes") {
+        this.nodes = [];
+        for (let r of e[t])
+          typeof r.clone == "function" ? this.append(r.clone()) : this.append(r);
+      } else
+        this[t] = e[t];
+  }
+  addToError(e) {
+    if (e.postcssNode = this, e.stack && this.source && /\n\s{4}at /.test(e.stack)) {
+      let t = this.source;
+      e.stack = e.stack.replace(
+        /\n\s{4}at /,
+        `$&${t.input.from}:${t.start.line}:${t.start.column}$&`
+      );
+    }
+    return e;
+  }
+  after(e) {
+    return this.parent.insertAfter(this, e), this;
+  }
+  assign(e = {}) {
+    for (let t in e)
+      this[t] = e[t];
+    return this;
+  }
+  before(e) {
+    return this.parent.insertBefore(this, e), this;
+  }
+  cleanRaws(e) {
+    delete this.raws.before, delete this.raws.after, e || delete this.raws.between;
+  }
+  clone(e = {}) {
+    let t = ge(this);
+    for (let r in e)
+      t[r] = e[r];
+    return t;
+  }
+  cloneAfter(e = {}) {
+    let t = this.clone(e);
+    return this.parent.insertAfter(this, t), t;
+  }
+  cloneBefore(e = {}) {
+    let t = this.clone(e);
+    return this.parent.insertBefore(this, t), t;
+  }
+  error(e, t = {}) {
+    if (this.source) {
+      let { end: r, start: s } = this.rangeBy(t);
+      return this.source.input.error(
+        e,
+        { column: s.column, line: s.line },
+        { column: r.column, line: r.line },
+        t
+      );
+    }
+    return new Wt(e);
+  }
+  getProxyProcessor() {
+    return {
+      get(e, t) {
+        return t === "proxyOf" ? e : t === "root" ? () => e.root().toProxy() : e[t];
+      },
+      set(e, t, r) {
+        return e[t] === r || (e[t] = r, (t === "prop" || t === "value" || t === "name" || t === "params" || t === "important" || /* c8 ignore next */
+        t === "text") && e.markDirty()), !0;
+      }
+    };
+  }
+  /* c8 ignore next 3 */
+  markClean() {
+    this[M] = !0;
+  }
+  markDirty() {
+    if (this[M]) {
+      this[M] = !1;
+      let e = this;
+      for (; e = e.parent; )
+        e[M] = !1;
+    }
+  }
+  next() {
+    if (!this.parent)
+      return;
+    let e = this.parent.index(this);
+    return this.parent.nodes[e + 1];
+  }
+  positionBy(e) {
+    let t = this.source.start;
+    if (e.index)
+      t = this.positionInside(e.index);
+    else if (e.word) {
+      let r = "document" in this.source.input ? this.source.input.document : this.source.input.css, i = r.slice(
+        k(r, this.source.start),
+        k(r, this.source.end)
+      ).indexOf(e.word);
+      i !== -1 && (t = this.positionInside(i));
+    }
+    return t;
+  }
+  positionInside(e) {
+    let t = this.source.start.column, r = this.source.start.line, s = "document" in this.source.input ? this.source.input.document : this.source.input.css, i = k(s, this.source.start), l = i + e;
+    for (let a = i; a < l; a++)
+      s[a] === `
+` ? (t = 1, r += 1) : t += 1;
+    return { column: t, line: r };
+  }
+  prev() {
+    if (!this.parent)
+      return;
+    let e = this.parent.index(this);
+    return this.parent.nodes[e - 1];
+  }
+  rangeBy(e) {
+    let t = {
+      column: this.source.start.column,
+      line: this.source.start.line
+    }, r = this.source.end ? {
+      column: this.source.end.column + 1,
+      line: this.source.end.line
+    } : {
+      column: t.column + 1,
+      line: t.line
+    };
+    if (e.word) {
+      let s = "document" in this.source.input ? this.source.input.document : this.source.input.css, l = s.slice(
+        k(s, this.source.start),
+        k(s, this.source.end)
+      ).indexOf(e.word);
+      l !== -1 && (t = this.positionInside(l), r = this.positionInside(
+        l + e.word.length
+      ));
+    } else
+      e.start ? t = {
+        column: e.start.column,
+        line: e.start.line
+      } : e.index && (t = this.positionInside(e.index)), e.end ? r = {
+        column: e.end.column,
+        line: e.end.line
+      } : typeof e.endIndex == "number" ? r = this.positionInside(e.endIndex) : e.index && (r = this.positionInside(e.index + 1));
+    return (r.line < t.line || r.line === t.line && r.column <= t.column) && (r = { column: t.column + 1, line: t.line }), { end: r, start: t };
+  }
+  raw(e, t) {
+    return new jt().raw(this, e, t);
+  }
+  remove() {
+    return this.parent && this.parent.removeChild(this), this.parent = void 0, this;
+  }
+  replaceWith(...e) {
+    if (this.parent) {
+      let t = this, r = !1;
+      for (let s of e)
+        s === this ? r = !0 : r ? (this.parent.insertAfter(t, s), t = s) : this.parent.insertBefore(t, s);
+      r || this.remove();
+    }
+    return this;
+  }
+  root() {
+    let e = this;
+    for (; e.parent && e.parent.type !== "document"; )
+      e = e.parent;
+    return e;
+  }
+  toJSON(e, t) {
+    let r = {}, s = t == null;
+    t = t || /* @__PURE__ */ new Map();
+    let i = 0;
+    for (let l in this) {
+      if (!Object.prototype.hasOwnProperty.call(this, l) || l === "parent" || l === "proxyCache")
+        continue;
+      let a = this[l];
+      if (Array.isArray(a))
+        r[l] = a.map((n) => typeof n == "object" && n.toJSON ? n.toJSON(null, t) : n);
+      else if (typeof a == "object" && a.toJSON)
+        r[l] = a.toJSON(null, t);
+      else if (l === "source") {
+        let n = t.get(a.input);
+        n == null && (n = i, t.set(a.input, i), i++), r[l] = {
+          end: a.end,
+          inputId: n,
+          start: a.start
+        };
+      } else
+        r[l] = a;
+    }
+    return s && (r.inputs = [...t.keys()].map((l) => l.toJSON())), r;
+  }
+  toProxy() {
+    return this.proxyCache || (this.proxyCache = new Proxy(this, this.getProxyProcessor())), this.proxyCache;
+  }
+  toString(e = Vt) {
+    e.stringify && (e = e.stringify);
+    let t = "";
+    return e(this, (r) => {
+      t += r;
+    }), t;
+  }
+  warn(e, t, r) {
+    let s = { node: this };
+    for (let i in r)
+      s[i] = r[i];
+    return e.warn(t, s);
+  }
+  get proxyOf() {
+    return this;
+  }
+};
+var se = we;
+we.default = we;
+let Jt = se, ye = class extends Jt {
+  constructor(e) {
+    super(e), this.type = "comment";
+  }
+};
+var ie = ye;
+ye.default = ye;
+let Ht = se, be = class extends Ht {
+  constructor(e) {
+    e && typeof e.value < "u" && typeof e.value != "string" && (e = { ...e, value: String(e.value) }), super(e), this.type = "decl";
+  }
+  get variable() {
+    return this.prop.startsWith("--") || this.prop[0] === "$";
+  }
+};
+var ne = be;
+be.default = be;
+let st = ie, it = ne, Yt = se, { isClean: nt, my: ot } = D, Pe, lt, at, Me;
+function ut(o) {
+  return o.map((e) => (e.nodes && (e.nodes = ut(e.nodes)), delete e.source, e));
+}
+function ht(o) {
+  if (o[nt] = !1, o.proxyOf.nodes)
+    for (let e of o.proxyOf.nodes)
+      ht(e);
+}
+let x = class extends Yt {
+  append(...e) {
+    for (let t of e) {
+      let r = this.normalize(t, this.last);
+      for (let s of r)
+        this.proxyOf.nodes.push(s);
+    }
+    return this.markDirty(), this;
+  }
+  cleanRaws(e) {
+    if (super.cleanRaws(e), this.nodes)
+      for (let t of this.nodes)
+        t.cleanRaws(e);
+  }
+  each(e) {
+    if (!this.proxyOf.nodes)
+      return;
+    let t = this.getIterator(), r, s;
+    for (; this.indexes[t] < this.proxyOf.nodes.length && (r = this.indexes[t], s = e(this.proxyOf.nodes[r], r), s !== !1); )
+      this.indexes[t] += 1;
+    return delete this.indexes[t], s;
+  }
+  every(e) {
+    return this.nodes.every(e);
+  }
+  getIterator() {
+    this.lastEach || (this.lastEach = 0), this.indexes || (this.indexes = {}), this.lastEach += 1;
+    let e = this.lastEach;
+    return this.indexes[e] = 0, e;
+  }
+  getProxyProcessor() {
+    return {
+      get(e, t) {
+        return t === "proxyOf" ? e : e[t] ? t === "each" || typeof t == "string" && t.startsWith("walk") ? (...r) => e[t](
+          ...r.map((s) => typeof s == "function" ? (i, l) => s(i.toProxy(), l) : s)
+        ) : t === "every" || t === "some" ? (r) => e[t](
+          (s, ...i) => r(s.toProxy(), ...i)
+        ) : t === "root" ? () => e.root().toProxy() : t === "nodes" ? e.nodes.map((r) => r.toProxy()) : t === "first" || t === "last" ? e[t].toProxy() : e[t] : e[t];
+      },
+      set(e, t, r) {
+        return e[t] === r || (e[t] = r, (t === "name" || t === "params" || t === "selector") && e.markDirty()), !0;
+      }
+    };
+  }
+  index(e) {
+    return typeof e == "number" ? e : (e.proxyOf && (e = e.proxyOf), this.proxyOf.nodes.indexOf(e));
+  }
+  insertAfter(e, t) {
+    let r = this.index(e), s = this.normalize(t, this.proxyOf.nodes[r]).reverse();
+    r = this.index(e);
+    for (let l of s)
+      this.proxyOf.nodes.splice(r + 1, 0, l);
+    let i;
+    for (let l in this.indexes)
+      i = this.indexes[l], r < i && (this.indexes[l] = i + s.length);
+    return this.markDirty(), this;
+  }
+  insertBefore(e, t) {
+    let r = this.index(e), s = r === 0 ? "prepend" : !1, i = this.normalize(
+      t,
+      this.proxyOf.nodes[r],
+      s
+    ).reverse();
+    r = this.index(e);
+    for (let a of i)
+      this.proxyOf.nodes.splice(r, 0, a);
+    let l;
+    for (let a in this.indexes)
+      l = this.indexes[a], r <= l && (this.indexes[a] = l + i.length);
+    return this.markDirty(), this;
+  }
+  normalize(e, t) {
+    if (typeof e == "string")
+      e = ut(lt(e).nodes);
+    else if (typeof e > "u")
+      e = [];
+    else if (Array.isArray(e)) {
+      e = e.slice(0);
+      for (let s of e)
+        s.parent && s.parent.removeChild(s, "ignore");
+    } else if (e.type === "root" && this.type !== "document") {
+      e = e.nodes.slice(0);
+      for (let s of e)
+        s.parent && s.parent.removeChild(s, "ignore");
+    } else if (e.type)
+      e = [e];
+    else if (e.prop) {
+      if (typeof e.value > "u")
+        throw new Error("Value field is missed in node creation");
+      typeof e.value != "string" && (e.value = String(e.value)), e = [new it(e)];
+    } else if (e.selector || e.selectors)
+      e = [new Me(e)];
+    else if (e.name)
+      e = [new Pe(e)];
+    else if (e.text)
+      e = [new st(e)];
+    else
+      throw new Error("Unknown node type in node creation");
+    return e.map((s) => (s[ot] || x.rebuild(s), s = s.proxyOf, s.parent && s.parent.removeChild(s), s[nt] && ht(s), s.raws || (s.raws = {}), typeof s.raws.before > "u" && t && typeof t.raws.before < "u" && (s.raws.before = t.raws.before.replace(/\S/g, "")), s.parent = this.proxyOf, s));
+  }
+  prepend(...e) {
+    e = e.reverse();
+    for (let t of e) {
+      let r = this.normalize(t, this.first, "prepend").reverse();
+      for (let s of r)
+        this.proxyOf.nodes.unshift(s);
+      for (let s in this.indexes)
+        this.indexes[s] = this.indexes[s] + r.length;
+    }
+    return this.markDirty(), this;
+  }
+  push(e) {
+    return e.parent = this, this.proxyOf.nodes.push(e), this;
+  }
+  removeAll() {
+    for (let e of this.proxyOf.nodes)
+      e.parent = void 0;
+    return this.proxyOf.nodes = [], this.markDirty(), this;
+  }
+  removeChild(e) {
+    e = this.index(e), this.proxyOf.nodes[e].parent = void 0, this.proxyOf.nodes.splice(e, 1);
+    let t;
+    for (let r in this.indexes)
+      t = this.indexes[r], t >= e && (this.indexes[r] = t - 1);
+    return this.markDirty(), this;
+  }
+  replaceValues(e, t, r) {
+    return r || (r = t, t = {}), this.walkDecls((s) => {
+      t.props && !t.props.includes(s.prop) || t.fast && !s.value.includes(t.fast) || (s.value = s.value.replace(e, r));
+    }), this.markDirty(), this;
+  }
+  some(e) {
+    return this.nodes.some(e);
+  }
+  walk(e) {
+    return this.each((t, r) => {
+      let s;
+      try {
+        s = e(t, r);
+      } catch (i) {
+        throw t.addToError(i);
+      }
+      return s !== !1 && t.walk && (s = t.walk(e)), s;
+    });
+  }
+  walkAtRules(e, t) {
+    return t ? e instanceof RegExp ? this.walk((r, s) => {
+      if (r.type === "atrule" && e.test(r.name))
+        return t(r, s);
+    }) : this.walk((r, s) => {
+      if (r.type === "atrule" && r.name === e)
+        return t(r, s);
+    }) : (t = e, this.walk((r, s) => {
+      if (r.type === "atrule")
+        return t(r, s);
+    }));
+  }
+  walkComments(e) {
+    return this.walk((t, r) => {
+      if (t.type === "comment")
+        return e(t, r);
+    });
+  }
+  walkDecls(e, t) {
+    return t ? e instanceof RegExp ? this.walk((r, s) => {
+      if (r.type === "decl" && e.test(r.prop))
+        return t(r, s);
+    }) : this.walk((r, s) => {
+      if (r.type === "decl" && r.prop === e)
+        return t(r, s);
+    }) : (t = e, this.walk((r, s) => {
+      if (r.type === "decl")
+        return t(r, s);
+    }));
+  }
+  walkRules(e, t) {
+    return t ? e instanceof RegExp ? this.walk((r, s) => {
+      if (r.type === "rule" && e.test(r.selector))
+        return t(r, s);
+    }) : this.walk((r, s) => {
+      if (r.type === "rule" && r.selector === e)
+        return t(r, s);
+    }) : (t = e, this.walk((r, s) => {
+      if (r.type === "rule")
+        return t(r, s);
+    }));
+  }
+  get first() {
+    if (this.proxyOf.nodes)
+      return this.proxyOf.nodes[0];
+  }
+  get last() {
+    if (this.proxyOf.nodes)
+      return this.proxyOf.nodes[this.proxyOf.nodes.length - 1];
+  }
+};
+x.registerParse = (o) => {
+  lt = o;
+};
+x.registerRule = (o) => {
+  Me = o;
+};
+x.registerAtRule = (o) => {
+  Pe = o;
+};
+x.registerRoot = (o) => {
+  at = o;
+};
+var v = x;
+x.default = x;
+x.rebuild = (o) => {
+  o.type === "atrule" ? Object.setPrototypeOf(o, Pe.prototype) : o.type === "rule" ? Object.setPrototypeOf(o, Me.prototype) : o.type === "decl" ? Object.setPrototypeOf(o, it.prototype) : o.type === "comment" ? Object.setPrototypeOf(o, st.prototype) : o.type === "root" && Object.setPrototypeOf(o, at.prototype), o[ot] = !0, o.nodes && o.nodes.forEach((e) => {
+    x.rebuild(e);
+  });
+};
+let ft = v, X = class extends ft {
+  constructor(e) {
+    super(e), this.type = "atrule";
+  }
+  append(...e) {
+    return this.proxyOf.nodes || (this.nodes = []), super.append(...e);
+  }
+  prepend(...e) {
+    return this.proxyOf.nodes || (this.nodes = []), super.prepend(...e);
+  }
+};
+var ke = X;
+X.default = X;
+ft.registerAtRule(X);
+let Qt = v, ct, pt, U = class extends Qt {
+  constructor(e) {
+    super({ type: "document", ...e }), this.nodes || (this.nodes = []);
+  }
+  toResult(e = {}) {
+    return new ct(new pt(), this, e).stringify();
+  }
+};
+U.registerLazyResult = (o) => {
+  ct = o;
+};
+U.registerProcessor = (o) => {
+  pt = o;
+};
+var Ie = U;
+U.default = U;
+let qt = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict", Kt = (o, e = 21) => (t = e) => {
+  let r = "", s = t | 0;
+  for (; s--; )
+    r += o[Math.random() * o.length | 0];
+  return r;
+}, Xt = (o = 21) => {
+  let e = "", t = o | 0;
+  for (; t--; )
+    e += qt[Math.random() * 64 | 0];
+  return e;
+};
+const Zt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  customAlphabet: Kt,
+  nanoid: Xt
+}, Symbol.toStringTag, { value: "Module" })), er = /* @__PURE__ */ Dt(Zt);
+let { existsSync: tr, readFileSync: rr } = y, { dirname: he, join: sr } = y, { SourceMapConsumer: Te, SourceMapGenerator: We } = y;
+function ir(o) {
+  return Buffer ? Buffer.from(o, "base64").toString() : window.atob(o);
+}
+let xe = class {
+  constructor(e, t) {
+    if (t.map === !1)
+      return;
+    this.loadAnnotation(e), this.inline = this.startWith(this.annotation, "data:");
+    let r = t.map ? t.map.prev : void 0, s = this.loadMap(t.from, r);
+    !this.mapFile && t.from && (this.mapFile = t.from), this.mapFile && (this.root = he(this.mapFile)), s && (this.text = s);
+  }
+  consumer() {
+    return this.consumerCache || (this.consumerCache = new Te(this.text)), this.consumerCache;
+  }
+  decodeInline(e) {
+    let t = /^data:application\/json;charset=utf-?8;base64,/, r = /^data:application\/json;base64,/, s = /^data:application\/json;charset=utf-?8,/, i = /^data:application\/json,/, l = e.match(s) || e.match(i);
+    if (l)
+      return decodeURIComponent(e.substr(l[0].length));
+    let a = e.match(t) || e.match(r);
+    if (a)
+      return ir(e.substr(a[0].length));
+    let n = e.match(/data:application\/json;([^,]+),/)[1];
+    throw new Error("Unsupported source map encoding " + n);
+  }
+  getAnnotationURL(e) {
+    return e.replace(/^\/\*\s*# sourceMappingURL=/, "").trim();
+  }
+  isMap(e) {
+    return typeof e != "object" ? !1 : typeof e.mappings == "string" || typeof e._mappings == "string" || Array.isArray(e.sections);
+  }
+  loadAnnotation(e) {
+    let t = e.match(/\/\*\s*# sourceMappingURL=/g);
+    if (!t)
+      return;
+    let r = e.lastIndexOf(t.pop()), s = e.indexOf("*/", r);
+    r > -1 && s > -1 && (this.annotation = this.getAnnotationURL(e.substring(r, s)));
+  }
+  loadFile(e) {
+    if (this.root = he(e), tr(e))
+      return this.mapFile = e, rr(e, "utf-8").toString().trim();
+  }
+  loadMap(e, t) {
+    if (t === !1)
+      return !1;
+    if (t) {
+      if (typeof t == "string")
+        return t;
+      if (typeof t == "function") {
+        let r = t(e);
+        if (r) {
+          let s = this.loadFile(r);
+          if (!s)
+            throw new Error(
+              "Unable to load previous source map: " + r.toString()
+            );
+          return s;
+        }
+      } else {
+        if (t instanceof Te)
+          return We.fromSourceMap(t).toString();
+        if (t instanceof We)
+          return t.toString();
+        if (this.isMap(t))
+          return JSON.stringify(t);
+        throw new Error(
+          "Unsupported previous source map format: " + t.toString()
+        );
+      }
+    } else {
+      if (this.inline)
+        return this.decodeInline(this.annotation);
+      if (this.annotation) {
+        let r = this.annotation;
+        return e && (r = sr(he(e), r)), this.loadFile(r);
+      }
+    }
+  }
+  startWith(e, t) {
+    return e ? e.substr(0, t.length) === t : !1;
+  }
+  withContent() {
+    return !!(this.consumer().sourcesContent && this.consumer().sourcesContent.length > 0);
+  }
+};
+var mt = xe;
+xe.default = xe;
+let { nanoid: nr } = er, { isAbsolute: Se, resolve: Ce } = y, { SourceMapConsumer: or, SourceMapGenerator: lr } = y, { fileURLToPath: je, pathToFileURL: F } = y, Ve = Ae, ar = mt, fe = y, ce = Symbol("fromOffsetCache"), ur = Boolean(or && lr), Ge = Boolean(Ce && Se), Z = class {
+  constructor(e, t = {}) {
+    if (e === null || typeof e > "u" || typeof e == "object" && !e.toString)
+      throw new Error(`PostCSS received ${e} instead of CSS string`);
+    if (this.css = e.toString(), this.css[0] === "\uFEFF" || this.css[0] === "￾" ? (this.hasBOM = !0, this.css = this.css.slice(1)) : this.hasBOM = !1, this.document = this.css, t.document && (this.document = t.document.toString()), t.from && (!Ge || /^\w+:\/\//.test(t.from) || Se(t.from) ? this.file = t.from : this.file = Ce(t.from)), Ge && ur) {
+      let r = new ar(this.css, t);
+      if (r.text) {
+        this.map = r;
+        let s = r.consumer().file;
+        !this.file && s && (this.file = this.mapResolve(s));
+      }
+    }
+    this.file || (this.id = "<input css " + nr(6) + ">"), this.map && (this.map.file = this.from);
+  }
+  error(e, t, r, s = {}) {
+    let i, l, a;
+    if (t && typeof t == "object") {
+      let u = t, h = r;
+      if (typeof u.offset == "number") {
+        let m = this.fromOffset(u.offset);
+        t = m.line, r = m.col;
+      } else
+        t = u.line, r = u.column;
+      if (typeof h.offset == "number") {
+        let m = this.fromOffset(h.offset);
+        l = m.line, i = m.col;
+      } else
+        l = h.line, i = h.column;
+    } else if (!r) {
+      let u = this.fromOffset(t);
+      t = u.line, r = u.col;
+    }
+    let n = this.origin(t, r, l, i);
+    return n ? a = new Ve(
+      e,
+      n.endLine === void 0 ? n.line : { column: n.column, line: n.line },
+      n.endLine === void 0 ? n.column : { column: n.endColumn, line: n.endLine },
+      n.source,
+      n.file,
+      s.plugin
+    ) : a = new Ve(
+      e,
+      l === void 0 ? t : { column: r, line: t },
+      l === void 0 ? r : { column: i, line: l },
+      this.css,
+      this.file,
+      s.plugin
+    ), a.input = { column: r, endColumn: i, endLine: l, line: t, source: this.css }, this.file && (F && (a.input.url = F(this.file).toString()), a.input.file = this.file), a;
+  }
+  fromOffset(e) {
+    let t, r;
+    if (this[ce])
+      r = this[ce];
+    else {
+      let i = this.css.split(`
+`);
+      r = new Array(i.length);
+      let l = 0;
+      for (let a = 0, n = i.length; a < n; a++)
+        r[a] = l, l += i[a].length + 1;
+      this[ce] = r;
+    }
+    t = r[r.length - 1];
+    let s = 0;
+    if (e >= t)
+      s = r.length - 1;
+    else {
+      let i = r.length - 2, l;
+      for (; s < i; )
+        if (l = s + (i - s >> 1), e < r[l])
+          i = l - 1;
+        else if (e >= r[l + 1])
+          s = l + 1;
+        else {
+          s = l;
+          break;
+        }
+    }
+    return {
+      col: e - r[s] + 1,
+      line: s + 1
+    };
+  }
+  mapResolve(e) {
+    return /^\w+:\/\//.test(e) ? e : Ce(this.map.consumer().sourceRoot || this.map.root || ".", e);
+  }
+  origin(e, t, r, s) {
+    if (!this.map)
+      return !1;
+    let i = this.map.consumer(), l = i.originalPositionFor({ column: t, line: e });
+    if (!l.source)
+      return !1;
+    let a;
+    typeof r == "number" && (a = i.originalPositionFor({ column: s, line: r }));
+    let n;
+    Se(l.source) ? n = F(l.source) : n = new URL(
+      l.source,
+      this.map.consumer().sourceRoot || F(this.map.mapFile)
+    );
+    let u = {
+      column: l.column,
+      endColumn: a && a.column,
+      endLine: a && a.line,
+      line: l.line,
+      url: n.toString()
+    };
+    if (n.protocol === "file:")
+      if (je)
+        u.file = je(n);
+      else
+        throw new Error("file: protocol is not available in this PostCSS build");
+    let h = i.sourceContentFor(l.source);
+    return h && (u.source = h), u;
+  }
+  toJSON() {
+    let e = {};
+    for (let t of ["hasBOM", "css", "file", "id"])
+      this[t] != null && (e[t] = this[t]);
+    return this.map && (e.map = { ...this.map }, e.map.consumerCache && (e.map.consumerCache = void 0)), e;
+  }
+  get from() {
+    return this.file || this.id;
+  }
+};
+var oe = Z;
+Z.default = Z;
+fe && fe.registerInput && fe.registerInput(Z);
+let dt = v, gt, wt, E = class extends dt {
+  constructor(e) {
+    super(e), this.type = "root", this.nodes || (this.nodes = []);
+  }
+  normalize(e, t, r) {
+    let s = super.normalize(e);
+    if (t) {
+      if (r === "prepend")
+        this.nodes.length > 1 ? t.raws.before = this.nodes[1].raws.before : delete t.raws.before;
+      else if (this.first !== t)
+        for (let i of s)
+          i.raws.before = t.raws.before;
+    }
+    return s;
+  }
+  removeChild(e, t) {
+    let r = this.index(e);
+    return !t && r === 0 && this.nodes.length > 1 && (this.nodes[1].raws.before = this.nodes[r].raws.before), super.removeChild(e);
+  }
+  toResult(e = {}) {
+    return new gt(new wt(), this, e).stringify();
+  }
+};
+E.registerLazyResult = (o) => {
+  gt = o;
+};
+E.registerProcessor = (o) => {
+  wt = o;
+};
+var z = E;
+E.default = E;
+dt.registerRoot(E);
+let N = {
+  comma(o) {
+    return N.split(o, [","], !0);
+  },
+  space(o) {
+    let e = [" ", `
+`, "	"];
+    return N.split(o, e);
+  },
+  split(o, e, t) {
+    let r = [], s = "", i = !1, l = 0, a = !1, n = "", u = !1;
+    for (let h of o)
+      u ? u = !1 : h === "\\" ? u = !0 : a ? h === n && (a = !1) : h === '"' || h === "'" ? (a = !0, n = h) : h === "(" ? l += 1 : h === ")" ? l > 0 && (l -= 1) : l === 0 && e.includes(h) && (i = !0), i ? (s !== "" && r.push(s.trim()), s = "", i = !1) : s += h;
+    return (t || s !== "") && r.push(s.trim()), r;
+  }
+};
+var yt = N;
+N.default = N;
+let bt = v, hr = yt, ee = class extends bt {
+  constructor(e) {
+    super(e), this.type = "rule", this.nodes || (this.nodes = []);
+  }
+  get selectors() {
+    return hr.comma(this.selector);
+  }
+  set selectors(e) {
+    let t = this.selector ? this.selector.match(/,\s*/) : null, r = t ? t[0] : "," + this.raw("between", "beforeOpen");
+    this.selector = e.join(r);
+  }
+};
+var Le = ee;
+ee.default = ee;
+bt.registerRule(ee);
+let fr = ke, cr = ie, pr = ne, mr = oe, dr = mt, gr = z, wr = Le;
+function _(o, e) {
+  if (Array.isArray(o))
+    return o.map((s) => _(s));
+  let { inputs: t, ...r } = o;
+  if (t) {
+    e = [];
+    for (let s of t) {
+      let i = { ...s, __proto__: mr.prototype };
+      i.map && (i.map = {
+        ...i.map,
+        __proto__: dr.prototype
+      }), e.push(i);
+    }
+  }
+  if (r.nodes && (r.nodes = o.nodes.map((s) => _(s, e))), r.source) {
+    let { inputId: s, ...i } = r.source;
+    r.source = i, s != null && (r.source.input = e[s]);
+  }
+  if (r.type === "root")
+    return new gr(r);
+  if (r.type === "decl")
+    return new pr(r);
+  if (r.type === "rule")
+    return new wr(r);
+  if (r.type === "comment")
+    return new cr(r);
+  if (r.type === "atrule")
+    return new fr(r);
+  throw new Error("Unknown node type: " + o.type);
+}
+var yr = _;
+_.default = _;
+let { dirname: Y, relative: xt, resolve: St, sep: Ct } = y, { SourceMapConsumer: vt, SourceMapGenerator: Q } = y, { pathToFileURL: Je } = y, br = oe, xr = Boolean(vt && Q), Sr = Boolean(Y && St && xt && Ct), Cr = class {
+  constructor(e, t, r, s) {
+    this.stringify = e, this.mapOpts = r.map || {}, this.root = t, this.opts = r, this.css = s, this.originalCSS = s, 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 e;
+    this.isInline() ? e = "data:application/json;base64," + this.toBase64(this.map.toString()) : typeof this.mapOpts.annotation == "string" ? e = this.mapOpts.annotation : typeof this.mapOpts.annotation == "function" ? e = this.mapOpts.annotation(this.opts.to, this.root) : e = this.outputFile() + ".map";
+    let t = `
+`;
+    this.css.includes(`\r
+`) && (t = `\r
+`), this.css += t + "/*# sourceMappingURL=" + e + " */";
+  }
+  applyPrevMaps() {
+    for (let e of this.previous()) {
+      let t = this.toUrl(this.path(e.file)), r = e.root || Y(e.file), s;
+      this.mapOpts.sourcesContent === !1 ? (s = new vt(e.text), s.sourcesContent && (s.sourcesContent = null)) : s = e.consumer(), this.map.applySourceMap(s, t, this.toUrl(this.path(r)));
+    }
+  }
+  clearAnnotation() {
+    if (this.mapOpts.annotation !== !1)
+      if (this.root) {
+        let e;
+        for (let t = this.root.nodes.length - 1; t >= 0; t--)
+          e = this.root.nodes[t], e.type === "comment" && e.text.startsWith("# sourceMappingURL=") && this.root.removeChild(t);
+      } else
+        this.css && (this.css = this.css.replace(/\n*\/\*#[\S\s]*?\*\/$/gm, ""));
+  }
+  generate() {
+    if (this.clearAnnotation(), Sr && xr && this.isMap())
+      return this.generateMap();
+    {
+      let e = "";
+      return this.stringify(this.root, (t) => {
+        e += t;
+      }), [e];
+    }
+  }
+  generateMap() {
+    if (this.root)
+      this.generateString();
+    else if (this.previous().length === 1) {
+      let e = this.previous()[0].consumer();
+      e.file = this.outputFile(), this.map = Q.fromSourceMap(e, {
+        ignoreInvalidMapping: !0
+      });
+    } else
+      this.map = new Q({
+        file: this.outputFile(),
+        ignoreInvalidMapping: !0
+      }), this.map.addMapping({
+        generated: { column: 0, line: 1 },
+        original: { column: 0, line: 1 },
+        source: this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>"
+      });
+    return this.isSourcesContent() && this.setSourcesContent(), this.root && this.previous().length > 0 && this.applyPrevMaps(), this.isAnnotation() && this.addAnnotation(), this.isInline() ? [this.css] : [this.css, this.map];
+  }
+  generateString() {
+    this.css = "", this.map = new Q({
+      file: this.outputFile(),
+      ignoreInvalidMapping: !0
+    });
+    let e = 1, t = 1, r = "<no source>", s = {
+      generated: { column: 0, line: 0 },
+      original: { column: 0, line: 0 },
+      source: ""
+    }, i, l;
+    this.stringify(this.root, (a, n, u) => {
+      if (this.css += a, n && u !== "end" && (s.generated.line = e, s.generated.column = t - 1, n.source && n.source.start ? (s.source = this.sourcePath(n), s.original.line = n.source.start.line, s.original.column = n.source.start.column - 1, this.map.addMapping(s)) : (s.source = r, s.original.line = 1, s.original.column = 0, this.map.addMapping(s))), l = a.match(/\n/g), l ? (e += l.length, i = a.lastIndexOf(`
+`), t = a.length - i) : t += a.length, n && u !== "start") {
+        let h = n.parent || { raws: {} };
+        (!(n.type === "decl" || n.type === "atrule" && !n.nodes) || n !== h.last || h.raws.semicolon) && (n.source && n.source.end ? (s.source = this.sourcePath(n), s.original.line = n.source.end.line, s.original.column = n.source.end.column - 1, s.generated.line = e, s.generated.column = t - 2, this.map.addMapping(s)) : (s.source = r, s.original.line = 1, s.original.column = 0, s.generated.line = e, s.generated.column = t - 1, this.map.addMapping(s)));
+      }
+    });
+  }
+  isAnnotation() {
+    return this.isInline() ? !0 : typeof this.mapOpts.annotation < "u" ? this.mapOpts.annotation : this.previous().length ? this.previous().some((e) => e.annotation) : !0;
+  }
+  isInline() {
+    if (typeof this.mapOpts.inline < "u")
+      return this.mapOpts.inline;
+    let e = this.mapOpts.annotation;
+    return typeof e < "u" && e !== !0 ? !1 : this.previous().length ? this.previous().some((t) => t.inline) : !0;
+  }
+  isMap() {
+    return typeof this.opts.map < "u" ? !!this.opts.map : this.previous().length > 0;
+  }
+  isSourcesContent() {
+    return typeof this.mapOpts.sourcesContent < "u" ? this.mapOpts.sourcesContent : this.previous().length ? this.previous().some((e) => e.withContent()) : !0;
+  }
+  outputFile() {
+    return this.opts.to ? this.path(this.opts.to) : this.opts.from ? this.path(this.opts.from) : "to.css";
+  }
+  path(e) {
+    if (this.mapOpts.absolute || e.charCodeAt(0) === 60 || /^\w+:\/\//.test(e))
+      return e;
+    let t = this.memoizedPaths.get(e);
+    if (t)
+      return t;
+    let r = this.opts.to ? Y(this.opts.to) : ".";
+    typeof this.mapOpts.annotation == "string" && (r = Y(St(r, this.mapOpts.annotation)));
+    let s = xt(r, e);
+    return this.memoizedPaths.set(e, s), s;
+  }
+  previous() {
+    if (!this.previousMaps)
+      if (this.previousMaps = [], this.root)
+        this.root.walk((e) => {
+          if (e.source && e.source.input.map) {
+            let t = e.source.input.map;
+            this.previousMaps.includes(t) || this.previousMaps.push(t);
+          }
+        });
+      else {
+        let e = new br(this.originalCSS, this.opts);
+        e.map && this.previousMaps.push(e.map);
+      }
+    return this.previousMaps;
+  }
+  setSourcesContent() {
+    let e = {};
+    if (this.root)
+      this.root.walk((t) => {
+        if (t.source) {
+          let r = t.source.input.from;
+          if (r && !e[r]) {
+            e[r] = !0;
+            let s = this.usesFileUrls ? this.toFileUrl(r) : this.toUrl(this.path(r));
+            this.map.setSourceContent(s, t.source.input.css);
+          }
+        }
+      });
+    else if (this.css) {
+      let t = this.opts.from ? this.toUrl(this.path(this.opts.from)) : "<no source>";
+      this.map.setSourceContent(t, this.css);
+    }
+  }
+  sourcePath(e) {
+    return this.mapOpts.from ? this.toUrl(this.mapOpts.from) : this.usesFileUrls ? this.toFileUrl(e.source.input.from) : this.toUrl(this.path(e.source.input.from));
+  }
+  toBase64(e) {
+    return Buffer ? Buffer.from(e).toString("base64") : window.btoa(unescape(encodeURIComponent(e)));
+  }
+  toFileUrl(e) {
+    let t = this.memoizedFileURLs.get(e);
+    if (t)
+      return t;
+    if (Je) {
+      let r = Je(e).toString();
+      return this.memoizedFileURLs.set(e, r), r;
+    } else
+      throw new Error(
+        "`map.absolute` option is not available in this PostCSS build"
+      );
+  }
+  toUrl(e) {
+    let t = this.memoizedURLs.get(e);
+    if (t)
+      return t;
+    Ct === "\\" && (e = e.replace(/\\/g, "/"));
+    let r = encodeURI(e).replace(/[#?]/g, encodeURIComponent);
+    return this.memoizedURLs.set(e, r), r;
+  }
+};
+var Ot = Cr;
+const pe = "'".charCodeAt(0), He = '"'.charCodeAt(0), T = "\\".charCodeAt(0), Ye = "/".charCodeAt(0), W = `
+`.charCodeAt(0), I = " ".charCodeAt(0), j = "\f".charCodeAt(0), V = "	".charCodeAt(0), G = "\r".charCodeAt(0), vr = "[".charCodeAt(0), Or = "]".charCodeAt(0), Rr = "(".charCodeAt(0), $r = ")".charCodeAt(0), Er = "{".charCodeAt(0), Ar = "}".charCodeAt(0), Pr = ";".charCodeAt(0), Mr = "*".charCodeAt(0), kr = ":".charCodeAt(0), Ir = "@".charCodeAt(0), J = /[\t\n\f\r "#'()/;[\\\]{}]/g, H = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g, Lr = /.[\r\n"'(/\\]/, Qe = /[\da-f]/i;
+var Ur = function(e, t = {}) {
+  let r = e.css.valueOf(), s = t.ignoreErrors, i, l, a, n, u, h, m, d, g, O, S = r.length, f = 0, P = [], R = [];
+  function le() {
+    return f;
+  }
+  function ae($) {
+    throw e.error("Unclosed " + $, f);
+  }
+  function Nt() {
+    return R.length === 0 && f >= S;
+  }
+  function _t($) {
+    if (R.length)
+      return R.pop();
+    if (f >= S)
+      return;
+    let ue = $ ? $.ignoreUnclosed : !1;
+    switch (i = r.charCodeAt(f), i) {
+      case W:
+      case I:
+      case V:
+      case G:
+      case j: {
+        n = f;
+        do
+          n += 1, i = r.charCodeAt(n);
+        while (i === I || i === W || i === V || i === G || i === j);
+        h = ["space", r.slice(f, n)], f = n - 1;
+        break;
+      }
+      case vr:
+      case Or:
+      case Er:
+      case Ar:
+      case kr:
+      case Pr:
+      case $r: {
+        let Be = String.fromCharCode(i);
+        h = [Be, Be, f];
+        break;
+      }
+      case Rr: {
+        if (O = P.length ? P.pop()[1] : "", g = r.charCodeAt(f + 1), O === "url" && g !== pe && g !== He && g !== I && g !== W && g !== V && g !== j && g !== G) {
+          n = f;
+          do {
+            if (m = !1, n = r.indexOf(")", n + 1), n === -1)
+              if (s || ue) {
+                n = f;
+                break;
+              } else
+                ae("bracket");
+            for (d = n; r.charCodeAt(d - 1) === T; )
+              d -= 1, m = !m;
+          } while (m);
+          h = ["brackets", r.slice(f, n + 1), f, n], f = n;
+        } else
+          n = r.indexOf(")", f + 1), l = r.slice(f, n + 1), n === -1 || Lr.test(l) ? h = ["(", "(", f] : (h = ["brackets", l, f, n], f = n);
+        break;
+      }
+      case pe:
+      case He: {
+        u = i === pe ? "'" : '"', n = f;
+        do {
+          if (m = !1, n = r.indexOf(u, n + 1), n === -1)
+            if (s || ue) {
+              n = f + 1;
+              break;
+            } else
+              ae("string");
+          for (d = n; r.charCodeAt(d - 1) === T; )
+            d -= 1, m = !m;
+        } while (m);
+        h = ["string", r.slice(f, n + 1), f, n], f = n;
+        break;
+      }
+      case Ir: {
+        J.lastIndex = f + 1, J.test(r), J.lastIndex === 0 ? n = r.length - 1 : n = J.lastIndex - 2, h = ["at-word", r.slice(f, n + 1), f, n], f = n;
+        break;
+      }
+      case T: {
+        for (n = f, a = !0; r.charCodeAt(n + 1) === T; )
+          n += 1, a = !a;
+        if (i = r.charCodeAt(n + 1), a && i !== Ye && i !== I && i !== W && i !== V && i !== G && i !== j && (n += 1, Qe.test(r.charAt(n)))) {
+          for (; Qe.test(r.charAt(n + 1)); )
+            n += 1;
+          r.charCodeAt(n + 1) === I && (n += 1);
+        }
+        h = ["word", r.slice(f, n + 1), f, n], f = n;
+        break;
+      }
+      default: {
+        i === Ye && r.charCodeAt(f + 1) === Mr ? (n = r.indexOf("*/", f + 2) + 1, n === 0 && (s || ue ? n = r.length : ae("comment")), h = ["comment", r.slice(f, n + 1), f, n], f = n) : (H.lastIndex = f + 1, H.test(r), H.lastIndex === 0 ? n = r.length - 1 : n = H.lastIndex - 2, h = ["word", r.slice(f, n + 1), f, n], P.push(h), f = n);
+        break;
+      }
+    }
+    return f++, h;
+  }
+  function Bt($) {
+    R.push($);
+  }
+  return {
+    back: Bt,
+    endOfFile: Nt,
+    nextToken: _t,
+    position: le
+  };
+};
+let Nr = ke, _r = ie, Br = ne, Dr = z, qe = Le, zr = Ur;
+const Ke = {
+  empty: !0,
+  space: !0
+};
+function Fr(o) {
+  for (let e = o.length - 1; e >= 0; e--) {
+    let t = o[e], r = t[3] || t[2];
+    if (r)
+      return r;
+  }
+}
+let Tr = class {
+  constructor(e) {
+    this.input = e, this.root = new Dr(), this.current = this.root, this.spaces = "", this.semicolon = !1, this.createTokenizer(), this.root.source = { input: e, start: { column: 1, line: 1, offset: 0 } };
+  }
+  atrule(e) {
+    let t = new Nr();
+    t.name = e[1].slice(1), t.name === "" && this.unnamedAtrule(t, e), this.init(t, e[2]);
+    let r, s, i, l = !1, a = !1, n = [], u = [];
+    for (; !this.tokenizer.endOfFile(); ) {
+      if (e = this.tokenizer.nextToken(), r = e[0], r === "(" || r === "[" ? u.push(r === "(" ? ")" : "]") : r === "{" && u.length > 0 ? u.push("}") : r === u[u.length - 1] && u.pop(), u.length === 0)
+        if (r === ";") {
+          t.source.end = this.getPosition(e[2]), t.source.end.offset++, this.semicolon = !0;
+          break;
+        } else if (r === "{") {
+          a = !0;
+          break;
+        } else if (r === "}") {
+          if (n.length > 0) {
+            for (i = n.length - 1, s = n[i]; s && s[0] === "space"; )
+              s = n[--i];
+            s && (t.source.end = this.getPosition(s[3] || s[2]), t.source.end.offset++);
+          }
+          this.end(e);
+          break;
+        } else
+          n.push(e);
+      else
+        n.push(e);
+      if (this.tokenizer.endOfFile()) {
+        l = !0;
+        break;
+      }
+    }
+    t.raws.between = this.spacesAndCommentsFromEnd(n), n.length ? (t.raws.afterName = this.spacesAndCommentsFromStart(n), this.raw(t, "params", n), l && (e = n[n.length - 1], t.source.end = this.getPosition(e[3] || e[2]), t.source.end.offset++, this.spaces = t.raws.between, t.raws.between = "")) : (t.raws.afterName = "", t.params = ""), a && (t.nodes = [], this.current = t);
+  }
+  checkMissedSemicolon(e) {
+    let t = this.colon(e);
+    if (t === !1)
+      return;
+    let r = 0, s;
+    for (let i = t - 1; i >= 0 && (s = e[i], !(s[0] !== "space" && (r += 1, r === 2))); i--)
+      ;
+    throw this.input.error(
+      "Missed semicolon",
+      s[0] === "word" ? s[3] + 1 : s[2]
+    );
+  }
+  colon(e) {
+    let t = 0, r, s, i;
+    for (let [l, a] of e.entries()) {
+      if (s = a, i = s[0], i === "(" && (t += 1), i === ")" && (t -= 1), t === 0 && i === ":")
+        if (!r)
+          this.doubleColon(s);
+        else {
+          if (r[0] === "word" && r[1] === "progid")
+            continue;
+          return l;
+        }
+      r = s;
+    }
+    return !1;
+  }
+  comment(e) {
+    let t = new _r();
+    this.init(t, e[2]), t.source.end = this.getPosition(e[3] || e[2]), t.source.end.offset++;
+    let r = e[1].slice(2, -2);
+    if (/^\s*$/.test(r))
+      t.text = "", t.raws.left = r, t.raws.right = "";
+    else {
+      let s = r.match(/^(\s*)([^]*\S)(\s*)$/);
+      t.text = s[2], t.raws.left = s[1], t.raws.right = s[3];
+    }
+  }
+  createTokenizer() {
+    this.tokenizer = zr(this.input);
+  }
+  decl(e, t) {
+    let r = new Br();
+    this.init(r, e[0][2]);
+    let s = e[e.length - 1];
+    for (s[0] === ";" && (this.semicolon = !0, e.pop()), r.source.end = this.getPosition(
+      s[3] || s[2] || Fr(e)
+    ), r.source.end.offset++; e[0][0] !== "word"; )
+      e.length === 1 && this.unknownWord(e), r.raws.before += e.shift()[1];
+    for (r.source.start = this.getPosition(e[0][2]), r.prop = ""; e.length; ) {
+      let u = e[0][0];
+      if (u === ":" || u === "space" || u === "comment")
+        break;
+      r.prop += e.shift()[1];
+    }
+    r.raws.between = "";
+    let i;
+    for (; e.length; )
+      if (i = e.shift(), i[0] === ":") {
+        r.raws.between += i[1];
+        break;
+      } else
+        i[0] === "word" && /\w/.test(i[1]) && this.unknownWord([i]), r.raws.between += i[1];
+    (r.prop[0] === "_" || r.prop[0] === "*") && (r.raws.before += r.prop[0], r.prop = r.prop.slice(1));
+    let l = [], a;
+    for (; e.length && (a = e[0][0], !(a !== "space" && a !== "comment")); )
+      l.push(e.shift());
+    this.precheckMissedSemicolon(e);
+    for (let u = e.length - 1; u >= 0; u--) {
+      if (i = e[u], i[1].toLowerCase() === "!important") {
+        r.important = !0;
+        let h = this.stringFrom(e, u);
+        h = this.spacesFromEnd(e) + h, h !== " !important" && (r.raws.important = h);
+        break;
+      } else if (i[1].toLowerCase() === "important") {
+        let h = e.slice(0), m = "";
+        for (let d = u; d > 0; d--) {
+          let g = h[d][0];
+          if (m.trim().startsWith("!") && g !== "space")
+            break;
+          m = h.pop()[1] + m;
+        }
+        m.trim().startsWith("!") && (r.important = !0, r.raws.important = m, e = h);
+      }
+      if (i[0] !== "space" && i[0] !== "comment")
+        break;
+    }
+    e.some((u) => u[0] !== "space" && u[0] !== "comment") && (r.raws.between += l.map((u) => u[1]).join(""), l = []), this.raw(r, "value", l.concat(e), t), r.value.includes(":") && !t && this.checkMissedSemicolon(e);
+  }
+  doubleColon(e) {
+    throw this.input.error(
+      "Double colon",
+      { offset: e[2] },
+      { offset: e[2] + e[1].length }
+    );
+  }
+  emptyRule(e) {
+    let t = new qe();
+    this.init(t, e[2]), t.selector = "", t.raws.between = "", this.current = t;
+  }
+  end(e) {
+    this.current.nodes && this.current.nodes.length && (this.current.raws.semicolon = this.semicolon), this.semicolon = !1, this.current.raws.after = (this.current.raws.after || "") + this.spaces, this.spaces = "", this.current.parent ? (this.current.source.end = this.getPosition(e[2]), this.current.source.end.offset++, this.current = this.current.parent) : this.unexpectedClose(e);
+  }
+  endFile() {
+    this.current.parent && this.unclosedBlock(), 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(e) {
+    if (this.spaces += e[1], this.current.nodes) {
+      let t = this.current.nodes[this.current.nodes.length - 1];
+      t && t.type === "rule" && !t.raws.ownSemicolon && (t.raws.ownSemicolon = this.spaces, this.spaces = "", t.source.end = this.getPosition(e[2]), t.source.end.offset += t.raws.ownSemicolon.length);
+    }
+  }
+  // Helpers
+  getPosition(e) {
+    let t = this.input.fromOffset(e);
+    return {
+      column: t.col,
+      line: t.line,
+      offset: e
+    };
+  }
+  init(e, t) {
+    this.current.push(e), e.source = {
+      input: this.input,
+      start: this.getPosition(t)
+    }, e.raws.before = this.spaces, this.spaces = "", e.type !== "comment" && (this.semicolon = !1);
+  }
+  other(e) {
+    let t = !1, r = null, s = !1, i = null, l = [], a = e[1].startsWith("--"), n = [], u = e;
+    for (; u; ) {
+      if (r = u[0], n.push(u), r === "(" || r === "[")
+        i || (i = u), l.push(r === "(" ? ")" : "]");
+      else if (a && s && r === "{")
+        i || (i = u), l.push("}");
+      else if (l.length === 0)
+        if (r === ";")
+          if (s) {
+            this.decl(n, a);
+            return;
+          } else
+            break;
+        else if (r === "{") {
+          this.rule(n);
+          return;
+        } else if (r === "}") {
+          this.tokenizer.back(n.pop()), t = !0;
+          break;
+        } else
+          r === ":" && (s = !0);
+      else
+        r === l[l.length - 1] && (l.pop(), l.length === 0 && (i = null));
+      u = this.tokenizer.nextToken();
+    }
+    if (this.tokenizer.endOfFile() && (t = !0), l.length > 0 && this.unclosedBracket(i), t && s) {
+      if (!a)
+        for (; n.length && (u = n[n.length - 1][0], !(u !== "space" && u !== "comment")); )
+          this.tokenizer.back(n.pop());
+      this.decl(n, a);
+    } else
+      this.unknownWord(n);
+  }
+  parse() {
+    let e;
+    for (; !this.tokenizer.endOfFile(); )
+      switch (e = this.tokenizer.nextToken(), e[0]) {
+        case "space":
+          this.spaces += e[1];
+          break;
+        case ";":
+          this.freeSemicolon(e);
+          break;
+        case "}":
+          this.end(e);
+          break;
+        case "comment":
+          this.comment(e);
+          break;
+        case "at-word":
+          this.atrule(e);
+          break;
+        case "{":
+          this.emptyRule(e);
+          break;
+        default:
+          this.other(e);
+          break;
+      }
+    this.endFile();
+  }
+  precheckMissedSemicolon() {
+  }
+  raw(e, t, r, s) {
+    let i, l, a = r.length, n = "", u = !0, h, m;
+    for (let d = 0; d < a; d += 1)
+      i = r[d], l = i[0], l === "space" && d === a - 1 && !s ? u = !1 : l === "comment" ? (m = r[d - 1] ? r[d - 1][0] : "empty", h = r[d + 1] ? r[d + 1][0] : "empty", !Ke[m] && !Ke[h] ? n.slice(-1) === "," ? u = !1 : n += i[1] : u = !1) : n += i[1];
+    if (!u) {
+      let d = r.reduce((g, O) => g + O[1], "");
+      e.raws[t] = { raw: d, value: n };
+    }
+    e[t] = n;
+  }
+  rule(e) {
+    e.pop();
+    let t = new qe();
+    this.init(t, e[0][2]), t.raws.between = this.spacesAndCommentsFromEnd(e), this.raw(t, "selector", e), this.current = t;
+  }
+  spacesAndCommentsFromEnd(e) {
+    let t, r = "";
+    for (; e.length && (t = e[e.length - 1][0], !(t !== "space" && t !== "comment")); )
+      r = e.pop()[1] + r;
+    return r;
+  }
+  // Errors
+  spacesAndCommentsFromStart(e) {
+    let t, r = "";
+    for (; e.length && (t = e[0][0], !(t !== "space" && t !== "comment")); )
+      r += e.shift()[1];
+    return r;
+  }
+  spacesFromEnd(e) {
+    let t, r = "";
+    for (; e.length && (t = e[e.length - 1][0], t === "space"); )
+      r = e.pop()[1] + r;
+    return r;
+  }
+  stringFrom(e, t) {
+    let r = "";
+    for (let s = t; s < e.length; s++)
+      r += e[s][1];
+    return e.splice(t, e.length - t), r;
+  }
+  unclosedBlock() {
+    let e = this.current.source.start;
+    throw this.input.error("Unclosed block", e.line, e.column);
+  }
+  unclosedBracket(e) {
+    throw this.input.error(
+      "Unclosed bracket",
+      { offset: e[2] },
+      { offset: e[2] + 1 }
+    );
+  }
+  unexpectedClose(e) {
+    throw this.input.error(
+      "Unexpected }",
+      { offset: e[2] },
+      { offset: e[2] + 1 }
+    );
+  }
+  unknownWord(e) {
+    throw this.input.error(
+      "Unknown word",
+      { offset: e[0][2] },
+      { offset: e[0][2] + e[0][1].length }
+    );
+  }
+  unnamedAtrule(e, t) {
+    throw this.input.error(
+      "At-rule without name",
+      { offset: t[2] },
+      { offset: t[2] + t[1].length }
+    );
+  }
+};
+var Wr = Tr;
+let jr = v, Vr = oe, Gr = Wr;
+function te(o, e) {
+  let t = new Vr(o, e), r = new Gr(t);
+  try {
+    r.parse();
+  } catch (s) {
+    throw process.env.NODE_ENV !== "production" && s.name === "CssSyntaxError" && e && e.from && (/\.scss$/i.test(e.from) ? s.message += `
+You tried to parse SCSS with the standard CSS parser; try again with the postcss-scss parser` : /\.sass/i.test(e.from) ? s.message += `
+You tried to parse Sass with the standard CSS parser; try again with the postcss-sass parser` : /\.less$/i.test(e.from) && (s.message += `
+You tried to parse Less with the standard CSS parser; try again with the postcss-less parser`)), s;
+  }
+  return r.root;
+}
+var Ue = te;
+te.default = te;
+jr.registerParse(te);
+let ve = class {
+  constructor(e, t = {}) {
+    if (this.type = "warning", this.text = e, t.node && t.node.source) {
+      let r = t.node.rangeBy(t);
+      this.line = r.start.line, this.column = r.start.column, this.endLine = r.end.line, this.endColumn = r.end.column;
+    }
+    for (let r in t)
+      this[r] = t[r];
+  }
+  toString() {
+    return this.node ? this.node.error(this.text, {
+      index: this.index,
+      plugin: this.plugin,
+      word: this.word
+    }).message : this.plugin ? this.plugin + ": " + this.text : this.text;
+  }
+};
+var Rt = ve;
+ve.default = ve;
+let Jr = Rt, Oe = class {
+  constructor(e, t, r) {
+    this.processor = e, this.messages = [], this.root = t, this.opts = r, this.css = void 0, this.map = void 0;
+  }
+  toString() {
+    return this.css;
+  }
+  warn(e, t = {}) {
+    t.plugin || this.lastPlugin && this.lastPlugin.postcssPlugin && (t.plugin = this.lastPlugin.postcssPlugin);
+    let r = new Jr(e, t);
+    return this.messages.push(r), r;
+  }
+  warnings() {
+    return this.messages.filter((e) => e.type === "warning");
+  }
+  get content() {
+    return this.css;
+  }
+};
+var Ne = Oe;
+Oe.default = Oe;
+let Xe = {};
+var $t = function(e) {
+  Xe[e] || (Xe[e] = !0, typeof console < "u" && console.warn && console.warn(e));
+};
+let Hr = v, Yr = Ie, Qr = Ot, qr = Ue, Ze = Ne, Kr = z, Xr = re, { isClean: b, my: Zr } = D, es = $t;
+const ts = {
+  atrule: "AtRule",
+  comment: "Comment",
+  decl: "Declaration",
+  document: "Document",
+  root: "Root",
+  rule: "Rule"
+}, rs = {
+  AtRule: !0,
+  AtRuleExit: !0,
+  Comment: !0,
+  CommentExit: !0,
+  Declaration: !0,
+  DeclarationExit: !0,
+  Document: !0,
+  DocumentExit: !0,
+  Once: !0,
+  OnceExit: !0,
+  postcssPlugin: !0,
+  prepare: !0,
+  Root: !0,
+  RootExit: !0,
+  Rule: !0,
+  RuleExit: !0
+}, ss = {
+  Once: !0,
+  postcssPlugin: !0,
+  prepare: !0
+}, A = 0;
+function L(o) {
+  return typeof o == "object" && typeof o.then == "function";
+}
+function Et(o) {
+  let e = !1, t = ts[o.type];
+  return o.type === "decl" ? e = o.prop.toLowerCase() : o.type === "atrule" && (e = o.name.toLowerCase()), e && o.append ? [
+    t,
+    t + "-" + e,
+    A,
+    t + "Exit",
+    t + "Exit-" + e
+  ] : e ? [t, t + "-" + e, t + "Exit", t + "Exit-" + e] : o.append ? [t, A, t + "Exit"] : [t, t + "Exit"];
+}
+function et(o) {
+  let e;
+  return o.type === "document" ? e = ["Document", A, "DocumentExit"] : o.type === "root" ? e = ["Root", A, "RootExit"] : e = Et(o), {
+    eventIndex: 0,
+    events: e,
+    iterator: 0,
+    node: o,
+    visitorIndex: 0,
+    visitors: []
+  };
+}
+function Re(o) {
+  return o[b] = !1, o.nodes && o.nodes.forEach((e) => Re(e)), o;
+}
+let $e = {}, C = class {
+  constructor(e, t, r) {
+    this.stringified = !1, this.processed = !1;
+    let s;
+    if (typeof t == "object" && t !== null && (t.type === "root" || t.type === "document"))
+      s = Re(t);
+    else if (t instanceof C || t instanceof Ze)
+      s = Re(t.root), t.map && (typeof r.map > "u" && (r.map = {}), r.map.inline || (r.map.inline = !1), r.map.prev = t.map);
+    else {
+      let i = qr;
+      r.syntax && (i = r.syntax.parse), r.parser && (i = r.parser), i.parse && (i = i.parse);
+      try {
+        s = i(t, r);
+      } catch (l) {
+        this.processed = !0, this.error = l;
+      }
+      s && !s[Zr] && Hr.rebuild(s);
+    }
+    this.result = new Ze(e, s, r), this.helpers = { ...$e, postcss: $e, result: this.result }, this.plugins = this.processor.plugins.map((i) => typeof i == "object" && i.prepare ? { ...i, ...i.prepare(this.result) } : i);
+  }
+  async() {
+    return this.error ? Promise.reject(this.error) : this.processed ? Promise.resolve(this.result) : (this.processing || (this.processing = this.runAsync()), this.processing);
+  }
+  catch(e) {
+    return this.async().catch(e);
+  }
+  finally(e) {
+    return this.async().then(e, e);
+  }
+  getAsyncError() {
+    throw new Error("Use process(css).then(cb) to work with async plugins");
+  }
+  handleError(e, t) {
+    let r = this.result.lastPlugin;
+    try {
+      if (t && t.addToError(e), this.error = e, e.name === "CssSyntaxError" && !e.plugin)
+        e.plugin = r.postcssPlugin, e.setMessage();
+      else if (r.postcssVersion && process.env.NODE_ENV !== "production") {
+        let s = r.postcssPlugin, i = r.postcssVersion, l = this.result.processor.version, a = i.split("."), n = l.split(".");
+        (a[0] !== n[0] || parseInt(a[1]) > parseInt(n[1])) && console.error(
+          "Unknown error from PostCSS plugin. Your current PostCSS version is " + l + ", but " + s + " uses " + i + ". Perhaps this is the source of the error below."
+        );
+      }
+    } catch (s) {
+      console && console.error && console.error(s);
+    }
+    return e;
+  }
+  prepareVisitors() {
+    this.listeners = {};
+    let e = (t, r, s) => {
+      this.listeners[r] || (this.listeners[r] = []), this.listeners[r].push([t, s]);
+    };
+    for (let t of this.plugins)
+      if (typeof t == "object")
+        for (let r in t) {
+          if (!rs[r] && /^[A-Z]/.test(r))
+            throw new Error(
+              `Unknown event ${r} in ${t.postcssPlugin}. Try to update PostCSS (${this.processor.version} now).`
+            );
+          if (!ss[r])
+            if (typeof t[r] == "object")
+              for (let s in t[r])
+                s === "*" ? e(t, r, t[r][s]) : e(
+                  t,
+                  r + "-" + s.toLowerCase(),
+                  t[r][s]
+                );
+            else
+              typeof t[r] == "function" && e(t, r, t[r]);
+        }
+    this.hasListener = Object.keys(this.listeners).length > 0;
+  }
+  async runAsync() {
+    this.plugin = 0;
+    for (let e = 0; e < this.plugins.length; e++) {
+      let t = this.plugins[e], r = this.runOnRoot(t);
+      if (L(r))
+        try {
+          await r;
+        } catch (s) {
+          throw this.handleError(s);
+        }
+    }
+    if (this.prepareVisitors(), this.hasListener) {
+      let e = this.result.root;
+      for (; !e[b]; ) {
+        e[b] = !0;
+        let t = [et(e)];
+        for (; t.length > 0; ) {
+          let r = this.visitTick(t);
+          if (L(r))
+            try {
+              await r;
+            } catch (s) {
+              let i = t[t.length - 1].node;
+              throw this.handleError(s, i);
+            }
+        }
+      }
+      if (this.listeners.OnceExit)
+        for (let [t, r] of this.listeners.OnceExit) {
+          this.result.lastPlugin = t;
+          try {
+            if (e.type === "document") {
+              let s = e.nodes.map(
+                (i) => r(i, this.helpers)
+              );
+              await Promise.all(s);
+            } else
+              await r(e, this.helpers);
+          } catch (s) {
+            throw this.handleError(s);
+          }
+        }
+    }
+    return this.processed = !0, this.stringify();
+  }
+  runOnRoot(e) {
+    this.result.lastPlugin = e;
+    try {
+      if (typeof e == "object" && e.Once) {
+        if (this.result.root.type === "document") {
+          let t = this.result.root.nodes.map(
+            (r) => e.Once(r, this.helpers)
+          );
+          return L(t[0]) ? Promise.all(t) : t;
+        }
+        return e.Once(this.result.root, this.helpers);
+      } else if (typeof e == "function")
+        return e(this.result.root, this.result);
+    } catch (t) {
+      throw this.handleError(t);
+    }
+  }
+  stringify() {
+    if (this.error)
+      throw this.error;
+    if (this.stringified)
+      return this.result;
+    this.stringified = !0, this.sync();
+    let e = this.result.opts, t = Xr;
+    e.syntax && (t = e.syntax.stringify), e.stringifier && (t = e.stringifier), t.stringify && (t = t.stringify);
+    let s = new Qr(t, this.result.root, this.result.opts).generate();
+    return this.result.css = s[0], this.result.map = s[1], this.result;
+  }
+  sync() {
+    if (this.error)
+      throw this.error;
+    if (this.processed)
+      return this.result;
+    if (this.processed = !0, this.processing)
+      throw this.getAsyncError();
+    for (let e of this.plugins) {
+      let t = this.runOnRoot(e);
+      if (L(t))
+        throw this.getAsyncError();
+    }
+    if (this.prepareVisitors(), this.hasListener) {
+      let e = this.result.root;
+      for (; !e[b]; )
+        e[b] = !0, this.walkSync(e);
+      if (this.listeners.OnceExit)
+        if (e.type === "document")
+          for (let t of e.nodes)
+            this.visitSync(this.listeners.OnceExit, t);
+        else
+          this.visitSync(this.listeners.OnceExit, e);
+    }
+    return this.result;
+  }
+  then(e, t) {
+    return process.env.NODE_ENV !== "production" && ("from" in this.opts || es(
+      "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."
+    )), this.async().then(e, t);
+  }
+  toString() {
+    return this.css;
+  }
+  visitSync(e, t) {
+    for (let [r, s] of e) {
+      this.result.lastPlugin = r;
+      let i;
+      try {
+        i = s(t, this.helpers);
+      } catch (l) {
+        throw this.handleError(l, t.proxyOf);
+      }
+      if (t.type !== "root" && t.type !== "document" && !t.parent)
+        return !0;
+      if (L(i))
+        throw this.getAsyncError();
+    }
+  }
+  visitTick(e) {
+    let t = e[e.length - 1], { node: r, visitors: s } = t;
+    if (r.type !== "root" && r.type !== "document" && !r.parent) {
+      e.pop();
+      return;
+    }
+    if (s.length > 0 && t.visitorIndex < s.length) {
+      let [l, a] = s[t.visitorIndex];
+      t.visitorIndex += 1, t.visitorIndex === s.length && (t.visitors = [], t.visitorIndex = 0), this.result.lastPlugin = l;
+      try {
+        return a(r.toProxy(), this.helpers);
+      } catch (n) {
+        throw this.handleError(n, r);
+      }
+    }
+    if (t.iterator !== 0) {
+      let l = t.iterator, a;
+      for (; a = r.nodes[r.indexes[l]]; )
+        if (r.indexes[l] += 1, !a[b]) {
+          a[b] = !0, e.push(et(a));
+          return;
+        }
+      t.iterator = 0, delete r.indexes[l];
+    }
+    let i = t.events;
+    for (; t.eventIndex < i.length; ) {
+      let l = i[t.eventIndex];
+      if (t.eventIndex += 1, l === A) {
+        r.nodes && r.nodes.length && (r[b] = !0, t.iterator = r.getIterator());
+        return;
+      } else if (this.listeners[l]) {
+        t.visitors = this.listeners[l];
+        return;
+      }
+    }
+    e.pop();
+  }
+  walkSync(e) {
+    e[b] = !0;
+    let t = Et(e);
+    for (let r of t)
+      if (r === A)
+        e.nodes && e.each((s) => {
+          s[b] || this.walkSync(s);
+        });
+      else {
+        let s = this.listeners[r];
+        if (s && this.visitSync(s, e.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";
+  }
+};
+C.registerPostcss = (o) => {
+  $e = o;
+};
+var At = C;
+C.default = C;
+Kr.registerLazyResult(C);
+Yr.registerLazyResult(C);
+let is = Ot, ns = Ue;
+const os = Ne;
+let ls = re, as = $t, Ee = class {
+  constructor(e, t, r) {
+    t = t.toString(), this.stringified = !1, this._processor = e, this._css = t, this._opts = r, this._map = void 0;
+    let s, i = ls;
+    this.result = new os(this._processor, s, this._opts), this.result.css = t;
+    let l = this;
+    Object.defineProperty(this.result, "root", {
+      get() {
+        return l.root;
+      }
+    });
+    let a = new is(i, s, this._opts, t);
+    if (a.isMap()) {
+      let [n, u] = a.generate();
+      n && (this.result.css = n), u && (this.result.map = u);
+    } else
+      a.clearAnnotation(), this.result.css = a.css;
+  }
+  async() {
+    return this.error ? Promise.reject(this.error) : Promise.resolve(this.result);
+  }
+  catch(e) {
+    return this.async().catch(e);
+  }
+  finally(e) {
+    return this.async().then(e, e);
+  }
+  sync() {
+    if (this.error)
+      throw this.error;
+    return this.result;
+  }
+  then(e, t) {
+    return process.env.NODE_ENV !== "production" && ("from" in this._opts || as(
+      "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."
+    )), this.async().then(e, t);
+  }
+  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 e, t = ns;
+    try {
+      e = t(this._css, this._opts);
+    } catch (r) {
+      this.error = r;
+    }
+    if (this.error)
+      throw this.error;
+    return this._root = e, e;
+  }
+  get [Symbol.toStringTag]() {
+    return "NoWorkResult";
+  }
+};
+var us = Ee;
+Ee.default = Ee;
+let hs = Ie, fs = At, cs = us, ps = z, B = class {
+  constructor(e = []) {
+    this.version = "8.5.2", this.plugins = this.normalize(e);
+  }
+  normalize(e) {
+    let t = [];
+    for (let r of e)
+      if (r.postcss === !0 ? r = r() : r.postcss && (r = r.postcss), typeof r == "object" && Array.isArray(r.plugins))
+        t = t.concat(r.plugins);
+      else if (typeof r == "object" && r.postcssPlugin)
+        t.push(r);
+      else if (typeof r == "function")
+        t.push(r);
+      else if (typeof r == "object" && (r.parse || r.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(r + " is not a PostCSS plugin");
+    return t;
+  }
+  process(e, t = {}) {
+    return !this.plugins.length && !t.parser && !t.stringifier && !t.syntax ? new cs(this, e, t) : new fs(this, e, t);
+  }
+  use(e) {
+    return this.plugins = this.plugins.concat(this.normalize([e])), this;
+  }
+};
+var ms = B;
+B.default = B;
+ps.registerProcessor(B);
+hs.registerProcessor(B);
+let Pt = ke, Mt = ie, ds = v, gs = Ae, kt = ne, It = Ie, ws = yr, ys = oe, bs = At, xs = yt, Ss = se, Cs = Ue, _e = ms, vs = Ne, Lt = z, Ut = Le, Os = re, Rs = Rt;
+function p(...o) {
+  return o.length === 1 && Array.isArray(o[0]) && (o = o[0]), new _e(o);
+}
+p.plugin = function(e, t) {
+  let r = !1;
+  function s(...l) {
+    console && console.warn && !r && (r = !0, console.warn(
+      e + `: postcss.plugin was deprecated. Migration guide:
+https://evilmartians.com/chronicles/postcss-8-plugin-migration`
+    ), process.env.LANG && process.env.LANG.startsWith("cn") && console.warn(
+      e + `: 里面 postcss.plugin 被弃用. 迁移指南:
+https://www.w3ctech.com/topic/2226`
+    ));
+    let a = t(...l);
+    return a.postcssPlugin = e, a.postcssVersion = new _e().version, a;
+  }
+  let i;
+  return Object.defineProperty(s, "postcss", {
+    get() {
+      return i || (i = s()), i;
+    }
+  }), s.process = function(l, a, n) {
+    return p([s(n)]).process(l, a);
+  }, s;
+};
+p.stringify = Os;
+p.parse = Cs;
+p.fromJSON = ws;
+p.list = xs;
+p.comment = (o) => new Mt(o);
+p.atRule = (o) => new Pt(o);
+p.decl = (o) => new kt(o);
+p.rule = (o) => new Ut(o);
+p.root = (o) => new Lt(o);
+p.document = (o) => new It(o);
+p.CssSyntaxError = gs;
+p.Declaration = kt;
+p.Container = ds;
+p.Processor = _e;
+p.Document = It;
+p.Comment = Mt;
+p.Warning = Rs;
+p.AtRule = Pt;
+p.Result = vs;
+p.Input = ys;
+p.Rule = Ut;
+p.Root = Lt;
+p.Node = Ss;
+bs.registerPostcss(p);
+var $s = p;
+p.default = p;
+const w = $s, ri = w.stringify, si = w.fromJSON, ii = w.plugin, ni = w.parse, oi = w.list, li = w.document, ai = w.comment, ui = w.atRule, hi = w.rule, fi = w.decl, ci = w.root, pi = w.CssSyntaxError, mi = w.Declaration, di = w.Container, gi = w.Processor, wi = w.Document, yi = w.Comment, bi = w.Warning, xi = w.AtRule, Si = w.Result, Ci = w.Input, vi = w.Rule, Oi = w.Root, Ri = w.Node;
+export {
+  xi as AtRule,
+  yi as Comment,
+  di as Container,
+  pi as CssSyntaxError,
+  mi as Declaration,
+  wi as Document,
+  Ci as Input,
+  Ri as Node,
+  gi as Processor,
+  Si as Result,
+  Oi as Root,
+  vi as Rule,
+  bi as Warning,
+  ui as atRule,
+  ai as comment,
+  fi as decl,
+  w as default,
+  li as document,
+  si as fromJSON,
+  oi as list,
+  ni as parse,
+  ii as plugin,
+  ci as root,
+  hi as rule,
+  ri as stringify
+};