@anhnv/lexical-playground 0.39.0

package/dist/postcss-CCzdrMa5.js

@@ -0,0 +1,4735 @@
+import { g as ua } from "./_commonjsHelpers-C6fGbg64.js";
+function la(Se, ft) {
+  for (var ce = 0; ce < ft.length; ce++) {
+    const Y = ft[ce];
+    if (typeof Y != "string" && !Array.isArray(Y)) {
+      for (const ee in Y)
+        if (ee !== "default" && !(ee in Se)) {
+          const Ae = Object.getOwnPropertyDescriptor(Y, ee);
+          Ae && Object.defineProperty(Se, ee, Ae.get ? Ae : {
+            enumerable: !0,
+            get: () => Y[ee]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(Se, Symbol.toStringTag, { value: "Module" }));
+}
+var Ht = { exports: {} }, os;
+function ca() {
+  return os || (os = 1, (function(Se, ft) {
+    (function(ce) {
+      function Y() {
+        var ee = ce();
+        return ee.default || ee;
+      }
+      Se.exports = Y();
+    })(function() {
+      var ce = Object.create, Y = Object.defineProperty, ee = Object.getOwnPropertyDescriptor, Ae = Object.getOwnPropertyNames, cs = Object.getPrototypeOf, ps = Object.prototype.hasOwnProperty, S = (e, s) => () => (s || e((s = { exports: {} }).exports, s), s.exports), Jt = (e, s) => {
+        for (var i in s) Y(e, i, { get: s[i], enumerable: !0 });
+      }, Qt = (e, s, i, r) => {
+        if (s && typeof s == "object" || typeof s == "function") for (let a of Ae(s)) !ps.call(e, a) && a !== i && Y(e, a, { get: () => s[a], enumerable: !(r = ee(s, a)) || r.enumerable });
+        return e;
+      }, me = (e, s, i) => (i = e != null ? ce(cs(e)) : {}, Qt(Y(i, "default", { value: e, enumerable: !0 }), e)), hs = (e) => Qt(Y({}, "__esModule", { value: !0 }), e), fs = S((e, s) => {
+        var i = String, r = function() {
+          return { isColorSupported: !1, reset: i, bold: i, dim: i, italic: i, underline: i, inverse: i, hidden: i, strikethrough: i, black: i, red: i, green: i, yellow: i, blue: i, magenta: i, cyan: i, white: i, gray: i, bgBlack: i, bgRed: i, bgGreen: i, bgYellow: i, bgBlue: i, bgMagenta: i, bgCyan: i, bgWhite: i, blackBright: i, redBright: i, greenBright: i, yellowBright: i, blueBright: i, magentaBright: i, cyanBright: i, whiteBright: i, bgBlackBright: i, bgRedBright: i, bgGreenBright: i, bgYellowBright: i, bgBlueBright: i, bgMagentaBright: i, bgCyanBright: i, bgWhiteBright: i };
+        };
+        s.exports = r(), s.exports.createColors = r;
+      }), Zt = S(() => {
+      }), dt = S((e, s) => {
+        var i = fs(), r = Zt(), a = class is extends Error {
+          constructor(u, p, y, m, n, t) {
+            super(u), this.name = "CssSyntaxError", this.reason = u, n && (this.file = n), m && (this.source = m), t && (this.plugin = t), typeof p < "u" && typeof y < "u" && (typeof p == "number" ? (this.line = p, this.column = y) : (this.line = p.line, this.column = p.column, this.endLine = y.line, this.endColumn = y.column)), this.setMessage(), Error.captureStackTrace && Error.captureStackTrace(this, is);
+          }
+          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(u) {
+            if (!this.source) return "";
+            let p = this.source;
+            u == null && (u = i.isColorSupported);
+            let y = (l) => l, m = (l) => l, n = (l) => l;
+            if (u) {
+              let { bold: l, gray: w, red: v } = i.createColors(!0);
+              m = (f) => l(v(f)), y = (f) => w(f), r && (n = (f) => r(f));
+            }
+            let t = p.split(/\r?\n/), h = Math.max(this.line - 3, 0), c = Math.min(this.line + 2, t.length), d = String(c).length;
+            return t.slice(h, c).map((l, w) => {
+              let v = h + 1 + w, f = " " + (" " + v).slice(-d) + " | ";
+              if (v === this.line) {
+                if (l.length > 160) {
+                  let T = 20, b = Math.max(0, this.column - T), x = Math.max(this.column + T, this.endColumn + T), k = l.slice(b, x), O = y(f.replace(/\d/g, " ")) + l.slice(0, Math.min(this.column - 1, T - 1)).replace(/[^\t]/g, " ");
+                  return m(">") + y(f) + n(k) + `
+ ` + O + m("^");
+                }
+                let g = y(f.replace(/\d/g, " ")) + l.slice(0, this.column - 1).replace(/[^\t]/g, " ");
+                return m(">") + y(f) + n(l) + `
+ ` + g + m("^");
+              }
+              return " " + y(f) + n(l);
+            }).join(`
+`);
+          }
+          toString() {
+            let u = this.showSourceCode();
+            return u && (u = `
+
+` + u + `
+`), this.name + ": " + this.message + u;
+          }
+        };
+        s.exports = a, a.default = a;
+      }), mt = S((e, s) => {
+        var i = { after: `
+`, beforeClose: `
+`, beforeComment: `
+`, beforeDecl: `
+`, beforeOpen: " ", beforeRule: `
+`, colon: ": ", commentLeft: " ", commentRight: " ", emptyBody: "", indent: "    ", semicolon: !1 };
+        function r(o) {
+          return o[0].toUpperCase() + o.slice(1);
+        }
+        var a = class {
+          constructor(o) {
+            this.builder = o;
+          }
+          atrule(o, u) {
+            let p = "@" + o.name, y = o.params ? this.rawValue(o, "params") : "";
+            if (typeof o.raws.afterName < "u" ? p += o.raws.afterName : y && (p += " "), o.nodes) this.block(o, p + y);
+            else {
+              let m = (o.raws.between || "") + (u ? ";" : "");
+              this.builder(p + y + m, o);
+            }
+          }
+          beforeAfter(o, u) {
+            let p;
+            o.type === "decl" ? p = this.raw(o, null, "beforeDecl") : o.type === "comment" ? p = this.raw(o, null, "beforeComment") : u === "before" ? p = this.raw(o, null, "beforeRule") : p = this.raw(o, null, "beforeClose");
+            let y = o.parent, m = 0;
+            for (; y && y.type !== "root"; ) m += 1, y = y.parent;
+            if (p.includes(`
+`)) {
+              let n = this.raw(o, null, "indent");
+              if (n.length) for (let t = 0; t < m; t++) p += n;
+            }
+            return p;
+          }
+          block(o, u) {
+            let p = this.raw(o, "between", "beforeOpen");
+            this.builder(u + p + "{", o, "start");
+            let y;
+            o.nodes && o.nodes.length ? (this.body(o), y = this.raw(o, "after")) : y = this.raw(o, "after", "emptyBody"), y && this.builder(y), this.builder("}", o, "end");
+          }
+          body(o) {
+            let u = o.nodes.length - 1;
+            for (; u > 0 && o.nodes[u].type === "comment"; ) u -= 1;
+            let p = this.raw(o, "semicolon");
+            for (let y = 0; y < o.nodes.length; y++) {
+              let m = o.nodes[y], n = this.raw(m, "before");
+              n && this.builder(n), this.stringify(m, u !== y || p);
+            }
+          }
+          comment(o) {
+            let u = this.raw(o, "left", "commentLeft"), p = this.raw(o, "right", "commentRight");
+            this.builder("/*" + u + o.text + p + "*/", o);
+          }
+          decl(o, u) {
+            let p = this.raw(o, "between", "colon"), y = o.prop + p + this.rawValue(o, "value");
+            o.important && (y += o.raws.important || " !important"), u && (y += ";"), this.builder(y, o);
+          }
+          document(o) {
+            this.body(o);
+          }
+          raw(o, u, p) {
+            let y;
+            if (p || (p = u), u && (y = o.raws[u], typeof y < "u")) return y;
+            let m = o.parent;
+            if (p === "before" && (!m || m.type === "root" && m.first === o || m && m.type === "document")) return "";
+            if (!m) return i[p];
+            let n = o.root();
+            if (n.rawCache || (n.rawCache = {}), typeof n.rawCache[p] < "u") return n.rawCache[p];
+            if (p === "before" || p === "after") return this.beforeAfter(o, p);
+            {
+              let t = "raw" + r(p);
+              this[t] ? y = this[t](n, o) : n.walk((h) => {
+                if (y = h.raws[u], typeof y < "u") return !1;
+              });
+            }
+            return typeof y > "u" && (y = i[p]), n.rawCache[p] = y, y;
+          }
+          rawBeforeClose(o) {
+            let u;
+            return o.walk((p) => {
+              if (p.nodes && p.nodes.length > 0 && typeof p.raws.after < "u") return u = p.raws.after, u.includes(`
+`) && (u = u.replace(/[^\n]+$/, "")), !1;
+            }), u && (u = u.replace(/\S/g, "")), u;
+          }
+          rawBeforeComment(o, u) {
+            let p;
+            return o.walkComments((y) => {
+              if (typeof y.raws.before < "u") return p = y.raws.before, p.includes(`
+`) && (p = p.replace(/[^\n]+$/, "")), !1;
+            }), typeof p > "u" ? p = this.raw(u, null, "beforeDecl") : p && (p = p.replace(/\S/g, "")), p;
+          }
+          rawBeforeDecl(o, u) {
+            let p;
+            return o.walkDecls((y) => {
+              if (typeof y.raws.before < "u") return p = y.raws.before, p.includes(`
+`) && (p = p.replace(/[^\n]+$/, "")), !1;
+            }), typeof p > "u" ? p = this.raw(u, null, "beforeRule") : p && (p = p.replace(/\S/g, "")), p;
+          }
+          rawBeforeOpen(o) {
+            let u;
+            return o.walk((p) => {
+              if (p.type !== "decl" && (u = p.raws.between, typeof u < "u")) return !1;
+            }), u;
+          }
+          rawBeforeRule(o) {
+            let u;
+            return o.walk((p) => {
+              if (p.nodes && (p.parent !== o || o.first !== p) && typeof p.raws.before < "u") return u = p.raws.before, u.includes(`
+`) && (u = u.replace(/[^\n]+$/, "")), !1;
+            }), u && (u = u.replace(/\S/g, "")), u;
+          }
+          rawColon(o) {
+            let u;
+            return o.walkDecls((p) => {
+              if (typeof p.raws.between < "u") return u = p.raws.between.replace(/[^\s:]/g, ""), !1;
+            }), u;
+          }
+          rawEmptyBody(o) {
+            let u;
+            return o.walk((p) => {
+              if (p.nodes && p.nodes.length === 0 && (u = p.raws.after, typeof u < "u")) return !1;
+            }), u;
+          }
+          rawIndent(o) {
+            if (o.raws.indent) return o.raws.indent;
+            let u;
+            return o.walk((p) => {
+              let y = p.parent;
+              if (y && y !== o && y.parent && y.parent === o && typeof p.raws.before < "u") {
+                let m = p.raws.before.split(`
+`);
+                return u = m[m.length - 1], u = u.replace(/\S/g, ""), !1;
+              }
+            }), u;
+          }
+          rawSemicolon(o) {
+            let u;
+            return o.walk((p) => {
+              if (p.nodes && p.nodes.length && p.last.type === "decl" && (u = p.raws.semicolon, typeof u < "u")) return !1;
+            }), u;
+          }
+          rawValue(o, u) {
+            let p = o[u], y = o.raws[u];
+            return y && y.value === p ? y.raw : p;
+          }
+          root(o) {
+            this.body(o), o.raws.after && this.builder(o.raws.after);
+          }
+          rule(o) {
+            this.block(o, this.rawValue(o, "selector")), o.raws.ownSemicolon && this.builder(o.raws.ownSemicolon, o, "end");
+          }
+          stringify(o, u) {
+            if (!this[o.type]) throw new Error("Unknown AST node type " + o.type + ". Maybe you need to change PostCSS stringifier.");
+            this[o.type](o, u);
+          }
+        };
+        s.exports = a, a.default = a;
+      }), Ge = S((e, s) => {
+        var i = mt();
+        function r(a, o) {
+          new i(o).stringify(a);
+        }
+        s.exports = r, r.default = r;
+      }), yt = S((e, s) => {
+        s.exports.isClean = /* @__PURE__ */ Symbol("isClean"), s.exports.my = /* @__PURE__ */ Symbol("my");
+      }), He = S((e, s) => {
+        var i = dt(), r = mt(), a = Ge(), { isClean: o, my: u } = yt();
+        function p(n, t) {
+          let h = new n.constructor();
+          for (let c in n) {
+            if (!Object.prototype.hasOwnProperty.call(n, c) || c === "proxyCache") continue;
+            let d = n[c], l = typeof d;
+            c === "parent" && l === "object" ? t && (h[c] = t) : c === "source" ? h[c] = d : Array.isArray(d) ? h[c] = d.map((w) => p(w, h)) : (l === "object" && d !== null && (d = p(d)), h[c] = d);
+          }
+          return h;
+        }
+        function y(n, t) {
+          if (t && typeof t.offset < "u") return t.offset;
+          let h = 1, c = 1, d = 0;
+          for (let l = 0; l < n.length; l++) {
+            if (c === t.line && h === t.column) {
+              d = l;
+              break;
+            }
+            n[l] === `
+` ? (h = 1, c += 1) : h += 1;
+          }
+          return d;
+        }
+        var m = class {
+          get proxyOf() {
+            return this;
+          }
+          constructor(n = {}) {
+            this.raws = {}, this[o] = !1, this[u] = !0;
+            for (let t in n) if (t === "nodes") {
+              this.nodes = [];
+              for (let h of n[t]) typeof h.clone == "function" ? this.append(h.clone()) : this.append(h);
+            } else this[t] = n[t];
+          }
+          addToError(n) {
+            if (n.postcssNode = this, n.stack && this.source && /\n\s{4}at /.test(n.stack)) {
+              let t = this.source;
+              n.stack = n.stack.replace(/\n\s{4}at /, `$&${t.input.from}:${t.start.line}:${t.start.column}$&`);
+            }
+            return n;
+          }
+          after(n) {
+            return this.parent.insertAfter(this, n), this;
+          }
+          assign(n = {}) {
+            for (let t in n) this[t] = n[t];
+            return this;
+          }
+          before(n) {
+            return this.parent.insertBefore(this, n), this;
+          }
+          cleanRaws(n) {
+            delete this.raws.before, delete this.raws.after, n || delete this.raws.between;
+          }
+          clone(n = {}) {
+            let t = p(this);
+            for (let h in n) t[h] = n[h];
+            return t;
+          }
+          cloneAfter(n = {}) {
+            let t = this.clone(n);
+            return this.parent.insertAfter(this, t), t;
+          }
+          cloneBefore(n = {}) {
+            let t = this.clone(n);
+            return this.parent.insertBefore(this, t), t;
+          }
+          error(n, t = {}) {
+            if (this.source) {
+              let { end: h, start: c } = this.rangeBy(t);
+              return this.source.input.error(n, { column: c.column, line: c.line }, { column: h.column, line: h.line }, t);
+            }
+            return new i(n);
+          }
+          getProxyProcessor() {
+            return { get(n, t) {
+              return t === "proxyOf" ? n : t === "root" ? () => n.root().toProxy() : n[t];
+            }, set(n, t, h) {
+              return n[t] === h || (n[t] = h, (t === "prop" || t === "value" || t === "name" || t === "params" || t === "important" || t === "text") && n.markDirty()), !0;
+            } };
+          }
+          markClean() {
+            this[o] = !0;
+          }
+          markDirty() {
+            if (this[o]) {
+              this[o] = !1;
+              let n = this;
+              for (; n = n.parent; ) n[o] = !1;
+            }
+          }
+          next() {
+            if (!this.parent) return;
+            let n = this.parent.index(this);
+            return this.parent.nodes[n + 1];
+          }
+          positionBy(n = {}) {
+            let t = this.source.start;
+            if (n.index) t = this.positionInside(n.index);
+            else if (n.word) {
+              let h = "document" in this.source.input ? this.source.input.document : this.source.input.css, c = h.slice(y(h, this.source.start), y(h, this.source.end)).indexOf(n.word);
+              c !== -1 && (t = this.positionInside(c));
+            }
+            return t;
+          }
+          positionInside(n) {
+            let t = this.source.start.column, h = this.source.start.line, c = "document" in this.source.input ? this.source.input.document : this.source.input.css, d = y(c, this.source.start), l = d + n;
+            for (let w = d; w < l; w++) c[w] === `
+` ? (t = 1, h += 1) : t += 1;
+            return { column: t, line: h, offset: l };
+          }
+          prev() {
+            if (!this.parent) return;
+            let n = this.parent.index(this);
+            return this.parent.nodes[n - 1];
+          }
+          rangeBy(n = {}) {
+            let t = "document" in this.source.input ? this.source.input.document : this.source.input.css, h = { column: this.source.start.column, line: this.source.start.line, offset: y(t, this.source.start) }, c = this.source.end ? { column: this.source.end.column + 1, line: this.source.end.line, offset: typeof this.source.end.offset == "number" ? this.source.end.offset : y(t, this.source.end) + 1 } : { column: h.column + 1, line: h.line, offset: h.offset + 1 };
+            if (n.word) {
+              let d = t.slice(y(t, this.source.start), y(t, this.source.end)).indexOf(n.word);
+              d !== -1 && (h = this.positionInside(d), c = this.positionInside(d + n.word.length));
+            } else n.start ? h = { column: n.start.column, line: n.start.line, offset: y(t, n.start) } : n.index && (h = this.positionInside(n.index)), n.end ? c = { column: n.end.column, line: n.end.line, offset: y(t, n.end) } : typeof n.endIndex == "number" ? c = this.positionInside(n.endIndex) : n.index && (c = this.positionInside(n.index + 1));
+            return (c.line < h.line || c.line === h.line && c.column <= h.column) && (c = { column: h.column + 1, line: h.line, offset: h.offset + 1 }), { end: c, start: h };
+          }
+          raw(n, t) {
+            return new r().raw(this, n, t);
+          }
+          remove() {
+            return this.parent && this.parent.removeChild(this), this.parent = void 0, this;
+          }
+          replaceWith(...n) {
+            if (this.parent) {
+              let t = this, h = !1;
+              for (let c of n) c === this ? h = !0 : h ? (this.parent.insertAfter(t, c), t = c) : this.parent.insertBefore(t, c);
+              h || this.remove();
+            }
+            return this;
+          }
+          root() {
+            let n = this;
+            for (; n.parent && n.parent.type !== "document"; ) n = n.parent;
+            return n;
+          }
+          toJSON(n, t) {
+            let h = {}, c = t == null;
+            t = t || /* @__PURE__ */ new Map();
+            let d = 0;
+            for (let l in this) {
+              if (!Object.prototype.hasOwnProperty.call(this, l) || l === "parent" || l === "proxyCache") continue;
+              let w = this[l];
+              if (Array.isArray(w)) h[l] = w.map((v) => typeof v == "object" && v.toJSON ? v.toJSON(null, t) : v);
+              else if (typeof w == "object" && w.toJSON) h[l] = w.toJSON(null, t);
+              else if (l === "source") {
+                if (w == null) continue;
+                let v = t.get(w.input);
+                v == null && (v = d, t.set(w.input, d), d++), h[l] = { end: w.end, inputId: v, start: w.start };
+              } else h[l] = w;
+            }
+            return c && (h.inputs = [...t.keys()].map((l) => l.toJSON())), h;
+          }
+          toProxy() {
+            return this.proxyCache || (this.proxyCache = new Proxy(this, this.getProxyProcessor())), this.proxyCache;
+          }
+          toString(n = a) {
+            n.stringify && (n = n.stringify);
+            let t = "";
+            return n(this, (h) => {
+              t += h;
+            }), t;
+          }
+          warn(n, t, h = {}) {
+            let c = { node: this };
+            for (let d in h) c[d] = h[d];
+            return n.warn(t, c);
+          }
+        };
+        s.exports = m, m.default = m;
+      }), Ee = S((e, s) => {
+        var i = He(), r = class extends i {
+          constructor(a) {
+            super(a), this.type = "comment";
+          }
+        };
+        s.exports = r, r.default = r;
+      }), Je = S((e, s) => {
+        var i = He(), r = class extends i {
+          get variable() {
+            return this.prop.startsWith("--") || this.prop[0] === "$";
+          }
+          constructor(a) {
+            a && typeof a.value < "u" && typeof a.value != "string" && (a = { ...a, value: String(a.value) }), super(a), this.type = "decl";
+          }
+        };
+        s.exports = r, r.default = r;
+      }), pe = S((e, s) => {
+        var i = Ee(), r = Je(), a = He(), { isClean: o, my: u } = yt(), p, y, m, n;
+        function t(d) {
+          return d.map((l) => (l.nodes && (l.nodes = t(l.nodes)), delete l.source, l));
+        }
+        function h(d) {
+          if (d[o] = !1, d.proxyOf.nodes) for (let l of d.proxyOf.nodes) h(l);
+        }
+        var c = class as extends a {
+          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];
+          }
+          append(...l) {
+            for (let w of l) {
+              let v = this.normalize(w, this.last);
+              for (let f of v) this.proxyOf.nodes.push(f);
+            }
+            return this.markDirty(), this;
+          }
+          cleanRaws(l) {
+            if (super.cleanRaws(l), this.nodes) for (let w of this.nodes) w.cleanRaws(l);
+          }
+          each(l) {
+            if (!this.proxyOf.nodes) return;
+            let w = this.getIterator(), v, f;
+            for (; this.indexes[w] < this.proxyOf.nodes.length && (v = this.indexes[w], f = l(this.proxyOf.nodes[v], v), f !== !1); ) this.indexes[w] += 1;
+            return delete this.indexes[w], f;
+          }
+          every(l) {
+            return this.nodes.every(l);
+          }
+          getIterator() {
+            this.lastEach || (this.lastEach = 0), this.indexes || (this.indexes = {}), this.lastEach += 1;
+            let l = this.lastEach;
+            return this.indexes[l] = 0, l;
+          }
+          getProxyProcessor() {
+            return { get(l, w) {
+              return w === "proxyOf" ? l : l[w] ? w === "each" || typeof w == "string" && w.startsWith("walk") ? (...v) => l[w](...v.map((f) => typeof f == "function" ? (g, T) => f(g.toProxy(), T) : f)) : w === "every" || w === "some" ? (v) => l[w]((f, ...g) => v(f.toProxy(), ...g)) : w === "root" ? () => l.root().toProxy() : w === "nodes" ? l.nodes.map((v) => v.toProxy()) : w === "first" || w === "last" ? l[w].toProxy() : l[w] : l[w];
+            }, set(l, w, v) {
+              return l[w] === v || (l[w] = v, (w === "name" || w === "params" || w === "selector") && l.markDirty()), !0;
+            } };
+          }
+          index(l) {
+            return typeof l == "number" ? l : (l.proxyOf && (l = l.proxyOf), this.proxyOf.nodes.indexOf(l));
+          }
+          insertAfter(l, w) {
+            let v = this.index(l), f = this.normalize(w, this.proxyOf.nodes[v]).reverse();
+            v = this.index(l);
+            for (let T of f) this.proxyOf.nodes.splice(v + 1, 0, T);
+            let g;
+            for (let T in this.indexes) g = this.indexes[T], v < g && (this.indexes[T] = g + f.length);
+            return this.markDirty(), this;
+          }
+          insertBefore(l, w) {
+            let v = this.index(l), f = v === 0 ? "prepend" : !1, g = this.normalize(w, this.proxyOf.nodes[v], f).reverse();
+            v = this.index(l);
+            for (let b of g) this.proxyOf.nodes.splice(v, 0, b);
+            let T;
+            for (let b in this.indexes) T = this.indexes[b], v <= T && (this.indexes[b] = T + g.length);
+            return this.markDirty(), this;
+          }
+          normalize(l, w) {
+            if (typeof l == "string") l = t(y(l).nodes);
+            else if (typeof l > "u") l = [];
+            else if (Array.isArray(l)) {
+              l = l.slice(0);
+              for (let v of l) v.parent && v.parent.removeChild(v, "ignore");
+            } else if (l.type === "root" && this.type !== "document") {
+              l = l.nodes.slice(0);
+              for (let v of l) v.parent && v.parent.removeChild(v, "ignore");
+            } else if (l.type) l = [l];
+            else if (l.prop) {
+              if (typeof l.value > "u") throw new Error("Value field is missed in node creation");
+              typeof l.value != "string" && (l.value = String(l.value)), l = [new r(l)];
+            } else if (l.selector || l.selectors) l = [new n(l)];
+            else if (l.name) l = [new p(l)];
+            else if (l.text) l = [new i(l)];
+            else throw new Error("Unknown node type in node creation");
+            return l.map((v) => (v[u] || as.rebuild(v), v = v.proxyOf, v.parent && v.parent.removeChild(v), v[o] && h(v), v.raws || (v.raws = {}), typeof v.raws.before > "u" && w && typeof w.raws.before < "u" && (v.raws.before = w.raws.before.replace(/\S/g, "")), v.parent = this.proxyOf, v));
+          }
+          prepend(...l) {
+            l = l.reverse();
+            for (let w of l) {
+              let v = this.normalize(w, this.first, "prepend").reverse();
+              for (let f of v) this.proxyOf.nodes.unshift(f);
+              for (let f in this.indexes) this.indexes[f] = this.indexes[f] + v.length;
+            }
+            return this.markDirty(), this;
+          }
+          push(l) {
+            return l.parent = this, this.proxyOf.nodes.push(l), this;
+          }
+          removeAll() {
+            for (let l of this.proxyOf.nodes) l.parent = void 0;
+            return this.proxyOf.nodes = [], this.markDirty(), this;
+          }
+          removeChild(l) {
+            l = this.index(l), this.proxyOf.nodes[l].parent = void 0, this.proxyOf.nodes.splice(l, 1);
+            let w;
+            for (let v in this.indexes) w = this.indexes[v], w >= l && (this.indexes[v] = w - 1);
+            return this.markDirty(), this;
+          }
+          replaceValues(l, w, v) {
+            return v || (v = w, w = {}), this.walkDecls((f) => {
+              w.props && !w.props.includes(f.prop) || w.fast && !f.value.includes(w.fast) || (f.value = f.value.replace(l, v));
+            }), this.markDirty(), this;
+          }
+          some(l) {
+            return this.nodes.some(l);
+          }
+          walk(l) {
+            return this.each((w, v) => {
+              let f;
+              try {
+                f = l(w, v);
+              } catch (g) {
+                throw w.addToError(g);
+              }
+              return f !== !1 && w.walk && (f = w.walk(l)), f;
+            });
+          }
+          walkAtRules(l, w) {
+            return w ? l instanceof RegExp ? this.walk((v, f) => {
+              if (v.type === "atrule" && l.test(v.name)) return w(v, f);
+            }) : this.walk((v, f) => {
+              if (v.type === "atrule" && v.name === l) return w(v, f);
+            }) : (w = l, this.walk((v, f) => {
+              if (v.type === "atrule") return w(v, f);
+            }));
+          }
+          walkComments(l) {
+            return this.walk((w, v) => {
+              if (w.type === "comment") return l(w, v);
+            });
+          }
+          walkDecls(l, w) {
+            return w ? l instanceof RegExp ? this.walk((v, f) => {
+              if (v.type === "decl" && l.test(v.prop)) return w(v, f);
+            }) : this.walk((v, f) => {
+              if (v.type === "decl" && v.prop === l) return w(v, f);
+            }) : (w = l, this.walk((v, f) => {
+              if (v.type === "decl") return w(v, f);
+            }));
+          }
+          walkRules(l, w) {
+            return w ? l instanceof RegExp ? this.walk((v, f) => {
+              if (v.type === "rule" && l.test(v.selector)) return w(v, f);
+            }) : this.walk((v, f) => {
+              if (v.type === "rule" && v.selector === l) return w(v, f);
+            }) : (w = l, this.walk((v, f) => {
+              if (v.type === "rule") return w(v, f);
+            }));
+          }
+        };
+        c.registerParse = (d) => {
+          y = d;
+        }, c.registerRule = (d) => {
+          n = d;
+        }, c.registerAtRule = (d) => {
+          p = d;
+        }, c.registerRoot = (d) => {
+          m = d;
+        }, s.exports = c, c.default = c, c.rebuild = (d) => {
+          d.type === "atrule" ? Object.setPrototypeOf(d, p.prototype) : d.type === "rule" ? Object.setPrototypeOf(d, n.prototype) : d.type === "decl" ? Object.setPrototypeOf(d, r.prototype) : d.type === "comment" ? Object.setPrototypeOf(d, i.prototype) : d.type === "root" && Object.setPrototypeOf(d, m.prototype), d[u] = !0, d.nodes && d.nodes.forEach((l) => {
+            c.rebuild(l);
+          });
+        };
+      }), ds = S((e, s) => {
+        var i = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict", r = (o, u = 21) => (p = u) => {
+          let y = "", m = p | 0;
+          for (; m--; ) y += o[Math.random() * o.length | 0];
+          return y;
+        }, a = (o = 21) => {
+          let u = "", p = o | 0;
+          for (; p--; ) u += i[Math.random() * 64 | 0];
+          return u;
+        };
+        s.exports = { nanoid: a, customAlphabet: r };
+      }), ms = S(() => {
+      }), Yt = S((e, s) => {
+        s.exports = class {
+        };
+      }), je = S((e, s) => {
+        var { nanoid: i } = ds(), { isAbsolute: r, resolve: a } = {}, { SourceMapConsumer: o, SourceMapGenerator: u } = ms(), { fileURLToPath: p, pathToFileURL: y } = {}, m = dt(), n = Yt(), t = Zt(), h = /* @__PURE__ */ Symbol("lineToIndexCache"), c = !!(o && u), d = !!(a && r);
+        function l(v) {
+          if (v[h]) return v[h];
+          let f = v.css.split(`
+`), g = new Array(f.length), T = 0;
+          for (let b = 0, x = f.length; b < x; b++) g[b] = T, T += f[b].length + 1;
+          return v[h] = g, g;
+        }
+        var w = class {
+          get from() {
+            return this.file || this.id;
+          }
+          constructor(v, f = {}) {
+            if (v === null || typeof v > "u" || typeof v == "object" && !v.toString) throw new Error(`PostCSS received ${v} instead of CSS string`);
+            if (this.css = v.toString(), this.css[0] === "\uFEFF" || this.css[0] === "￾" ? (this.hasBOM = !0, this.css = this.css.slice(1)) : this.hasBOM = !1, this.document = this.css, f.document && (this.document = f.document.toString()), f.from && (!d || /^\w+:\/\//.test(f.from) || r(f.from) ? this.file = f.from : this.file = a(f.from)), d && c) {
+              let g = new n(this.css, f);
+              if (g.text) {
+                this.map = g;
+                let T = g.consumer().file;
+                !this.file && T && (this.file = this.mapResolve(T));
+              }
+            }
+            this.file || (this.id = "<input css " + i(6) + ">"), this.map && (this.map.file = this.from);
+          }
+          error(v, f, g, T = {}) {
+            let b, x, k, O, A;
+            if (f && typeof f == "object") {
+              let P = f, W = g;
+              if (typeof P.offset == "number") {
+                O = P.offset;
+                let R = this.fromOffset(O);
+                f = R.line, g = R.col;
+              } else f = P.line, g = P.column, O = this.fromLineAndColumn(f, g);
+              if (typeof W.offset == "number") {
+                k = W.offset;
+                let R = this.fromOffset(k);
+                x = R.line, b = R.col;
+              } else x = W.line, b = W.column, k = this.fromLineAndColumn(W.line, W.column);
+            } else if (g) O = this.fromLineAndColumn(f, g);
+            else {
+              O = f;
+              let P = this.fromOffset(O);
+              f = P.line, g = P.col;
+            }
+            let E = this.origin(f, g, x, b);
+            return E ? A = new m(v, E.endLine === void 0 ? E.line : { column: E.column, line: E.line }, E.endLine === void 0 ? E.column : { column: E.endColumn, line: E.endLine }, E.source, E.file, T.plugin) : A = new m(v, x === void 0 ? f : { column: g, line: f }, x === void 0 ? g : { column: b, line: x }, this.css, this.file, T.plugin), A.input = { column: g, endColumn: b, endLine: x, endOffset: k, line: f, offset: O, source: this.css }, this.file && (y && (A.input.url = y(this.file).toString()), A.input.file = this.file), A;
+          }
+          fromLineAndColumn(v, f) {
+            return l(this)[v - 1] + f - 1;
+          }
+          fromOffset(v) {
+            let f = l(this), g = f[f.length - 1], T = 0;
+            if (v >= g) T = f.length - 1;
+            else {
+              let b = f.length - 2, x;
+              for (; T < b; ) if (x = T + (b - T >> 1), v < f[x]) b = x - 1;
+              else if (v >= f[x + 1]) T = x + 1;
+              else {
+                T = x;
+                break;
+              }
+            }
+            return { col: v - f[T] + 1, line: T + 1 };
+          }
+          mapResolve(v) {
+            return /^\w+:\/\//.test(v) ? v : a(this.map.consumer().sourceRoot || this.map.root || ".", v);
+          }
+          origin(v, f, g, T) {
+            if (!this.map) return !1;
+            let b = this.map.consumer(), x = b.originalPositionFor({ column: f, line: v });
+            if (!x.source) return !1;
+            let k;
+            typeof g == "number" && (k = b.originalPositionFor({ column: T, line: g }));
+            let O;
+            r(x.source) ? O = y(x.source) : O = new URL(x.source, this.map.consumer().sourceRoot || y(this.map.mapFile));
+            let A = { column: x.column, endColumn: k && k.column, endLine: k && k.line, line: x.line, url: O.toString() };
+            if (O.protocol === "file:") if (p) A.file = p(O);
+            else throw new Error("file: protocol is not available in this PostCSS build");
+            let E = b.sourceContentFor(x.source);
+            return E && (A.source = E), A;
+          }
+          toJSON() {
+            let v = {};
+            for (let f of ["hasBOM", "css", "file", "id"]) this[f] != null && (v[f] = this[f]);
+            return this.map && (v.map = { ...this.map }, v.map.consumerCache && (v.map.consumerCache = void 0)), v;
+          }
+        };
+        s.exports = w, w.default = w, t && t.registerInput && t.registerInput(w);
+      }), vt = S((e, s) => {
+        var i = pe(), r = class extends i {
+          constructor(a) {
+            super(a), this.type = "atrule";
+          }
+          append(...a) {
+            return this.proxyOf.nodes || (this.nodes = []), super.append(...a);
+          }
+          prepend(...a) {
+            return this.proxyOf.nodes || (this.nodes = []), super.prepend(...a);
+          }
+        };
+        s.exports = r, r.default = r, i.registerAtRule(r);
+      }), Ie = S((e, s) => {
+        var i = pe(), r, a, o = class extends i {
+          constructor(u) {
+            super(u), this.type = "root", this.nodes || (this.nodes = []);
+          }
+          normalize(u, p, y) {
+            let m = super.normalize(u);
+            if (p) {
+              if (y === "prepend") this.nodes.length > 1 ? p.raws.before = this.nodes[1].raws.before : delete p.raws.before;
+              else if (this.first !== p) for (let n of m) n.raws.before = p.raws.before;
+            }
+            return m;
+          }
+          removeChild(u, p) {
+            let y = this.index(u);
+            return !p && y === 0 && this.nodes.length > 1 && (this.nodes[1].raws.before = this.nodes[y].raws.before), super.removeChild(u);
+          }
+          toResult(u = {}) {
+            return new r(new a(), this, u).stringify();
+          }
+        };
+        o.registerLazyResult = (u) => {
+          r = u;
+        }, o.registerProcessor = (u) => {
+          a = u;
+        }, s.exports = o, o.default = o, i.registerRoot(o);
+      }), Kt = S((e, s) => {
+        var i = { comma(r) {
+          return i.split(r, [","], !0);
+        }, space(r) {
+          let a = [" ", `
+`, "	"];
+          return i.split(r, a);
+        }, split(r, a, o) {
+          let u = [], p = "", y = !1, m = 0, n = !1, t = "", h = !1;
+          for (let c of r) h ? h = !1 : c === "\\" ? h = !0 : n ? c === t && (n = !1) : c === '"' || c === "'" ? (n = !0, t = c) : c === "(" ? m += 1 : c === ")" ? m > 0 && (m -= 1) : m === 0 && a.includes(c) && (y = !0), y ? (p !== "" && u.push(p.trim()), p = "", y = !1) : p += c;
+          return (o || p !== "") && u.push(p.trim()), u;
+        } };
+        s.exports = i, i.default = i;
+      }), gt = S((e, s) => {
+        var i = pe(), r = Kt(), a = class extends i {
+          get selectors() {
+            return r.comma(this.selector);
+          }
+          set selectors(o) {
+            let u = this.selector ? this.selector.match(/,\s*/) : null, p = u ? u[0] : "," + this.raw("between", "beforeOpen");
+            this.selector = o.join(p);
+          }
+          constructor(o) {
+            super(o), this.type = "rule", this.nodes || (this.nodes = []);
+          }
+        };
+        s.exports = a, a.default = a, i.registerRule(a);
+      }), wt = S((e, s) => {
+        var i = /[\t\n\f\r "#'()/;[\\\]{}]/g, r = /[\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g, a = /.[\r\n"'(/\\]/, o = /[\da-f]/i;
+        s.exports = function(u, p = {}) {
+          let y = u.css.valueOf(), m = p.ignoreErrors, n, t, h, c, d, l, w, v, f, g, T = y.length, b = 0, x = [], k = [];
+          function O() {
+            return b;
+          }
+          function A(R) {
+            throw u.error("Unclosed " + R, b);
+          }
+          function E() {
+            return k.length === 0 && b >= T;
+          }
+          function P(R) {
+            if (k.length) return k.pop();
+            if (b >= T) return;
+            let $ = R ? R.ignoreUnclosed : !1;
+            switch (n = y.charCodeAt(b), n) {
+              case 10:
+              case 32:
+              case 9:
+              case 13:
+              case 12: {
+                c = b;
+                do
+                  c += 1, n = y.charCodeAt(c);
+                while (n === 32 || n === 10 || n === 9 || n === 13 || n === 12);
+                l = ["space", y.slice(b, c)], b = c - 1;
+                break;
+              }
+              case 91:
+              case 93:
+              case 123:
+              case 125:
+              case 58:
+              case 59:
+              case 41: {
+                let M = String.fromCharCode(n);
+                l = [M, M, b];
+                break;
+              }
+              case 40: {
+                if (g = x.length ? x.pop()[1] : "", f = y.charCodeAt(b + 1), g === "url" && f !== 39 && f !== 34 && f !== 32 && f !== 10 && f !== 9 && f !== 12 && f !== 13) {
+                  c = b;
+                  do {
+                    if (w = !1, c = y.indexOf(")", c + 1), c === -1) if (m || $) {
+                      c = b;
+                      break;
+                    } else A("bracket");
+                    for (v = c; y.charCodeAt(v - 1) === 92; ) v -= 1, w = !w;
+                  } while (w);
+                  l = ["brackets", y.slice(b, c + 1), b, c], b = c;
+                } else c = y.indexOf(")", b + 1), t = y.slice(b, c + 1), c === -1 || a.test(t) ? l = ["(", "(", b] : (l = ["brackets", t, b, c], b = c);
+                break;
+              }
+              case 39:
+              case 34: {
+                d = n === 39 ? "'" : '"', c = b;
+                do {
+                  if (w = !1, c = y.indexOf(d, c + 1), c === -1) if (m || $) {
+                    c = b + 1;
+                    break;
+                  } else A("string");
+                  for (v = c; y.charCodeAt(v - 1) === 92; ) v -= 1, w = !w;
+                } while (w);
+                l = ["string", y.slice(b, c + 1), b, c], b = c;
+                break;
+              }
+              case 64: {
+                i.lastIndex = b + 1, i.test(y), i.lastIndex === 0 ? c = y.length - 1 : c = i.lastIndex - 2, l = ["at-word", y.slice(b, c + 1), b, c], b = c;
+                break;
+              }
+              case 92: {
+                for (c = b, h = !0; y.charCodeAt(c + 1) === 92; ) c += 1, h = !h;
+                if (n = y.charCodeAt(c + 1), h && n !== 47 && n !== 32 && n !== 10 && n !== 9 && n !== 13 && n !== 12 && (c += 1, o.test(y.charAt(c)))) {
+                  for (; o.test(y.charAt(c + 1)); ) c += 1;
+                  y.charCodeAt(c + 1) === 32 && (c += 1);
+                }
+                l = ["word", y.slice(b, c + 1), b, c], b = c;
+                break;
+              }
+              default: {
+                n === 47 && y.charCodeAt(b + 1) === 42 ? (c = y.indexOf("*/", b + 2) + 1, c === 0 && (m || $ ? c = y.length : A("comment")), l = ["comment", y.slice(b, c + 1), b, c], b = c) : (r.lastIndex = b + 1, r.test(y), r.lastIndex === 0 ? c = y.length - 1 : c = r.lastIndex - 2, l = ["word", y.slice(b, c + 1), b, c], x.push(l), b = c);
+                break;
+              }
+            }
+            return b++, l;
+          }
+          function W(R) {
+            k.push(R);
+          }
+          return { back: W, endOfFile: E, nextToken: P, position: O };
+        };
+      }), bt = S((e, s) => {
+        var i = vt(), r = Ee(), a = Je(), o = Ie(), u = gt(), p = wt(), y = { empty: !0, space: !0 };
+        function m(t) {
+          for (let h = t.length - 1; h >= 0; h--) {
+            let c = t[h], d = c[3] || c[2];
+            if (d) return d;
+          }
+        }
+        var n = class {
+          constructor(t) {
+            this.input = t, this.root = new o(), this.current = this.root, this.spaces = "", this.semicolon = !1, this.createTokenizer(), this.root.source = { input: t, start: { column: 1, line: 1, offset: 0 } };
+          }
+          atrule(t) {
+            let h = new i();
+            h.name = t[1].slice(1), h.name === "" && this.unnamedAtrule(h, t), this.init(h, t[2]);
+            let c, d, l, w = !1, v = !1, f = [], g = [];
+            for (; !this.tokenizer.endOfFile(); ) {
+              if (t = this.tokenizer.nextToken(), c = t[0], c === "(" || c === "[" ? g.push(c === "(" ? ")" : "]") : c === "{" && g.length > 0 ? g.push("}") : c === g[g.length - 1] && g.pop(), g.length === 0) if (c === ";") {
+                h.source.end = this.getPosition(t[2]), h.source.end.offset++, this.semicolon = !0;
+                break;
+              } else if (c === "{") {
+                v = !0;
+                break;
+              } else if (c === "}") {
+                if (f.length > 0) {
+                  for (l = f.length - 1, d = f[l]; d && d[0] === "space"; ) d = f[--l];
+                  d && (h.source.end = this.getPosition(d[3] || d[2]), h.source.end.offset++);
+                }
+                this.end(t);
+                break;
+              } else f.push(t);
+              else f.push(t);
+              if (this.tokenizer.endOfFile()) {
+                w = !0;
+                break;
+              }
+            }
+            h.raws.between = this.spacesAndCommentsFromEnd(f), f.length ? (h.raws.afterName = this.spacesAndCommentsFromStart(f), this.raw(h, "params", f), w && (t = f[f.length - 1], h.source.end = this.getPosition(t[3] || t[2]), h.source.end.offset++, this.spaces = h.raws.between, h.raws.between = "")) : (h.raws.afterName = "", h.params = ""), v && (h.nodes = [], this.current = h);
+          }
+          checkMissedSemicolon(t) {
+            let h = this.colon(t);
+            if (h === !1) return;
+            let c = 0, d;
+            for (let l = h - 1; l >= 0 && (d = t[l], !(d[0] !== "space" && (c += 1, c === 2))); l--) ;
+            throw this.input.error("Missed semicolon", d[0] === "word" ? d[3] + 1 : d[2]);
+          }
+          colon(t) {
+            let h = 0, c, d, l;
+            for (let [w, v] of t.entries()) {
+              if (d = v, l = d[0], l === "(" && (h += 1), l === ")" && (h -= 1), h === 0 && l === ":") if (!c) this.doubleColon(d);
+              else {
+                if (c[0] === "word" && c[1] === "progid") continue;
+                return w;
+              }
+              c = d;
+            }
+            return !1;
+          }
+          comment(t) {
+            let h = new r();
+            this.init(h, t[2]), h.source.end = this.getPosition(t[3] || t[2]), h.source.end.offset++;
+            let c = t[1].slice(2, -2);
+            if (/^\s*$/.test(c)) h.text = "", h.raws.left = c, h.raws.right = "";
+            else {
+              let d = c.match(/^(\s*)([^]*\S)(\s*)$/);
+              h.text = d[2], h.raws.left = d[1], h.raws.right = d[3];
+            }
+          }
+          createTokenizer() {
+            this.tokenizer = p(this.input);
+          }
+          decl(t, h) {
+            let c = new a();
+            this.init(c, t[0][2]);
+            let d = t[t.length - 1];
+            for (d[0] === ";" && (this.semicolon = !0, t.pop()), c.source.end = this.getPosition(d[3] || d[2] || m(t)), c.source.end.offset++; t[0][0] !== "word"; ) t.length === 1 && this.unknownWord(t), c.raws.before += t.shift()[1];
+            for (c.source.start = this.getPosition(t[0][2]), c.prop = ""; t.length; ) {
+              let f = t[0][0];
+              if (f === ":" || f === "space" || f === "comment") break;
+              c.prop += t.shift()[1];
+            }
+            c.raws.between = "";
+            let l;
+            for (; t.length; ) if (l = t.shift(), l[0] === ":") {
+              c.raws.between += l[1];
+              break;
+            } else l[0] === "word" && /\w/.test(l[1]) && this.unknownWord([l]), c.raws.between += l[1];
+            (c.prop[0] === "_" || c.prop[0] === "*") && (c.raws.before += c.prop[0], c.prop = c.prop.slice(1));
+            let w = [], v;
+            for (; t.length && (v = t[0][0], !(v !== "space" && v !== "comment")); ) w.push(t.shift());
+            this.precheckMissedSemicolon(t);
+            for (let f = t.length - 1; f >= 0; f--) {
+              if (l = t[f], l[1].toLowerCase() === "!important") {
+                c.important = !0;
+                let g = this.stringFrom(t, f);
+                g = this.spacesFromEnd(t) + g, g !== " !important" && (c.raws.important = g);
+                break;
+              } else if (l[1].toLowerCase() === "important") {
+                let g = t.slice(0), T = "";
+                for (let b = f; b > 0; b--) {
+                  let x = g[b][0];
+                  if (T.trim().startsWith("!") && x !== "space") break;
+                  T = g.pop()[1] + T;
+                }
+                T.trim().startsWith("!") && (c.important = !0, c.raws.important = T, t = g);
+              }
+              if (l[0] !== "space" && l[0] !== "comment") break;
+            }
+            t.some((f) => f[0] !== "space" && f[0] !== "comment") && (c.raws.between += w.map((f) => f[1]).join(""), w = []), this.raw(c, "value", w.concat(t), h), c.value.includes(":") && !h && this.checkMissedSemicolon(t);
+          }
+          doubleColon(t) {
+            throw this.input.error("Double colon", { offset: t[2] }, { offset: t[2] + t[1].length });
+          }
+          emptyRule(t) {
+            let h = new u();
+            this.init(h, t[2]), h.selector = "", h.raws.between = "", this.current = h;
+          }
+          end(t) {
+            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(t[2]), this.current.source.end.offset++, this.current = this.current.parent) : this.unexpectedClose(t);
+          }
+          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(t) {
+            if (this.spaces += t[1], this.current.nodes) {
+              let h = this.current.nodes[this.current.nodes.length - 1];
+              h && h.type === "rule" && !h.raws.ownSemicolon && (h.raws.ownSemicolon = this.spaces, this.spaces = "", h.source.end = this.getPosition(t[2]), h.source.end.offset += h.raws.ownSemicolon.length);
+            }
+          }
+          getPosition(t) {
+            let h = this.input.fromOffset(t);
+            return { column: h.col, line: h.line, offset: t };
+          }
+          init(t, h) {
+            this.current.push(t), t.source = { input: this.input, start: this.getPosition(h) }, t.raws.before = this.spaces, this.spaces = "", t.type !== "comment" && (this.semicolon = !1);
+          }
+          other(t) {
+            let h = !1, c = null, d = !1, l = null, w = [], v = t[1].startsWith("--"), f = [], g = t;
+            for (; g; ) {
+              if (c = g[0], f.push(g), c === "(" || c === "[") l || (l = g), w.push(c === "(" ? ")" : "]");
+              else if (v && d && c === "{") l || (l = g), w.push("}");
+              else if (w.length === 0) if (c === ";") if (d) {
+                this.decl(f, v);
+                return;
+              } else break;
+              else if (c === "{") {
+                this.rule(f);
+                return;
+              } else if (c === "}") {
+                this.tokenizer.back(f.pop()), h = !0;
+                break;
+              } else c === ":" && (d = !0);
+              else c === w[w.length - 1] && (w.pop(), w.length === 0 && (l = null));
+              g = this.tokenizer.nextToken();
+            }
+            if (this.tokenizer.endOfFile() && (h = !0), w.length > 0 && this.unclosedBracket(l), h && d) {
+              if (!v) for (; f.length && (g = f[f.length - 1][0], !(g !== "space" && g !== "comment")); ) this.tokenizer.back(f.pop());
+              this.decl(f, v);
+            } else this.unknownWord(f);
+          }
+          parse() {
+            let t;
+            for (; !this.tokenizer.endOfFile(); ) switch (t = this.tokenizer.nextToken(), t[0]) {
+              case "space":
+                this.spaces += t[1];
+                break;
+              case ";":
+                this.freeSemicolon(t);
+                break;
+              case "}":
+                this.end(t);
+                break;
+              case "comment":
+                this.comment(t);
+                break;
+              case "at-word":
+                this.atrule(t);
+                break;
+              case "{":
+                this.emptyRule(t);
+                break;
+              default:
+                this.other(t);
+                break;
+            }
+            this.endFile();
+          }
+          precheckMissedSemicolon() {
+          }
+          raw(t, h, c, d) {
+            let l, w, v = c.length, f = "", g = !0, T, b;
+            for (let x = 0; x < v; x += 1) l = c[x], w = l[0], w === "space" && x === v - 1 && !d ? g = !1 : w === "comment" ? (b = c[x - 1] ? c[x - 1][0] : "empty", T = c[x + 1] ? c[x + 1][0] : "empty", !y[b] && !y[T] ? f.slice(-1) === "," ? g = !1 : f += l[1] : g = !1) : f += l[1];
+            if (!g) {
+              let x = c.reduce((k, O) => k + O[1], "");
+              t.raws[h] = { raw: x, value: f };
+            }
+            t[h] = f;
+          }
+          rule(t) {
+            t.pop();
+            let h = new u();
+            this.init(h, t[0][2]), h.raws.between = this.spacesAndCommentsFromEnd(t), this.raw(h, "selector", t), this.current = h;
+          }
+          spacesAndCommentsFromEnd(t) {
+            let h, c = "";
+            for (; t.length && (h = t[t.length - 1][0], !(h !== "space" && h !== "comment")); ) c = t.pop()[1] + c;
+            return c;
+          }
+          spacesAndCommentsFromStart(t) {
+            let h, c = "";
+            for (; t.length && (h = t[0][0], !(h !== "space" && h !== "comment")); ) c += t.shift()[1];
+            return c;
+          }
+          spacesFromEnd(t) {
+            let h, c = "";
+            for (; t.length && (h = t[t.length - 1][0], h === "space"); ) c = t.pop()[1] + c;
+            return c;
+          }
+          stringFrom(t, h) {
+            let c = "";
+            for (let d = h; d < t.length; d++) c += t[d][1];
+            return t.splice(h, t.length - h), c;
+          }
+          unclosedBlock() {
+            let t = this.current.source.start;
+            throw this.input.error("Unclosed block", t.line, t.column);
+          }
+          unclosedBracket(t) {
+            throw this.input.error("Unclosed bracket", { offset: t[2] }, { offset: t[2] + 1 });
+          }
+          unexpectedClose(t) {
+            throw this.input.error("Unexpected }", { offset: t[2] }, { offset: t[2] + 1 });
+          }
+          unknownWord(t) {
+            throw this.input.error("Unknown word " + t[0][1], { offset: t[0][2] }, { offset: t[0][2] + t[0][1].length });
+          }
+          unnamedAtrule(t, h) {
+            throw this.input.error("At-rule without name", { offset: h[2] }, { offset: h[2] + h[1].length });
+          }
+        };
+        s.exports = n;
+      }), Qe = S((e, s) => {
+        var i = pe(), r = je(), a = bt();
+        function o(u, p) {
+          let y = new r(u, p), m = new a(y);
+          try {
+            m.parse();
+          } catch (n) {
+            throw n;
+          }
+          return m.root;
+        }
+        s.exports = o, o.default = o, i.registerParse(o);
+      }), ys = S((e, s) => {
+        var i = wt(), r = je();
+        s.exports = { isInlineComment(a) {
+          if (a[0] === "word" && a[1].slice(0, 2) === "//") {
+            let o = a, u = [], p, y;
+            for (; a; ) {
+              if (/\r?\n/.test(a[1])) {
+                if (/['"].*\r?\n/.test(a[1])) {
+                  u.push(a[1].substring(0, a[1].indexOf(`
+`))), y = a[1].substring(a[1].indexOf(`
+`));
+                  let n = this.input.css.valueOf().substring(this.tokenizer.position());
+                  y += n, p = a[3] + n.length - y.length;
+                } else this.tokenizer.back(a);
+                break;
+              }
+              u.push(a[1]), p = a[2], a = this.tokenizer.nextToken({ ignoreUnclosed: !0 });
+            }
+            let m = ["comment", u.join(""), o[2], p];
+            return this.inlineComment(m), y && (this.input = new r(y), this.tokenizer = i(this.input)), !0;
+          } else if (a[1] === "/") {
+            let o = this.tokenizer.nextToken({ ignoreUnclosed: !0 });
+            if (o[0] === "comment" && /^\/\*/.test(o[1])) return o[0] = "word", o[1] = o[1].slice(1), a[1] = "//", this.tokenizer.back(o), s.exports.isInlineComment.bind(this)(a);
+          }
+          return !1;
+        } };
+      }), vs = S((e, s) => {
+        s.exports = { interpolation(i) {
+          let r = [i, this.tokenizer.nextToken()], a = ["word", "}"];
+          if (r[0][1].length > 1 || r[1][0] !== "{") return this.tokenizer.back(r[1]), !1;
+          for (i = this.tokenizer.nextToken(); i && a.includes(i[0]); ) r.push(i), i = this.tokenizer.nextToken();
+          let o = r.map((m) => m[1]), [u] = r, p = r.pop(), y = ["word", o.join(""), u[2], p[2]];
+          return this.tokenizer.back(i), this.tokenizer.back(y), !0;
+        } };
+      }), gs = S((e, s) => {
+        var i = /^#[0-9a-fA-F]{6}$|^#[0-9a-fA-F]{3}$/, r = /\.[0-9]/, a = (o) => {
+          let [, u] = o, [p] = u;
+          return (p === "." || p === "#") && i.test(u) === !1 && r.test(u) === !1;
+        };
+        s.exports = { isMixinToken: a };
+      }), ws = S((e, s) => {
+        var i = wt(), r = /^url\((.+)\)/;
+        s.exports = (a) => {
+          let { name: o, params: u = "" } = a;
+          if (o === "import" && u.length) {
+            a.import = !0;
+            let p = i({ css: u });
+            for (a.filename = u.replace(r, "$1"); !p.endOfFile(); ) {
+              let [y, m] = p.nextToken();
+              if (y === "word" && m === "url") return;
+              if (y === "brackets") {
+                a.options = m, a.filename = u.replace(m, "").trim();
+                break;
+              }
+            }
+          }
+        };
+      }), bs = S((e, s) => {
+        var i = /:$/, r = /^:(\s+)?/;
+        s.exports = (a) => {
+          let { name: o, params: u = "" } = a;
+          if (a.name.slice(-1) === ":") {
+            if (i.test(o)) {
+              let [p] = o.match(i);
+              a.name = o.replace(p, ""), a.raws.afterName = p + (a.raws.afterName || ""), a.variable = !0, a.value = a.params;
+            }
+            if (r.test(u)) {
+              let [p] = u.match(r);
+              a.value = u.replace(p, ""), a.raws.afterName = (a.raws.afterName || "") + p, a.variable = !0;
+            }
+          }
+        };
+      }), xs = S((e, s) => {
+        var i = Ee(), r = bt(), { isInlineComment: a } = ys(), { interpolation: o } = vs(), { isMixinToken: u } = gs(), p = ws(), y = bs(), m = /(!\s*important)$/i;
+        s.exports = class extends r {
+          constructor(...n) {
+            super(...n), this.lastNode = null;
+          }
+          atrule(n) {
+            o.bind(this)(n) || (super.atrule(n), p(this.lastNode), y(this.lastNode));
+          }
+          decl(...n) {
+            super.decl(...n), /extend\(.+\)/i.test(this.lastNode.value) && (this.lastNode.extend = !0);
+          }
+          each(n) {
+            n[0][1] = ` ${n[0][1]}`;
+            let t = n.findIndex((l) => l[0] === "("), h = n.reverse().find((l) => l[0] === ")"), c = n.reverse().indexOf(h), d = n.splice(t, c).map((l) => l[1]).join("");
+            for (let l of n.reverse()) this.tokenizer.back(l);
+            this.atrule(this.tokenizer.nextToken()), this.lastNode.function = !0, this.lastNode.params = d;
+          }
+          init(n, t, h) {
+            super.init(n, t, h), this.lastNode = n;
+          }
+          inlineComment(n) {
+            let t = new i(), h = n[1].slice(2);
+            if (this.init(t, n[2]), t.source.end = this.getPosition(n[3] || n[2]), t.inline = !0, t.raws.begin = "//", /^\s*$/.test(h)) t.text = "", t.raws.left = h, t.raws.right = "";
+            else {
+              let c = h.match(/^(\s*)([^]*[^\s])(\s*)$/);
+              [, t.raws.left, t.text, t.raws.right] = c;
+            }
+          }
+          mixin(n) {
+            let [t] = n, h = t[1].slice(0, 1), c = n.findIndex((f) => f[0] === "brackets"), d = n.findIndex((f) => f[0] === "("), l = "";
+            if ((c < 0 || c > 3) && d > 0) {
+              let f = n.reduce((P, W, R) => W[0] === ")" ? R : P), g = n.slice(d, f + d).map((P) => P[1]).join(""), [T] = n.slice(d), b = [T[2], T[3]], [x] = n.slice(f, f + 1), k = [x[2], x[3]], O = ["brackets", g].concat(b, k), A = n.slice(0, d), E = n.slice(f + 1);
+              n = A, n.push(O), n = n.concat(E);
+            }
+            let w = [];
+            for (let f of n) if ((f[1] === "!" || w.length) && w.push(f), f[1] === "important") break;
+            if (w.length) {
+              let [f] = w, g = n.indexOf(f), T = w[w.length - 1], b = [f[2], f[3]], x = [T[4], T[5]], k = ["word", w.map((O) => O[1]).join("")].concat(b, x);
+              n.splice(g, w.length, k);
+            }
+            let v = n.findIndex((f) => m.test(f[1]));
+            v > 0 && ([, l] = n[v], n.splice(v, 1));
+            for (let f of n.reverse()) this.tokenizer.back(f);
+            this.atrule(this.tokenizer.nextToken()), this.lastNode.mixin = !0, this.lastNode.raws.identifier = h, l && (this.lastNode.important = !0, this.lastNode.raws.important = l);
+          }
+          other(n) {
+            a.bind(this)(n) || super.other(n);
+          }
+          rule(n) {
+            let t = n[n.length - 1], h = n[n.length - 2];
+            if (h[0] === "at-word" && t[0] === "{" && (this.tokenizer.back(t), o.bind(this)(h))) {
+              let c = this.tokenizer.nextToken();
+              n = n.slice(0, n.length - 2).concat([c]);
+              for (let d of n.reverse()) this.tokenizer.back(d);
+              return;
+            }
+            super.rule(n), /:extend\(.+\)/i.test(this.lastNode.selector) && (this.lastNode.extend = !0);
+          }
+          unknownWord(n) {
+            let [t] = n;
+            if (n[0][1] === "each" && n[1][0] === "(") {
+              this.each(n);
+              return;
+            }
+            if (u(t)) {
+              this.mixin(n);
+              return;
+            }
+            super.unknownWord(n);
+          }
+        };
+      }), ks = S((e, s) => {
+        var i = mt();
+        s.exports = class extends i {
+          atrule(r, a) {
+            if (!r.mixin && !r.variable && !r.function) {
+              super.atrule(r, a);
+              return;
+            }
+            let o = `${r.function ? "" : r.raws.identifier || "@"}${r.name}`, u = r.params ? this.rawValue(r, "params") : "", p = r.raws.important || "";
+            if (r.variable && (u = r.value), typeof r.raws.afterName < "u" ? o += r.raws.afterName : u && (o += " "), r.nodes) this.block(r, o + u + p);
+            else {
+              let y = (r.raws.between || "") + p + (a ? ";" : "");
+              this.builder(o + u + y, r);
+            }
+          }
+          comment(r) {
+            if (r.inline) {
+              let a = this.raw(r, "left", "commentLeft"), o = this.raw(r, "right", "commentRight");
+              this.builder(`//${a}${r.text}${o}`, r);
+            } else super.comment(r);
+          }
+        };
+      }), Os = S((e, s) => {
+        var i = je(), r = xs(), a = ks();
+        s.exports = { parse(o, u) {
+          let p = new i(o, u), y = new r(p);
+          return y.parse(), y.root.walk((m) => {
+            let n = p.css.lastIndexOf(m.source.input.css);
+            if (n === 0) return;
+            if (n + m.source.input.css.length !== p.css.length) throw new Error("Invalid state detected in postcss-less");
+            let t = n + m.source.start.offset, h = p.fromOffset(n + m.source.start.offset);
+            if (m.source.start = { offset: t, line: h.line, column: h.col }, m.source.end) {
+              let c = n + m.source.end.offset, d = p.fromOffset(n + m.source.end.offset);
+              m.source.end = { offset: c, line: d.line, column: d.col };
+            }
+          }), y.root;
+        }, stringify(o, u) {
+          new a(u).stringify(o);
+        }, nodeToString(o) {
+          let u = "";
+          return s.exports.stringify(o, (p) => {
+            u += p;
+          }), u;
+        } };
+      }), xt = S((e, s) => {
+        var i = pe(), r, a, o = class extends i {
+          constructor(u) {
+            super({ type: "document", ...u }), this.nodes || (this.nodes = []);
+          }
+          toResult(u = {}) {
+            return new r(new a(), this, u).stringify();
+          }
+        };
+        o.registerLazyResult = (u) => {
+          r = u;
+        }, o.registerProcessor = (u) => {
+          a = u;
+        }, s.exports = o, o.default = o;
+      }), Ts = S((e, s) => {
+        var i = vt(), r = Ee(), a = Je(), o = je(), u = Yt(), p = Ie(), y = gt();
+        function m(n, t) {
+          if (Array.isArray(n)) return n.map((d) => m(d));
+          let { inputs: h, ...c } = n;
+          if (h) {
+            t = [];
+            for (let d of h) {
+              let l = { ...d, __proto__: o.prototype };
+              l.map && (l.map = { ...l.map, __proto__: u.prototype }), t.push(l);
+            }
+          }
+          if (c.nodes && (c.nodes = n.nodes.map((d) => m(d, t))), c.source) {
+            let { inputId: d, ...l } = c.source;
+            c.source = l, d != null && (c.source.input = t[d]);
+          }
+          if (c.type === "root") return new p(c);
+          if (c.type === "decl") return new a(c);
+          if (c.type === "rule") return new y(c);
+          if (c.type === "comment") return new r(c);
+          if (c.type === "atrule") return new i(c);
+          throw new Error("Unknown node type: " + n.type);
+        }
+        s.exports = m, m.default = m;
+      }), Xt = S((e, s) => {
+        s.exports = class {
+          generate() {
+          }
+        };
+      }), er = S((e, s) => {
+        var i = class {
+          constructor(r, a = {}) {
+            if (this.type = "warning", this.text = r, a.node && a.node.source) {
+              let o = a.node.rangeBy(a);
+              this.line = o.start.line, this.column = o.start.column, this.endLine = o.end.line, this.endColumn = o.end.column;
+            }
+            for (let o in a) this[o] = a[o];
+          }
+          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;
+          }
+        };
+        s.exports = i, i.default = i;
+      }), kt = S((e, s) => {
+        var i = er(), r = class {
+          get content() {
+            return this.css;
+          }
+          constructor(a, o, u) {
+            this.processor = a, this.messages = [], this.root = o, this.opts = u, this.css = "", this.map = void 0;
+          }
+          toString() {
+            return this.css;
+          }
+          warn(a, o = {}) {
+            o.plugin || this.lastPlugin && this.lastPlugin.postcssPlugin && (o.plugin = this.lastPlugin.postcssPlugin);
+            let u = new i(a, o);
+            return this.messages.push(u), u;
+          }
+          warnings() {
+            return this.messages.filter((a) => a.type === "warning");
+          }
+        };
+        s.exports = r, r.default = r;
+      }), tr = S((e, s) => {
+        var i = {};
+        s.exports = function(r) {
+          i[r] || (i[r] = !0, typeof console < "u" && console.warn && console.warn(r));
+        };
+      }), rr = S((e, s) => {
+        var i = pe(), r = xt(), a = Xt(), o = Qe(), u = kt(), p = Ie(), y = Ge(), { isClean: m, my: n } = yt();
+        tr();
+        var t = { atrule: "AtRule", comment: "Comment", decl: "Declaration", document: "Document", root: "Root", rule: "Rule" }, h = { 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 }, c = { Once: !0, postcssPlugin: !0, prepare: !0 }, d = 0;
+        function l(b) {
+          return typeof b == "object" && typeof b.then == "function";
+        }
+        function w(b) {
+          let x = !1, k = t[b.type];
+          return b.type === "decl" ? x = b.prop.toLowerCase() : b.type === "atrule" && (x = b.name.toLowerCase()), x && b.append ? [k, k + "-" + x, d, k + "Exit", k + "Exit-" + x] : x ? [k, k + "-" + x, k + "Exit", k + "Exit-" + x] : b.append ? [k, d, k + "Exit"] : [k, k + "Exit"];
+        }
+        function v(b) {
+          let x;
+          return b.type === "document" ? x = ["Document", d, "DocumentExit"] : b.type === "root" ? x = ["Root", d, "RootExit"] : x = w(b), { eventIndex: 0, events: x, iterator: 0, node: b, visitorIndex: 0, visitors: [] };
+        }
+        function f(b) {
+          return b[m] = !1, b.nodes && b.nodes.forEach((x) => f(x)), b;
+        }
+        var g = {}, T = class us {
+          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";
+          }
+          constructor(x, k, O) {
+            this.stringified = !1, this.processed = !1;
+            let A;
+            if (typeof k == "object" && k !== null && (k.type === "root" || k.type === "document")) A = f(k);
+            else if (k instanceof us || k instanceof u) A = f(k.root), k.map && (typeof O.map > "u" && (O.map = {}), O.map.inline || (O.map.inline = !1), O.map.prev = k.map);
+            else {
+              let E = o;
+              O.syntax && (E = O.syntax.parse), O.parser && (E = O.parser), E.parse && (E = E.parse);
+              try {
+                A = E(k, O);
+              } catch (P) {
+                this.processed = !0, this.error = P;
+              }
+              A && !A[n] && i.rebuild(A);
+            }
+            this.result = new u(x, A, O), this.helpers = { ...g, postcss: g, result: this.result }, this.plugins = this.processor.plugins.map((E) => typeof E == "object" && E.prepare ? { ...E, ...E.prepare(this.result) } : E);
+          }
+          async() {
+            return this.error ? Promise.reject(this.error) : this.processed ? Promise.resolve(this.result) : (this.processing || (this.processing = this.runAsync()), this.processing);
+          }
+          catch(x) {
+            return this.async().catch(x);
+          }
+          finally(x) {
+            return this.async().then(x, x);
+          }
+          getAsyncError() {
+            throw new Error("Use process(css).then(cb) to work with async plugins");
+          }
+          handleError(x, k) {
+            let O = this.result.lastPlugin;
+            try {
+              k && k.addToError(x), this.error = x, x.name === "CssSyntaxError" && !x.plugin ? (x.plugin = O.postcssPlugin, x.setMessage()) : O.postcssVersion;
+            } catch (A) {
+              console && console.error && console.error(A);
+            }
+            return x;
+          }
+          prepareVisitors() {
+            this.listeners = {};
+            let x = (k, O, A) => {
+              this.listeners[O] || (this.listeners[O] = []), this.listeners[O].push([k, A]);
+            };
+            for (let k of this.plugins) if (typeof k == "object") for (let O in k) {
+              if (!h[O] && /^[A-Z]/.test(O)) throw new Error(`Unknown event ${O} in ${k.postcssPlugin}. Try to update PostCSS (${this.processor.version} now).`);
+              if (!c[O]) if (typeof k[O] == "object") for (let A in k[O]) A === "*" ? x(k, O, k[O][A]) : x(k, O + "-" + A.toLowerCase(), k[O][A]);
+              else typeof k[O] == "function" && x(k, O, k[O]);
+            }
+            this.hasListener = Object.keys(this.listeners).length > 0;
+          }
+          async runAsync() {
+            this.plugin = 0;
+            for (let x = 0; x < this.plugins.length; x++) {
+              let k = this.plugins[x], O = this.runOnRoot(k);
+              if (l(O)) try {
+                await O;
+              } catch (A) {
+                throw this.handleError(A);
+              }
+            }
+            if (this.prepareVisitors(), this.hasListener) {
+              let x = this.result.root;
+              for (; !x[m]; ) {
+                x[m] = !0;
+                let k = [v(x)];
+                for (; k.length > 0; ) {
+                  let O = this.visitTick(k);
+                  if (l(O)) try {
+                    await O;
+                  } catch (A) {
+                    let E = k[k.length - 1].node;
+                    throw this.handleError(A, E);
+                  }
+                }
+              }
+              if (this.listeners.OnceExit) for (let [k, O] of this.listeners.OnceExit) {
+                this.result.lastPlugin = k;
+                try {
+                  if (x.type === "document") {
+                    let A = x.nodes.map((E) => O(E, this.helpers));
+                    await Promise.all(A);
+                  } else await O(x, this.helpers);
+                } catch (A) {
+                  throw this.handleError(A);
+                }
+              }
+            }
+            return this.processed = !0, this.stringify();
+          }
+          runOnRoot(x) {
+            this.result.lastPlugin = x;
+            try {
+              if (typeof x == "object" && x.Once) {
+                if (this.result.root.type === "document") {
+                  let k = this.result.root.nodes.map((O) => x.Once(O, this.helpers));
+                  return l(k[0]) ? Promise.all(k) : k;
+                }
+                return x.Once(this.result.root, this.helpers);
+              } else if (typeof x == "function") return x(this.result.root, this.result);
+            } catch (k) {
+              throw this.handleError(k);
+            }
+          }
+          stringify() {
+            if (this.error) throw this.error;
+            if (this.stringified) return this.result;
+            this.stringified = !0, this.sync();
+            let x = this.result.opts, k = y;
+            x.syntax && (k = x.syntax.stringify), x.stringifier && (k = x.stringifier), k.stringify && (k = k.stringify);
+            let O = new a(k, this.result.root, this.result.opts).generate();
+            return this.result.css = O[0], this.result.map = O[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 x of this.plugins) {
+              let k = this.runOnRoot(x);
+              if (l(k)) throw this.getAsyncError();
+            }
+            if (this.prepareVisitors(), this.hasListener) {
+              let x = this.result.root;
+              for (; !x[m]; ) x[m] = !0, this.walkSync(x);
+              if (this.listeners.OnceExit) if (x.type === "document") for (let k of x.nodes) this.visitSync(this.listeners.OnceExit, k);
+              else this.visitSync(this.listeners.OnceExit, x);
+            }
+            return this.result;
+          }
+          then(x, k) {
+            return this.async().then(x, k);
+          }
+          toString() {
+            return this.css;
+          }
+          visitSync(x, k) {
+            for (let [O, A] of x) {
+              this.result.lastPlugin = O;
+              let E;
+              try {
+                E = A(k, this.helpers);
+              } catch (P) {
+                throw this.handleError(P, k.proxyOf);
+              }
+              if (k.type !== "root" && k.type !== "document" && !k.parent) return !0;
+              if (l(E)) throw this.getAsyncError();
+            }
+          }
+          visitTick(x) {
+            let k = x[x.length - 1], { node: O, visitors: A } = k;
+            if (O.type !== "root" && O.type !== "document" && !O.parent) {
+              x.pop();
+              return;
+            }
+            if (A.length > 0 && k.visitorIndex < A.length) {
+              let [P, W] = A[k.visitorIndex];
+              k.visitorIndex += 1, k.visitorIndex === A.length && (k.visitors = [], k.visitorIndex = 0), this.result.lastPlugin = P;
+              try {
+                return W(O.toProxy(), this.helpers);
+              } catch (R) {
+                throw this.handleError(R, O);
+              }
+            }
+            if (k.iterator !== 0) {
+              let P = k.iterator, W;
+              for (; W = O.nodes[O.indexes[P]]; ) if (O.indexes[P] += 1, !W[m]) {
+                W[m] = !0, x.push(v(W));
+                return;
+              }
+              k.iterator = 0, delete O.indexes[P];
+            }
+            let E = k.events;
+            for (; k.eventIndex < E.length; ) {
+              let P = E[k.eventIndex];
+              if (k.eventIndex += 1, P === d) {
+                O.nodes && O.nodes.length && (O[m] = !0, k.iterator = O.getIterator());
+                return;
+              } else if (this.listeners[P]) {
+                k.visitors = this.listeners[P];
+                return;
+              }
+            }
+            x.pop();
+          }
+          walkSync(x) {
+            x[m] = !0;
+            let k = w(x);
+            for (let O of k) if (O === d) x.nodes && x.each((A) => {
+              A[m] || this.walkSync(A);
+            });
+            else {
+              let A = this.listeners[O];
+              if (A && this.visitSync(A, x.toProxy())) return;
+            }
+          }
+          warnings() {
+            return this.sync().warnings();
+          }
+        };
+        T.registerPostcss = (b) => {
+          g = b;
+        }, s.exports = T, T.default = T, p.registerLazyResult(T), r.registerLazyResult(T);
+      }), _s = S((e, s) => {
+        var i = Xt(), r = Qe(), a = kt(), o = Ge();
+        tr();
+        var u = class {
+          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 p, y = r;
+            try {
+              p = y(this._css, this._opts);
+            } catch (m) {
+              this.error = m;
+            }
+            if (this.error) throw this.error;
+            return this._root = p, p;
+          }
+          get [Symbol.toStringTag]() {
+            return "NoWorkResult";
+          }
+          constructor(p, y, m) {
+            y = y.toString(), this.stringified = !1, this._processor = p, this._css = y, this._opts = m, this._map = void 0;
+            let n, t = o;
+            this.result = new a(this._processor, n, this._opts), this.result.css = y;
+            let h = this;
+            Object.defineProperty(this.result, "root", { get() {
+              return h.root;
+            } });
+            let c = new i(t, n, this._opts, y);
+            if (c.isMap()) {
+              let [d, l] = c.generate();
+              d && (this.result.css = d), l && (this.result.map = l);
+            } else c.clearAnnotation(), this.result.css = c.css;
+          }
+          async() {
+            return this.error ? Promise.reject(this.error) : Promise.resolve(this.result);
+          }
+          catch(p) {
+            return this.async().catch(p);
+          }
+          finally(p) {
+            return this.async().then(p, p);
+          }
+          sync() {
+            if (this.error) throw this.error;
+            return this.result;
+          }
+          then(p, y) {
+            return this.async().then(p, y);
+          }
+          toString() {
+            return this._css;
+          }
+          warnings() {
+            return [];
+          }
+        };
+        s.exports = u, u.default = u;
+      }), Cs = S((e, s) => {
+        var i = xt(), r = rr(), a = _s(), o = Ie(), u = class {
+          constructor(p = []) {
+            this.version = "8.5.6", this.plugins = this.normalize(p);
+          }
+          normalize(p) {
+            let y = [];
+            for (let m of p) if (m.postcss === !0 ? m = m() : m.postcss && (m = m.postcss), typeof m == "object" && Array.isArray(m.plugins)) y = y.concat(m.plugins);
+            else if (typeof m == "object" && m.postcssPlugin) y.push(m);
+            else if (typeof m == "function") y.push(m);
+            else if (!(typeof m == "object" && (m.parse || m.stringify))) throw new Error(m + " is not a PostCSS plugin");
+            return y;
+          }
+          process(p, y = {}) {
+            return !this.plugins.length && !y.parser && !y.stringifier && !y.syntax ? new a(this, p, y) : new r(this, p, y);
+          }
+          use(p) {
+            return this.plugins = this.plugins.concat(this.normalize([p])), this;
+          }
+        };
+        s.exports = u, u.default = u, o.registerProcessor(u), i.registerProcessor(u);
+      }), Ot = S((e, s) => {
+        var i = vt(), r = Ee(), a = pe(), o = dt(), u = Je(), p = xt(), y = Ts(), m = je(), n = rr(), t = Kt(), h = He(), c = Qe(), d = Cs(), l = kt(), w = Ie(), v = gt(), f = Ge(), g = er();
+        function T(...b) {
+          return b.length === 1 && Array.isArray(b[0]) && (b = b[0]), new d(b);
+        }
+        T.plugin = function(b, x) {
+          let k = !1;
+          function O(...E) {
+            console && console.warn && !k && (k = !0, console.warn(b + `: postcss.plugin was deprecated. Migration guide:
+https://evilmartians.com/chronicles/postcss-8-plugin-migration`));
+            let P = x(...E);
+            return P.postcssPlugin = b, P.postcssVersion = new d().version, P;
+          }
+          let A;
+          return Object.defineProperty(O, "postcss", { get() {
+            return A || (A = O()), A;
+          } }), O.process = function(E, P, W) {
+            return T([O(W)]).process(E, P);
+          }, O;
+        }, T.stringify = f, T.parse = c, T.fromJSON = y, T.list = t, T.comment = (b) => new r(b), T.atRule = (b) => new i(b), T.decl = (b) => new u(b), T.rule = (b) => new v(b), T.root = (b) => new w(b), T.document = (b) => new p(b), T.CssSyntaxError = o, T.Declaration = u, T.Container = a, T.Processor = d, T.Document = p, T.Comment = r, T.Warning = g, T.AtRule = i, T.Result = l, T.Input = m, T.Rule = v, T.Root = w, T.Node = h, n.registerPostcss(T), s.exports = T, T.default = T;
+      }), Ss = S((e, s) => {
+        var { Container: i } = Ot(), r = class extends i {
+          constructor(a) {
+            super(a), this.type = "decl", this.isNested = !0, this.nodes || (this.nodes = []);
+          }
+        };
+        s.exports = r;
+      }), As = S((e, s) => {
+        var i = /[\t\n\f\r "#'()/;[\\\]{}]/g, r = /[,\t\n\f\r !"#'():;@[\\\]{}]|\/(?=\*)/g, a = /.[\r\n"'(/\\]/, o = /[\da-f]/i, u = /[\n\f\r]/g;
+        s.exports = function(p, y = {}) {
+          let m = p.css.valueOf(), n = y.ignoreErrors, t, h, c, d, l, w, v, f, g, T = m.length, b = 0, x = [], k = [], O;
+          function A() {
+            return b;
+          }
+          function E(M) {
+            throw p.error("Unclosed " + M, b);
+          }
+          function P() {
+            return k.length === 0 && b >= T;
+          }
+          function W() {
+            let M = 1, I = !1, U = !1;
+            for (; M > 0; ) h += 1, m.length <= h && E("interpolation"), t = m.charCodeAt(h), f = m.charCodeAt(h + 1), I ? !U && t === I ? (I = !1, U = !1) : t === 92 ? U = !U : U && (U = !1) : t === 39 || t === 34 ? I = t : t === 125 ? M -= 1 : t === 35 && f === 123 && (M += 1);
+          }
+          function R(M) {
+            if (k.length) return k.pop();
+            if (b >= T) return;
+            let I = M ? M.ignoreUnclosed : !1;
+            switch (t = m.charCodeAt(b), t) {
+              case 10:
+              case 32:
+              case 9:
+              case 13:
+              case 12: {
+                h = b;
+                do
+                  h += 1, t = m.charCodeAt(h);
+                while (t === 32 || t === 10 || t === 9 || t === 13 || t === 12);
+                g = ["space", m.slice(b, h)], b = h - 1;
+                break;
+              }
+              case 91:
+              case 93:
+              case 123:
+              case 125:
+              case 58:
+              case 59:
+              case 41: {
+                let U = String.fromCharCode(t);
+                g = [U, U, b];
+                break;
+              }
+              case 44: {
+                g = ["word", ",", b, b + 1];
+                break;
+              }
+              case 40: {
+                if (v = x.length ? x.pop()[1] : "", f = m.charCodeAt(b + 1), v === "url" && f !== 39 && f !== 34) {
+                  for (O = 1, w = !1, h = b + 1; h <= m.length - 1; ) {
+                    if (f = m.charCodeAt(h), f === 92) w = !w;
+                    else if (f === 40) O += 1;
+                    else if (f === 41 && (O -= 1, O === 0)) break;
+                    h += 1;
+                  }
+                  d = m.slice(b, h + 1), g = ["brackets", d, b, h], b = h;
+                } else h = m.indexOf(")", b + 1), d = m.slice(b, h + 1), h === -1 || a.test(d) ? g = ["(", "(", b] : (g = ["brackets", d, b, h], b = h);
+                break;
+              }
+              case 39:
+              case 34: {
+                for (c = t, h = b, w = !1; h < T && (h++, h === T && E("string"), t = m.charCodeAt(h), f = m.charCodeAt(h + 1), !(!w && t === c)); ) t === 92 ? w = !w : w ? w = !1 : t === 35 && f === 123 && W();
+                g = ["string", m.slice(b, h + 1), b, h], b = h;
+                break;
+              }
+              case 64: {
+                i.lastIndex = b + 1, i.test(m), i.lastIndex === 0 ? h = m.length - 1 : h = i.lastIndex - 2, g = ["at-word", m.slice(b, h + 1), b, h], b = h;
+                break;
+              }
+              case 92: {
+                for (h = b, l = !0; m.charCodeAt(h + 1) === 92; ) h += 1, l = !l;
+                if (t = m.charCodeAt(h + 1), l && t !== 47 && t !== 32 && t !== 10 && t !== 9 && t !== 13 && t !== 12 && (h += 1, o.test(m.charAt(h)))) {
+                  for (; o.test(m.charAt(h + 1)); ) h += 1;
+                  m.charCodeAt(h + 1) === 32 && (h += 1);
+                }
+                g = ["word", m.slice(b, h + 1), b, h], b = h;
+                break;
+              }
+              default:
+                f = m.charCodeAt(b + 1), t === 35 && f === 123 ? (h = b, W(), d = m.slice(b, h + 1), g = ["word", d, b, h], b = h) : t === 47 && f === 42 ? (h = m.indexOf("*/", b + 2) + 1, h === 0 && (n || I ? h = m.length : E("comment")), g = ["comment", m.slice(b, h + 1), b, h], b = h) : t === 47 && f === 47 ? (u.lastIndex = b + 1, u.test(m), u.lastIndex === 0 ? h = m.length - 1 : h = u.lastIndex - 2, d = m.slice(b, h + 1), g = ["comment", d, b, h, "inline"], b = h) : (r.lastIndex = b + 1, r.test(m), r.lastIndex === 0 ? h = m.length - 1 : h = r.lastIndex - 2, g = ["word", m.slice(b, h + 1), b, h], x.push(g), b = h);
+                break;
+            }
+            return b++, g;
+          }
+          function $(M) {
+            k.push(M);
+          }
+          return { back: $, endOfFile: P, nextToken: R, position: A };
+        };
+      }), Es = S((e, s) => {
+        var { Comment: i } = Ot(), r = bt(), a = Ss(), o = As(), u = class extends r {
+          atrule(p) {
+            let y = p[1], m = p;
+            for (; !this.tokenizer.endOfFile(); ) {
+              let n = this.tokenizer.nextToken();
+              if (n[0] === "word" && n[2] === m[3] + 1) y += n[1], m = n;
+              else {
+                this.tokenizer.back(n);
+                break;
+              }
+            }
+            super.atrule(["at-word", y, p[2], m[3]]);
+          }
+          comment(p) {
+            if (p[4] === "inline") {
+              let y = new i();
+              this.init(y, p[2]), y.raws.inline = !0;
+              let m = this.input.fromOffset(p[3]);
+              y.source.end = { column: m.col, line: m.line, offset: p[3] + 1 };
+              let n = p[1].slice(2);
+              if (/^\s*$/.test(n)) y.text = "", y.raws.left = n, y.raws.right = "";
+              else {
+                let t = n.match(/^(\s*)([^]*\S)(\s*)$/), h = t[2].replace(/(\*\/|\/\*)/g, "*//*");
+                y.text = h, y.raws.left = t[1], y.raws.right = t[3], y.raws.text = t[2];
+              }
+            } else super.comment(p);
+          }
+          createTokenizer() {
+            this.tokenizer = o(this.input);
+          }
+          raw(p, y, m, n) {
+            if (super.raw(p, y, m, n), p.raws[y]) {
+              let t = p.raws[y].raw;
+              p.raws[y].raw = m.reduce((h, c) => {
+                if (c[0] === "comment" && c[4] === "inline") {
+                  let d = c[1].slice(2).replace(/(\*\/|\/\*)/g, "*//*");
+                  return h + "/*" + d + "*/";
+                } else return h + c[1];
+              }, ""), t !== p.raws[y].raw && (p.raws[y].scss = t);
+            }
+          }
+          rule(p) {
+            let y = !1, m = 0, n = "";
+            for (let t of p) if (y) t[0] !== "comment" && t[0] !== "{" && (n += t[1]);
+            else {
+              if (t[0] === "space" && t[1].includes(`
+`)) break;
+              t[0] === "(" ? m += 1 : t[0] === ")" ? m -= 1 : m === 0 && t[0] === ":" && (y = !0);
+            }
+            if (!y || n.trim() === "" || /^[#:A-Za-z-]/.test(n)) super.rule(p);
+            else {
+              p.pop();
+              let t = new a();
+              this.init(t, p[0][2]);
+              let h;
+              for (let d = p.length - 1; d >= 0; d--) if (p[d][0] !== "space") {
+                h = p[d];
+                break;
+              }
+              if (h[3]) {
+                let d = this.input.fromOffset(h[3]);
+                t.source.end = { column: d.col, line: d.line, offset: h[3] + 1 };
+              } else {
+                let d = this.input.fromOffset(h[2]);
+                t.source.end = { column: d.col, line: d.line, offset: h[2] + 1 };
+              }
+              for (; p[0][0] !== "word"; ) t.raws.before += p.shift()[1];
+              if (p[0][2]) {
+                let d = this.input.fromOffset(p[0][2]);
+                t.source.start = { column: d.col, line: d.line, offset: p[0][2] };
+              }
+              for (t.prop = ""; p.length; ) {
+                let d = p[0][0];
+                if (d === ":" || d === "space" || d === "comment") break;
+                t.prop += p.shift()[1];
+              }
+              t.raws.between = "";
+              let c;
+              for (; p.length; ) if (c = p.shift(), c[0] === ":") {
+                t.raws.between += c[1];
+                break;
+              } else t.raws.between += c[1];
+              (t.prop[0] === "_" || t.prop[0] === "*") && (t.raws.before += t.prop[0], t.prop = t.prop.slice(1)), t.raws.between += this.spacesAndCommentsFromStart(p), this.precheckMissedSemicolon(p);
+              for (let d = p.length - 1; d > 0; d--) {
+                if (c = p[d], c[1] === "!important") {
+                  t.important = !0;
+                  let l = this.stringFrom(p, d);
+                  l = this.spacesFromEnd(p) + l, l !== " !important" && (t.raws.important = l);
+                  break;
+                } else if (c[1] === "important") {
+                  let l = p.slice(0), w = "";
+                  for (let v = d; v > 0; v--) {
+                    let f = l[v][0];
+                    if (w.trim().indexOf("!") === 0 && f !== "space") break;
+                    w = l.pop()[1] + w;
+                  }
+                  w.trim().indexOf("!") === 0 && (t.important = !0, t.raws.important = w, p = l);
+                }
+                if (c[0] !== "space" && c[0] !== "comment") break;
+              }
+              this.raw(t, "value", p), t.value.includes(":") && this.checkMissedSemicolon(p), this.current = t;
+            }
+          }
+        };
+        s.exports = u;
+      }), js = S((e, s) => {
+        var { Input: i } = Ot(), r = Es();
+        s.exports = function(a, o) {
+          let u = new i(a, o), p = new r(u);
+          return p.parse(), p.root;
+        };
+      }), sr = S((e) => {
+        Object.defineProperty(e, "__esModule", { value: !0 });
+        function s(i) {
+          this.after = i.after, this.before = i.before, this.type = i.type, this.value = i.value, this.sourceIndex = i.sourceIndex;
+        }
+        e.default = s;
+      }), nr = S((e) => {
+        Object.defineProperty(e, "__esModule", { value: !0 });
+        var s = sr(), i = r(s);
+        function r(o) {
+          return o && o.__esModule ? o : { default: o };
+        }
+        function a(o) {
+          var u = this;
+          this.constructor(o), this.nodes = o.nodes, this.after === void 0 && (this.after = this.nodes.length > 0 ? this.nodes[this.nodes.length - 1].after : ""), this.before === void 0 && (this.before = this.nodes.length > 0 ? this.nodes[0].before : ""), this.sourceIndex === void 0 && (this.sourceIndex = this.before.length), this.nodes.forEach(function(p) {
+            p.parent = u;
+          });
+        }
+        a.prototype = Object.create(i.default.prototype), a.constructor = i.default, a.prototype.walk = function(o, u) {
+          for (var p = typeof o == "string" || o instanceof RegExp, y = p ? u : o, m = typeof o == "string" ? new RegExp(o) : o, n = 0; n < this.nodes.length; n++) {
+            var t = this.nodes[n], h = p ? m.test(t.type) : !0;
+            if (h && y && y(t, n, this.nodes) === !1 || t.nodes && t.walk(o, u) === !1) return !1;
+          }
+          return !0;
+        }, a.prototype.each = function() {
+          for (var o = arguments.length <= 0 || arguments[0] === void 0 ? function() {
+          } : arguments[0], u = 0; u < this.nodes.length; u++) {
+            var p = this.nodes[u];
+            if (o(p, u, this.nodes) === !1) return !1;
+          }
+          return !0;
+        }, e.default = a;
+      }), Is = S((e) => {
+        Object.defineProperty(e, "__esModule", { value: !0 }), e.parseMediaFeature = u, e.parseMediaQuery = p, e.parseMediaList = y;
+        var s = sr(), i = o(s), r = nr(), a = o(r);
+        function o(m) {
+          return m && m.__esModule ? m : { default: m };
+        }
+        function u(m) {
+          var n = arguments.length <= 1 || arguments[1] === void 0 ? 0 : arguments[1], t = [{ mode: "normal", character: null }], h = [], c = 0, d = "", l = null, w = null, v = n, f = m;
+          m[0] === "(" && m[m.length - 1] === ")" && (f = m.substring(1, m.length - 1), v++);
+          for (var g = 0; g < f.length; g++) {
+            var T = f[g];
+            if ((T === "'" || T === '"') && (t[c].isCalculationEnabled === !0 ? (t.push({ mode: "string", isCalculationEnabled: !1, character: T }), c++) : t[c].mode === "string" && t[c].character === T && f[g - 1] !== "\\" && (t.pop(), c--)), T === "{" ? (t.push({ mode: "interpolation", isCalculationEnabled: !0 }), c++) : T === "}" && (t.pop(), c--), t[c].mode === "normal" && T === ":") {
+              var b = f.substring(g + 1);
+              w = { type: "value", before: /^(\s*)/.exec(b)[1], after: /(\s*)$/.exec(b)[1], value: b.trim() }, w.sourceIndex = w.before.length + g + 1 + v, l = { type: "colon", sourceIndex: g + v, after: w.before, value: ":" };
+              break;
+            }
+            d += T;
+          }
+          return d = { type: "media-feature", before: /^(\s*)/.exec(d)[1], after: /(\s*)$/.exec(d)[1], value: d.trim() }, d.sourceIndex = d.before.length + v, h.push(d), l !== null && (l.before = d.after, h.push(l)), w !== null && h.push(w), h;
+        }
+        function p(m) {
+          var n = arguments.length <= 1 || arguments[1] === void 0 ? 0 : arguments[1], t = [], h = 0, c = !1, d = void 0;
+          function l() {
+            return { before: "", after: "", value: "" };
+          }
+          d = l();
+          for (var w = 0; w < m.length; w++) {
+            var v = m[w];
+            c ? (d.value += v, (v === "{" || v === "(") && h++, (v === ")" || v === "}") && h--) : v.search(/\s/) !== -1 ? d.before += v : (v === "(" && (d.type = "media-feature-expression", h++), d.value = v, d.sourceIndex = n + w, c = !0), c && h === 0 && (v === ")" || w === m.length - 1 || m[w + 1].search(/\s/) !== -1) && (["not", "only", "and"].indexOf(d.value) !== -1 && (d.type = "keyword"), d.type === "media-feature-expression" && (d.nodes = u(d.value, d.sourceIndex)), t.push(Array.isArray(d.nodes) ? new a.default(d) : new i.default(d)), d = l(), c = !1);
+          }
+          for (var f = 0; f < t.length; f++) if (d = t[f], f > 0 && (t[f - 1].after = d.before), d.type === void 0) {
+            if (f > 0) {
+              if (t[f - 1].type === "media-feature-expression") {
+                d.type = "keyword";
+                continue;
+              }
+              if (t[f - 1].value === "not" || t[f - 1].value === "only") {
+                d.type = "media-type";
+                continue;
+              }
+              if (t[f - 1].value === "and") {
+                d.type = "media-feature-expression";
+                continue;
+              }
+              t[f - 1].type === "media-type" && (t[f + 1] ? d.type = t[f + 1].type === "media-feature-expression" ? "keyword" : "media-feature-expression" : d.type = "media-feature-expression");
+            }
+            if (f === 0) {
+              if (!t[f + 1]) {
+                d.type = "media-type";
+                continue;
+              }
+              if (t[f + 1] && (t[f + 1].type === "media-feature-expression" || t[f + 1].type === "keyword")) {
+                d.type = "media-type";
+                continue;
+              }
+              if (t[f + 2]) {
+                if (t[f + 2].type === "media-feature-expression") {
+                  d.type = "media-type", t[f + 1].type = "keyword";
+                  continue;
+                }
+                if (t[f + 2].type === "keyword") {
+                  d.type = "keyword", t[f + 1].type = "media-type";
+                  continue;
+                }
+              }
+              if (t[f + 3] && t[f + 3].type === "media-feature-expression") {
+                d.type = "keyword", t[f + 1].type = "media-type", t[f + 2].type = "keyword";
+                continue;
+              }
+            }
+          }
+          return t;
+        }
+        function y(m) {
+          var n = [], t = 0, h = 0, c = /^(\s*)url\s*\(/.exec(m);
+          if (c !== null) {
+            for (var d = c[0].length, l = 1; l > 0; ) {
+              var w = m[d];
+              w === "(" && l++, w === ")" && l--, d++;
+            }
+            n.unshift(new i.default({ type: "url", value: m.substring(0, d).trim(), sourceIndex: c[1].length, before: c[1], after: /^(\s*)/.exec(m.substring(d))[1] })), t = d;
+          }
+          for (var v = t; v < m.length; v++) {
+            var f = m[v];
+            if (f === "(" && h++, f === ")" && h--, h === 0 && f === ",") {
+              var g = m.substring(t, v), T = /^(\s*)/.exec(g)[1];
+              n.push(new a.default({ type: "media-query", value: g.trim(), sourceIndex: t + T.length, nodes: p(g, t), before: T, after: /(\s*)$/.exec(g)[1] })), t = v + 1;
+            }
+          }
+          var b = m.substring(t), x = /^(\s*)/.exec(b)[1];
+          return n.push(new a.default({ type: "media-query", value: b.trim(), sourceIndex: t + x.length, nodes: p(b, t), before: x, after: /(\s*)$/.exec(b)[1] })), n;
+        }
+      }), Ps = S((e) => {
+        Object.defineProperty(e, "__esModule", { value: !0 }), e.default = o;
+        var s = nr(), i = a(s), r = Is();
+        function a(u) {
+          return u && u.__esModule ? u : { default: u };
+        }
+        function o(u) {
+          return new i.default({ nodes: (0, r.parseMediaList)(u), type: "media-query-list", value: u.trim() });
+        }
+      }), or = S((e, s) => {
+        s.exports = function(i, r) {
+          if (r = typeof r == "number" ? r : 1 / 0, !r) return Array.isArray(i) ? i.map(function(o) {
+            return o;
+          }) : i;
+          return a(i, 1);
+          function a(o, u) {
+            return o.reduce(function(p, y) {
+              return Array.isArray(y) && u < r ? p.concat(a(y, u + 1)) : p.concat(y);
+            }, []);
+          }
+        };
+      }), ir = S((e, s) => {
+        s.exports = function(i, r) {
+          for (var a = -1, o = []; (a = i.indexOf(r, a + 1)) !== -1; ) o.push(a);
+          return o;
+        };
+      }), ar = S((e, s) => {
+        function i(o, u) {
+          for (var p = 1, y = o.length, m = o[0], n = o[0], t = 1; t < y; ++t) if (n = m, m = o[t], u(m, n)) {
+            if (t === p) {
+              p++;
+              continue;
+            }
+            o[p++] = m;
+          }
+          return o.length = p, o;
+        }
+        function r(o) {
+          for (var u = 1, p = o.length, y = o[0], m = o[0], n = 1; n < p; ++n, m = y) if (m = y, y = o[n], y !== m) {
+            if (n === u) {
+              u++;
+              continue;
+            }
+            o[u++] = y;
+          }
+          return o.length = u, o;
+        }
+        function a(o, u, p) {
+          return o.length === 0 ? o : u ? (p || o.sort(u), i(o, u)) : (p || o.sort(), r(o));
+        }
+        s.exports = a;
+      }), ye = S((e, s) => {
+        e.__esModule = !0;
+        var i = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(u) {
+          return typeof u;
+        } : function(u) {
+          return u && typeof Symbol == "function" && u.constructor === Symbol && u !== Symbol.prototype ? "symbol" : typeof u;
+        };
+        function r(u, p) {
+          if (!(u instanceof p)) throw new TypeError("Cannot call a class as a function");
+        }
+        var a = function u(p, y) {
+          if ((typeof p > "u" ? "undefined" : i(p)) !== "object") return p;
+          var m = new p.constructor();
+          for (var n in p) if (p.hasOwnProperty(n)) {
+            var t = p[n], h = typeof t > "u" ? "undefined" : i(t);
+            n === "parent" && h === "object" ? y && (m[n] = y) : t instanceof Array ? m[n] = t.map(function(c) {
+              return u(c, m);
+            }) : m[n] = u(t, m);
+          }
+          return m;
+        }, o = (function() {
+          function u() {
+            var p = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+            r(this, u);
+            for (var y in p) this[y] = p[y];
+            var m = p.spaces;
+            m = m === void 0 ? {} : m;
+            var n = m.before, t = n === void 0 ? "" : n, h = m.after, c = h === void 0 ? "" : h;
+            this.spaces = { before: t, after: c };
+          }
+          return u.prototype.remove = function() {
+            return this.parent && this.parent.removeChild(this), this.parent = void 0, this;
+          }, u.prototype.replaceWith = function() {
+            if (this.parent) {
+              for (var p in arguments) this.parent.insertBefore(this, arguments[p]);
+              this.remove();
+            }
+            return this;
+          }, u.prototype.next = function() {
+            return this.parent.at(this.parent.index(this) + 1);
+          }, u.prototype.prev = function() {
+            return this.parent.at(this.parent.index(this) - 1);
+          }, u.prototype.clone = function() {
+            var p = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, y = a(this);
+            for (var m in p) y[m] = p[m];
+            return y;
+          }, u.prototype.toString = function() {
+            return [this.spaces.before, String(this.value), this.spaces.after].join("");
+          }, u;
+        })();
+        e.default = o, s.exports = e.default;
+      }), G = S((e) => {
+        e.__esModule = !0, e.TAG = "tag", e.STRING = "string", e.SELECTOR = "selector", e.ROOT = "root", e.PSEUDO = "pseudo", e.NESTING = "nesting", e.ID = "id", e.COMMENT = "comment", e.COMBINATOR = "combinator", e.CLASS = "class", e.ATTRIBUTE = "attribute", e.UNIVERSAL = "universal";
+      }), Tt = S((e, s) => {
+        e.__esModule = !0;
+        var i = /* @__PURE__ */ (function() {
+          function c(d, l) {
+            for (var w = 0; w < l.length; w++) {
+              var v = l[w];
+              v.enumerable = v.enumerable || !1, v.configurable = !0, "value" in v && (v.writable = !0), Object.defineProperty(d, v.key, v);
+            }
+          }
+          return function(d, l, w) {
+            return l && c(d.prototype, l), w && c(d, w), d;
+          };
+        })(), r = ye(), a = y(r), o = G(), u = p(o);
+        function p(c) {
+          if (c && c.__esModule) return c;
+          var d = {};
+          if (c != null) for (var l in c) Object.prototype.hasOwnProperty.call(c, l) && (d[l] = c[l]);
+          return d.default = c, d;
+        }
+        function y(c) {
+          return c && c.__esModule ? c : { default: c };
+        }
+        function m(c, d) {
+          if (!(c instanceof d)) throw new TypeError("Cannot call a class as a function");
+        }
+        function n(c, d) {
+          if (!c) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          return d && (typeof d == "object" || typeof d == "function") ? d : c;
+        }
+        function t(c, d) {
+          if (typeof d != "function" && d !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof d);
+          c.prototype = Object.create(d && d.prototype, { constructor: { value: c, enumerable: !1, writable: !0, configurable: !0 } }), d && (Object.setPrototypeOf ? Object.setPrototypeOf(c, d) : c.__proto__ = d);
+        }
+        var h = (function(c) {
+          t(d, c);
+          function d(l) {
+            m(this, d);
+            var w = n(this, c.call(this, l));
+            return w.nodes || (w.nodes = []), w;
+          }
+          return d.prototype.append = function(l) {
+            return l.parent = this, this.nodes.push(l), this;
+          }, d.prototype.prepend = function(l) {
+            return l.parent = this, this.nodes.unshift(l), this;
+          }, d.prototype.at = function(l) {
+            return this.nodes[l];
+          }, d.prototype.index = function(l) {
+            return typeof l == "number" ? l : this.nodes.indexOf(l);
+          }, d.prototype.removeChild = function(l) {
+            l = this.index(l), this.at(l).parent = void 0, this.nodes.splice(l, 1);
+            var w = void 0;
+            for (var v in this.indexes) w = this.indexes[v], w >= l && (this.indexes[v] = w - 1);
+            return this;
+          }, d.prototype.removeAll = function() {
+            for (var v = this.nodes, l = Array.isArray(v), w = 0, v = l ? v : v[Symbol.iterator](); ; ) {
+              var f;
+              if (l) {
+                if (w >= v.length) break;
+                f = v[w++];
+              } else {
+                if (w = v.next(), w.done) break;
+                f = w.value;
+              }
+              var g = f;
+              g.parent = void 0;
+            }
+            return this.nodes = [], this;
+          }, d.prototype.empty = function() {
+            return this.removeAll();
+          }, d.prototype.insertAfter = function(l, w) {
+            var v = this.index(l);
+            this.nodes.splice(v + 1, 0, w);
+            var f = void 0;
+            for (var g in this.indexes) f = this.indexes[g], v <= f && (this.indexes[g] = f + this.nodes.length);
+            return this;
+          }, d.prototype.insertBefore = function(l, w) {
+            var v = this.index(l);
+            this.nodes.splice(v, 0, w);
+            var f = void 0;
+            for (var g in this.indexes) f = this.indexes[g], v <= f && (this.indexes[g] = f + this.nodes.length);
+            return this;
+          }, d.prototype.each = function(l) {
+            this.lastEach || (this.lastEach = 0), this.indexes || (this.indexes = {}), this.lastEach++;
+            var w = this.lastEach;
+            if (this.indexes[w] = 0, !!this.length) {
+              for (var v = void 0, f = void 0; this.indexes[w] < this.length && (v = this.indexes[w], f = l(this.at(v), v), f !== !1); ) this.indexes[w] += 1;
+              if (delete this.indexes[w], f === !1) return !1;
+            }
+          }, d.prototype.walk = function(l) {
+            return this.each(function(w, v) {
+              var f = l(w, v);
+              if (f !== !1 && w.length && (f = w.walk(l)), f === !1) return !1;
+            });
+          }, d.prototype.walkAttributes = function(l) {
+            var w = this;
+            return this.walk(function(v) {
+              if (v.type === u.ATTRIBUTE) return l.call(w, v);
+            });
+          }, d.prototype.walkClasses = function(l) {
+            var w = this;
+            return this.walk(function(v) {
+              if (v.type === u.CLASS) return l.call(w, v);
+            });
+          }, d.prototype.walkCombinators = function(l) {
+            var w = this;
+            return this.walk(function(v) {
+              if (v.type === u.COMBINATOR) return l.call(w, v);
+            });
+          }, d.prototype.walkComments = function(l) {
+            var w = this;
+            return this.walk(function(v) {
+              if (v.type === u.COMMENT) return l.call(w, v);
+            });
+          }, d.prototype.walkIds = function(l) {
+            var w = this;
+            return this.walk(function(v) {
+              if (v.type === u.ID) return l.call(w, v);
+            });
+          }, d.prototype.walkNesting = function(l) {
+            var w = this;
+            return this.walk(function(v) {
+              if (v.type === u.NESTING) return l.call(w, v);
+            });
+          }, d.prototype.walkPseudos = function(l) {
+            var w = this;
+            return this.walk(function(v) {
+              if (v.type === u.PSEUDO) return l.call(w, v);
+            });
+          }, d.prototype.walkTags = function(l) {
+            var w = this;
+            return this.walk(function(v) {
+              if (v.type === u.TAG) return l.call(w, v);
+            });
+          }, d.prototype.walkUniversals = function(l) {
+            var w = this;
+            return this.walk(function(v) {
+              if (v.type === u.UNIVERSAL) return l.call(w, v);
+            });
+          }, d.prototype.split = function(l) {
+            var w = this, v = [];
+            return this.reduce(function(f, g, T) {
+              var b = l.call(w, g);
+              return v.push(g), b ? (f.push(v), v = []) : T === w.length - 1 && f.push(v), f;
+            }, []);
+          }, d.prototype.map = function(l) {
+            return this.nodes.map(l);
+          }, d.prototype.reduce = function(l, w) {
+            return this.nodes.reduce(l, w);
+          }, d.prototype.every = function(l) {
+            return this.nodes.every(l);
+          }, d.prototype.some = function(l) {
+            return this.nodes.some(l);
+          }, d.prototype.filter = function(l) {
+            return this.nodes.filter(l);
+          }, d.prototype.sort = function(l) {
+            return this.nodes.sort(l);
+          }, d.prototype.toString = function() {
+            return this.map(String).join("");
+          }, i(d, [{ key: "first", get: function() {
+            return this.at(0);
+          } }, { key: "last", get: function() {
+            return this.at(this.length - 1);
+          } }, { key: "length", get: function() {
+            return this.nodes.length;
+          } }]), d;
+        })(a.default);
+        e.default = h, s.exports = e.default;
+      }), Ms = S((e, s) => {
+        e.__esModule = !0;
+        var i = Tt(), r = o(i), a = G();
+        function o(n) {
+          return n && n.__esModule ? n : { default: n };
+        }
+        function u(n, t) {
+          if (!(n instanceof t)) throw new TypeError("Cannot call a class as a function");
+        }
+        function p(n, t) {
+          if (!n) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          return t && (typeof t == "object" || typeof t == "function") ? t : n;
+        }
+        function y(n, t) {
+          if (typeof t != "function" && t !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof t);
+          n.prototype = Object.create(t && t.prototype, { constructor: { value: n, enumerable: !1, writable: !0, configurable: !0 } }), t && (Object.setPrototypeOf ? Object.setPrototypeOf(n, t) : n.__proto__ = t);
+        }
+        var m = (function(n) {
+          y(t, n);
+          function t(h) {
+            u(this, t);
+            var c = p(this, n.call(this, h));
+            return c.type = a.ROOT, c;
+          }
+          return t.prototype.toString = function() {
+            var h = this.reduce(function(c, d) {
+              var l = String(d);
+              return l ? c + l + "," : "";
+            }, "").slice(0, -1);
+            return this.trailingComma ? h + "," : h;
+          }, t;
+        })(r.default);
+        e.default = m, s.exports = e.default;
+      }), $s = S((e, s) => {
+        e.__esModule = !0;
+        var i = Tt(), r = o(i), a = G();
+        function o(n) {
+          return n && n.__esModule ? n : { default: n };
+        }
+        function u(n, t) {
+          if (!(n instanceof t)) throw new TypeError("Cannot call a class as a function");
+        }
+        function p(n, t) {
+          if (!n) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          return t && (typeof t == "object" || typeof t == "function") ? t : n;
+        }
+        function y(n, t) {
+          if (typeof t != "function" && t !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof t);
+          n.prototype = Object.create(t && t.prototype, { constructor: { value: n, enumerable: !1, writable: !0, configurable: !0 } }), t && (Object.setPrototypeOf ? Object.setPrototypeOf(n, t) : n.__proto__ = t);
+        }
+        var m = (function(n) {
+          y(t, n);
+          function t(h) {
+            u(this, t);
+            var c = p(this, n.call(this, h));
+            return c.type = a.SELECTOR, c;
+          }
+          return t;
+        })(r.default);
+        e.default = m, s.exports = e.default;
+      }), Pe = S((e, s) => {
+        e.__esModule = !0;
+        var i = /* @__PURE__ */ (function() {
+          function n(t, h) {
+            for (var c = 0; c < h.length; c++) {
+              var d = h[c];
+              d.enumerable = d.enumerable || !1, d.configurable = !0, "value" in d && (d.writable = !0), Object.defineProperty(t, d.key, d);
+            }
+          }
+          return function(t, h, c) {
+            return h && n(t.prototype, h), c && n(t, c), t;
+          };
+        })(), r = ye(), a = o(r);
+        function o(n) {
+          return n && n.__esModule ? n : { default: n };
+        }
+        function u(n, t) {
+          if (!(n instanceof t)) throw new TypeError("Cannot call a class as a function");
+        }
+        function p(n, t) {
+          if (!n) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          return t && (typeof t == "object" || typeof t == "function") ? t : n;
+        }
+        function y(n, t) {
+          if (typeof t != "function" && t !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof t);
+          n.prototype = Object.create(t && t.prototype, { constructor: { value: n, enumerable: !1, writable: !0, configurable: !0 } }), t && (Object.setPrototypeOf ? Object.setPrototypeOf(n, t) : n.__proto__ = t);
+        }
+        var m = (function(n) {
+          y(t, n);
+          function t() {
+            return u(this, t), p(this, n.apply(this, arguments));
+          }
+          return t.prototype.toString = function() {
+            return [this.spaces.before, this.ns, String(this.value), this.spaces.after].join("");
+          }, i(t, [{ key: "ns", get: function() {
+            var h = this.namespace;
+            return h ? (typeof h == "string" ? h : "") + "|" : "";
+          } }]), t;
+        })(a.default);
+        e.default = m, s.exports = e.default;
+      }), Rs = S((e, s) => {
+        e.__esModule = !0;
+        var i = Pe(), r = o(i), a = G();
+        function o(n) {
+          return n && n.__esModule ? n : { default: n };
+        }
+        function u(n, t) {
+          if (!(n instanceof t)) throw new TypeError("Cannot call a class as a function");
+        }
+        function p(n, t) {
+          if (!n) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          return t && (typeof t == "object" || typeof t == "function") ? t : n;
+        }
+        function y(n, t) {
+          if (typeof t != "function" && t !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof t);
+          n.prototype = Object.create(t && t.prototype, { constructor: { value: n, enumerable: !1, writable: !0, configurable: !0 } }), t && (Object.setPrototypeOf ? Object.setPrototypeOf(n, t) : n.__proto__ = t);
+        }
+        var m = (function(n) {
+          y(t, n);
+          function t(h) {
+            u(this, t);
+            var c = p(this, n.call(this, h));
+            return c.type = a.CLASS, c;
+          }
+          return t.prototype.toString = function() {
+            return [this.spaces.before, this.ns, "." + this.value, this.spaces.after].join("");
+          }, t;
+        })(r.default);
+        e.default = m, s.exports = e.default;
+      }), Ns = S((e, s) => {
+        e.__esModule = !0;
+        var i = ye(), r = o(i), a = G();
+        function o(n) {
+          return n && n.__esModule ? n : { default: n };
+        }
+        function u(n, t) {
+          if (!(n instanceof t)) throw new TypeError("Cannot call a class as a function");
+        }
+        function p(n, t) {
+          if (!n) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          return t && (typeof t == "object" || typeof t == "function") ? t : n;
+        }
+        function y(n, t) {
+          if (typeof t != "function" && t !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof t);
+          n.prototype = Object.create(t && t.prototype, { constructor: { value: n, enumerable: !1, writable: !0, configurable: !0 } }), t && (Object.setPrototypeOf ? Object.setPrototypeOf(n, t) : n.__proto__ = t);
+        }
+        var m = (function(n) {
+          y(t, n);
+          function t(h) {
+            u(this, t);
+            var c = p(this, n.call(this, h));
+            return c.type = a.COMMENT, c;
+          }
+          return t;
+        })(r.default);
+        e.default = m, s.exports = e.default;
+      }), Ls = S((e, s) => {
+        e.__esModule = !0;
+        var i = Pe(), r = o(i), a = G();
+        function o(n) {
+          return n && n.__esModule ? n : { default: n };
+        }
+        function u(n, t) {
+          if (!(n instanceof t)) throw new TypeError("Cannot call a class as a function");
+        }
+        function p(n, t) {
+          if (!n) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          return t && (typeof t == "object" || typeof t == "function") ? t : n;
+        }
+        function y(n, t) {
+          if (typeof t != "function" && t !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof t);
+          n.prototype = Object.create(t && t.prototype, { constructor: { value: n, enumerable: !1, writable: !0, configurable: !0 } }), t && (Object.setPrototypeOf ? Object.setPrototypeOf(n, t) : n.__proto__ = t);
+        }
+        var m = (function(n) {
+          y(t, n);
+          function t(h) {
+            u(this, t);
+            var c = p(this, n.call(this, h));
+            return c.type = a.ID, c;
+          }
+          return t.prototype.toString = function() {
+            return [this.spaces.before, this.ns, "#" + this.value, this.spaces.after].join("");
+          }, t;
+        })(r.default);
+        e.default = m, s.exports = e.default;
+      }), Ws = S((e, s) => {
+        e.__esModule = !0;
+        var i = Pe(), r = o(i), a = G();
+        function o(n) {
+          return n && n.__esModule ? n : { default: n };
+        }
+        function u(n, t) {
+          if (!(n instanceof t)) throw new TypeError("Cannot call a class as a function");
+        }
+        function p(n, t) {
+          if (!n) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          return t && (typeof t == "object" || typeof t == "function") ? t : n;
+        }
+        function y(n, t) {
+          if (typeof t != "function" && t !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof t);
+          n.prototype = Object.create(t && t.prototype, { constructor: { value: n, enumerable: !1, writable: !0, configurable: !0 } }), t && (Object.setPrototypeOf ? Object.setPrototypeOf(n, t) : n.__proto__ = t);
+        }
+        var m = (function(n) {
+          y(t, n);
+          function t(h) {
+            u(this, t);
+            var c = p(this, n.call(this, h));
+            return c.type = a.TAG, c;
+          }
+          return t;
+        })(r.default);
+        e.default = m, s.exports = e.default;
+      }), zs = S((e, s) => {
+        e.__esModule = !0;
+        var i = ye(), r = o(i), a = G();
+        function o(n) {
+          return n && n.__esModule ? n : { default: n };
+        }
+        function u(n, t) {
+          if (!(n instanceof t)) throw new TypeError("Cannot call a class as a function");
+        }
+        function p(n, t) {
+          if (!n) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          return t && (typeof t == "object" || typeof t == "function") ? t : n;
+        }
+        function y(n, t) {
+          if (typeof t != "function" && t !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof t);
+          n.prototype = Object.create(t && t.prototype, { constructor: { value: n, enumerable: !1, writable: !0, configurable: !0 } }), t && (Object.setPrototypeOf ? Object.setPrototypeOf(n, t) : n.__proto__ = t);
+        }
+        var m = (function(n) {
+          y(t, n);
+          function t(h) {
+            u(this, t);
+            var c = p(this, n.call(this, h));
+            return c.type = a.STRING, c;
+          }
+          return t;
+        })(r.default);
+        e.default = m, s.exports = e.default;
+      }), Bs = S((e, s) => {
+        e.__esModule = !0;
+        var i = Tt(), r = o(i), a = G();
+        function o(n) {
+          return n && n.__esModule ? n : { default: n };
+        }
+        function u(n, t) {
+          if (!(n instanceof t)) throw new TypeError("Cannot call a class as a function");
+        }
+        function p(n, t) {
+          if (!n) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          return t && (typeof t == "object" || typeof t == "function") ? t : n;
+        }
+        function y(n, t) {
+          if (typeof t != "function" && t !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof t);
+          n.prototype = Object.create(t && t.prototype, { constructor: { value: n, enumerable: !1, writable: !0, configurable: !0 } }), t && (Object.setPrototypeOf ? Object.setPrototypeOf(n, t) : n.__proto__ = t);
+        }
+        var m = (function(n) {
+          y(t, n);
+          function t(h) {
+            u(this, t);
+            var c = p(this, n.call(this, h));
+            return c.type = a.PSEUDO, c;
+          }
+          return t.prototype.toString = function() {
+            var h = this.length ? "(" + this.map(String).join(",") + ")" : "";
+            return [this.spaces.before, String(this.value), h, this.spaces.after].join("");
+          }, t;
+        })(r.default);
+        e.default = m, s.exports = e.default;
+      }), qs = S((e, s) => {
+        e.__esModule = !0;
+        var i = Pe(), r = o(i), a = G();
+        function o(n) {
+          return n && n.__esModule ? n : { default: n };
+        }
+        function u(n, t) {
+          if (!(n instanceof t)) throw new TypeError("Cannot call a class as a function");
+        }
+        function p(n, t) {
+          if (!n) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          return t && (typeof t == "object" || typeof t == "function") ? t : n;
+        }
+        function y(n, t) {
+          if (typeof t != "function" && t !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof t);
+          n.prototype = Object.create(t && t.prototype, { constructor: { value: n, enumerable: !1, writable: !0, configurable: !0 } }), t && (Object.setPrototypeOf ? Object.setPrototypeOf(n, t) : n.__proto__ = t);
+        }
+        var m = (function(n) {
+          y(t, n);
+          function t(h) {
+            u(this, t);
+            var c = p(this, n.call(this, h));
+            return c.type = a.ATTRIBUTE, c.raws = {}, c;
+          }
+          return t.prototype.toString = function() {
+            var h = [this.spaces.before, "[", this.ns, this.attribute];
+            return this.operator && h.push(this.operator), this.value && h.push(this.value), this.raws.insensitive ? h.push(this.raws.insensitive) : this.insensitive && h.push(" i"), h.push("]"), h.concat(this.spaces.after).join("");
+          }, t;
+        })(r.default);
+        e.default = m, s.exports = e.default;
+      }), Ds = S((e, s) => {
+        e.__esModule = !0;
+        var i = Pe(), r = o(i), a = G();
+        function o(n) {
+          return n && n.__esModule ? n : { default: n };
+        }
+        function u(n, t) {
+          if (!(n instanceof t)) throw new TypeError("Cannot call a class as a function");
+        }
+        function p(n, t) {
+          if (!n) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          return t && (typeof t == "object" || typeof t == "function") ? t : n;
+        }
+        function y(n, t) {
+          if (typeof t != "function" && t !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof t);
+          n.prototype = Object.create(t && t.prototype, { constructor: { value: n, enumerable: !1, writable: !0, configurable: !0 } }), t && (Object.setPrototypeOf ? Object.setPrototypeOf(n, t) : n.__proto__ = t);
+        }
+        var m = (function(n) {
+          y(t, n);
+          function t(h) {
+            u(this, t);
+            var c = p(this, n.call(this, h));
+            return c.type = a.UNIVERSAL, c.value = "*", c;
+          }
+          return t;
+        })(r.default);
+        e.default = m, s.exports = e.default;
+      }), Fs = S((e, s) => {
+        e.__esModule = !0;
+        var i = ye(), r = o(i), a = G();
+        function o(n) {
+          return n && n.__esModule ? n : { default: n };
+        }
+        function u(n, t) {
+          if (!(n instanceof t)) throw new TypeError("Cannot call a class as a function");
+        }
+        function p(n, t) {
+          if (!n) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          return t && (typeof t == "object" || typeof t == "function") ? t : n;
+        }
+        function y(n, t) {
+          if (typeof t != "function" && t !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof t);
+          n.prototype = Object.create(t && t.prototype, { constructor: { value: n, enumerable: !1, writable: !0, configurable: !0 } }), t && (Object.setPrototypeOf ? Object.setPrototypeOf(n, t) : n.__proto__ = t);
+        }
+        var m = (function(n) {
+          y(t, n);
+          function t(h) {
+            u(this, t);
+            var c = p(this, n.call(this, h));
+            return c.type = a.COMBINATOR, c;
+          }
+          return t;
+        })(r.default);
+        e.default = m, s.exports = e.default;
+      }), Us = S((e, s) => {
+        e.__esModule = !0;
+        var i = ye(), r = o(i), a = G();
+        function o(n) {
+          return n && n.__esModule ? n : { default: n };
+        }
+        function u(n, t) {
+          if (!(n instanceof t)) throw new TypeError("Cannot call a class as a function");
+        }
+        function p(n, t) {
+          if (!n) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          return t && (typeof t == "object" || typeof t == "function") ? t : n;
+        }
+        function y(n, t) {
+          if (typeof t != "function" && t !== null) throw new TypeError("Super expression must either be null or a function, not " + typeof t);
+          n.prototype = Object.create(t && t.prototype, { constructor: { value: n, enumerable: !1, writable: !0, configurable: !0 } }), t && (Object.setPrototypeOf ? Object.setPrototypeOf(n, t) : n.__proto__ = t);
+        }
+        var m = (function(n) {
+          y(t, n);
+          function t(h) {
+            u(this, t);
+            var c = p(this, n.call(this, h));
+            return c.type = a.NESTING, c.value = "&", c;
+          }
+          return t;
+        })(r.default);
+        e.default = m, s.exports = e.default;
+      }), Vs = S((e, s) => {
+        e.__esModule = !0, e.default = i;
+        function i(r) {
+          return r.sort(function(a, o) {
+            return a - o;
+          });
+        }
+        s.exports = e.default;
+      }), Gs = S((e, s) => {
+        e.__esModule = !0, e.default = P;
+        var i = 39, r = 34, a = 92, o = 47, u = 10, p = 32, y = 12, m = 9, n = 13, t = 43, h = 62, c = 126, d = 124, l = 44, w = 40, v = 41, f = 91, g = 93, T = 59, b = 42, x = 58, k = 38, O = 64, A = /[ \n\t\r\{\(\)'"\\;/]/g, E = /[ \n\t\r\(\)\*:;@!&'"\+\|~>,\[\]\\]|\/(?=\*)/g;
+        function P(W) {
+          for (var R = [], $ = W.css.valueOf(), M = void 0, I = void 0, U = void 0, Fe = void 0, xe = void 0, ke = void 0, Oe = void 0, Te = void 0, _e = void 0, B = void 0, Ue = void 0, Gt = $.length, j = -1, _ = 1, C = 0, L = function(z, q) {
+            if (W.safe) $ += q, I = $.length - 1;
+            else throw W.error("Unclosed " + z, _, C - j, C);
+          }; C < Gt; ) {
+            switch (M = $.charCodeAt(C), M === u && (j = C, _ += 1), M) {
+              case u:
+              case p:
+              case m:
+              case n:
+              case y:
+                I = C;
+                do
+                  I += 1, M = $.charCodeAt(I), M === u && (j = I, _ += 1);
+                while (M === p || M === u || M === m || M === n || M === y);
+                R.push(["space", $.slice(C, I), _, C - j, C]), C = I - 1;
+                break;
+              case t:
+              case h:
+              case c:
+              case d:
+                I = C;
+                do
+                  I += 1, M = $.charCodeAt(I);
+                while (M === t || M === h || M === c || M === d);
+                R.push(["combinator", $.slice(C, I), _, C - j, C]), C = I - 1;
+                break;
+              case b:
+                R.push(["*", "*", _, C - j, C]);
+                break;
+              case k:
+                R.push(["&", "&", _, C - j, C]);
+                break;
+              case l:
+                R.push([",", ",", _, C - j, C]);
+                break;
+              case f:
+                R.push(["[", "[", _, C - j, C]);
+                break;
+              case g:
+                R.push(["]", "]", _, C - j, C]);
+                break;
+              case x:
+                R.push([":", ":", _, C - j, C]);
+                break;
+              case T:
+                R.push([";", ";", _, C - j, C]);
+                break;
+              case w:
+                R.push(["(", "(", _, C - j, C]);
+                break;
+              case v:
+                R.push([")", ")", _, C - j, C]);
+                break;
+              case i:
+              case r:
+                U = M === i ? "'" : '"', I = C;
+                do
+                  for (B = !1, I = $.indexOf(U, I + 1), I === -1 && L("quote", U), Ue = I; $.charCodeAt(Ue - 1) === a; ) Ue -= 1, B = !B;
+                while (B);
+                R.push(["string", $.slice(C, I + 1), _, C - j, _, I - j, C]), C = I;
+                break;
+              case O:
+                A.lastIndex = C + 1, A.test($), A.lastIndex === 0 ? I = $.length - 1 : I = A.lastIndex - 2, R.push(["at-word", $.slice(C, I + 1), _, C - j, _, I - j, C]), C = I;
+                break;
+              case a:
+                for (I = C, Oe = !0; $.charCodeAt(I + 1) === a; ) I += 1, Oe = !Oe;
+                M = $.charCodeAt(I + 1), Oe && M !== o && M !== p && M !== u && M !== m && M !== n && M !== y && (I += 1), R.push(["word", $.slice(C, I + 1), _, C - j, _, I - j, C]), C = I;
+                break;
+              default:
+                M === o && $.charCodeAt(C + 1) === b ? (I = $.indexOf("*/", C + 2) + 1, I === 0 && L("comment", "*/"), ke = $.slice(C, I + 1), Fe = ke.split(`
+`), xe = Fe.length - 1, xe > 0 ? (Te = _ + xe, _e = I - Fe[xe].length) : (Te = _, _e = j), R.push(["comment", ke, _, C - j, Te, I - _e, C]), j = _e, _ = Te, C = I) : (E.lastIndex = C + 1, E.test($), E.lastIndex === 0 ? I = $.length - 1 : I = E.lastIndex - 2, R.push(["word", $.slice(C, I + 1), _, C - j, _, I - j, C]), C = I);
+                break;
+            }
+            C++;
+          }
+          return R;
+        }
+        s.exports = e.default;
+      }), Hs = S((e, s) => {
+        e.__esModule = !0;
+        var i = /* @__PURE__ */ (function() {
+          function j(_, C) {
+            for (var L = 0; L < C.length; L++) {
+              var z = C[L];
+              z.enumerable = z.enumerable || !1, z.configurable = !0, "value" in z && (z.writable = !0), Object.defineProperty(_, z.key, z);
+            }
+          }
+          return function(_, C, L) {
+            return C && j(_.prototype, C), L && j(_, L), _;
+          };
+        })(), r = or(), a = B(r), o = ir(), u = B(o), p = ar(), y = B(p), m = Ms(), n = B(m), t = $s(), h = B(t), c = Rs(), d = B(c), l = Ns(), w = B(l), v = Ls(), f = B(v), g = Ws(), T = B(g), b = zs(), x = B(b), k = Bs(), O = B(k), A = qs(), E = B(A), P = Ds(), W = B(P), R = Fs(), $ = B(R), M = Us(), I = B(M), U = Vs(), Fe = B(U), xe = Gs(), ke = B(xe), Oe = G(), Te = _e(Oe);
+        function _e(j) {
+          if (j && j.__esModule) return j;
+          var _ = {};
+          if (j != null) for (var C in j) Object.prototype.hasOwnProperty.call(j, C) && (_[C] = j[C]);
+          return _.default = j, _;
+        }
+        function B(j) {
+          return j && j.__esModule ? j : { default: j };
+        }
+        function Ue(j, _) {
+          if (!(j instanceof _)) throw new TypeError("Cannot call a class as a function");
+        }
+        var Gt = (function() {
+          function j(_) {
+            Ue(this, j), this.input = _, this.lossy = _.options.lossless === !1, this.position = 0, this.root = new n.default();
+            var C = new h.default();
+            return this.root.append(C), this.current = C, this.lossy ? this.tokens = (0, ke.default)({ safe: _.safe, css: _.css.trim() }) : this.tokens = (0, ke.default)(_), this.loop();
+          }
+          return j.prototype.attribute = function() {
+            var _ = "", C = void 0, L = this.currToken;
+            for (this.position++; this.position < this.tokens.length && this.currToken[0] !== "]"; ) _ += this.tokens[this.position][1], this.position++;
+            this.position === this.tokens.length && !~_.indexOf("]") && this.error("Expected a closing square bracket.");
+            var z = _.split(/((?:[*~^$|]?=))([^]*)/), q = z[0].split(/(\|)/g), se = { operator: z[1], value: z[2], source: { start: { line: L[2], column: L[3] }, end: { line: this.currToken[2], column: this.currToken[3] } }, sourceIndex: L[4] };
+            if (q.length > 1 ? (q[0] === "" && (q[0] = !0), se.attribute = this.parseValue(q[2]), se.namespace = this.parseNamespace(q[0])) : se.attribute = this.parseValue(z[0]), C = new E.default(se), z[2]) {
+              var ae = z[2].split(/(\s+i\s*?)$/), ue = ae[0].trim();
+              C.value = this.lossy ? ue : ae[0], ae[1] && (C.insensitive = !0, this.lossy || (C.raws.insensitive = ae[1])), C.quoted = ue[0] === "'" || ue[0] === '"', C.raws.unquoted = C.quoted ? ue.slice(1, -1) : ue;
+            }
+            this.newNode(C), this.position++;
+          }, j.prototype.combinator = function() {
+            if (this.currToken[1] === "|") return this.namespace();
+            for (var _ = new $.default({ value: "", source: { start: { line: this.currToken[2], column: this.currToken[3] }, end: { line: this.currToken[2], column: this.currToken[3] } }, sourceIndex: this.currToken[4] }); this.position < this.tokens.length && this.currToken && (this.currToken[0] === "space" || this.currToken[0] === "combinator"); ) this.nextToken && this.nextToken[0] === "combinator" ? (_.spaces.before = this.parseSpace(this.currToken[1]), _.source.start.line = this.nextToken[2], _.source.start.column = this.nextToken[3], _.source.end.column = this.nextToken[3], _.source.end.line = this.nextToken[2], _.sourceIndex = this.nextToken[4]) : this.prevToken && this.prevToken[0] === "combinator" ? _.spaces.after = this.parseSpace(this.currToken[1]) : this.currToken[0] === "combinator" ? _.value = this.currToken[1] : this.currToken[0] === "space" && (_.value = this.parseSpace(this.currToken[1], " ")), this.position++;
+            return this.newNode(_);
+          }, j.prototype.comma = function() {
+            if (this.position === this.tokens.length - 1) {
+              this.root.trailingComma = !0, this.position++;
+              return;
+            }
+            var _ = new h.default();
+            this.current.parent.append(_), this.current = _, this.position++;
+          }, j.prototype.comment = function() {
+            var _ = new w.default({ value: this.currToken[1], source: { start: { line: this.currToken[2], column: this.currToken[3] }, end: { line: this.currToken[4], column: this.currToken[5] } }, sourceIndex: this.currToken[6] });
+            this.newNode(_), this.position++;
+          }, j.prototype.error = function(_) {
+            throw new this.input.error(_);
+          }, j.prototype.missingBackslash = function() {
+            return this.error("Expected a backslash preceding the semicolon.");
+          }, j.prototype.missingParenthesis = function() {
+            return this.error("Expected opening parenthesis.");
+          }, j.prototype.missingSquareBracket = function() {
+            return this.error("Expected opening square bracket.");
+          }, j.prototype.namespace = function() {
+            var _ = this.prevToken && this.prevToken[1] || !0;
+            if (this.nextToken[0] === "word") return this.position++, this.word(_);
+            if (this.nextToken[0] === "*") return this.position++, this.universal(_);
+          }, j.prototype.nesting = function() {
+            this.newNode(new I.default({ value: this.currToken[1], source: { start: { line: this.currToken[2], column: this.currToken[3] }, end: { line: this.currToken[2], column: this.currToken[3] } }, sourceIndex: this.currToken[4] })), this.position++;
+          }, j.prototype.parentheses = function() {
+            var _ = this.current.last;
+            if (_ && _.type === Te.PSEUDO) {
+              var C = new h.default(), L = this.current;
+              _.append(C), this.current = C;
+              var z = 1;
+              for (this.position++; this.position < this.tokens.length && z; ) this.currToken[0] === "(" && z++, this.currToken[0] === ")" && z--, z ? this.parse() : (C.parent.source.end.line = this.currToken[2], C.parent.source.end.column = this.currToken[3], this.position++);
+              z && this.error("Expected closing parenthesis."), this.current = L;
+            } else {
+              var q = 1;
+              for (this.position++, _.value += "("; this.position < this.tokens.length && q; ) this.currToken[0] === "(" && q++, this.currToken[0] === ")" && q--, _.value += this.parseParenthesisToken(this.currToken), this.position++;
+              q && this.error("Expected closing parenthesis.");
+            }
+          }, j.prototype.pseudo = function() {
+            for (var _ = this, C = "", L = this.currToken; this.currToken && this.currToken[0] === ":"; ) C += this.currToken[1], this.position++;
+            if (!this.currToken) return this.error("Expected pseudo-class or pseudo-element");
+            if (this.currToken[0] === "word") {
+              var z = void 0;
+              this.splitWord(!1, function(q, se) {
+                C += q, z = new O.default({ value: C, source: { start: { line: L[2], column: L[3] }, end: { line: _.currToken[4], column: _.currToken[5] } }, sourceIndex: L[4] }), _.newNode(z), se > 1 && _.nextToken && _.nextToken[0] === "(" && _.error("Misplaced parenthesis.");
+              });
+            } else this.error('Unexpected "' + this.currToken[0] + '" found.');
+          }, j.prototype.space = function() {
+            var _ = this.currToken;
+            this.position === 0 || this.prevToken[0] === "," || this.prevToken[0] === "(" ? (this.spaces = this.parseSpace(_[1]), this.position++) : this.position === this.tokens.length - 1 || this.nextToken[0] === "," || this.nextToken[0] === ")" ? (this.current.last.spaces.after = this.parseSpace(_[1]), this.position++) : this.combinator();
+          }, j.prototype.string = function() {
+            var _ = this.currToken;
+            this.newNode(new x.default({ value: this.currToken[1], source: { start: { line: _[2], column: _[3] }, end: { line: _[4], column: _[5] } }, sourceIndex: _[6] })), this.position++;
+          }, j.prototype.universal = function(_) {
+            var C = this.nextToken;
+            if (C && C[1] === "|") return this.position++, this.namespace();
+            this.newNode(new W.default({ value: this.currToken[1], source: { start: { line: this.currToken[2], column: this.currToken[3] }, end: { line: this.currToken[2], column: this.currToken[3] } }, sourceIndex: this.currToken[4] }), _), this.position++;
+          }, j.prototype.splitWord = function(_, C) {
+            for (var L = this, z = this.nextToken, q = this.currToken[1]; z && z[0] === "word"; ) {
+              this.position++;
+              var se = this.currToken[1];
+              if (q += se, se.lastIndexOf("\\") === se.length - 1) {
+                var ae = this.nextToken;
+                ae && ae[0] === "space" && (q += this.parseSpace(ae[1], " "), this.position++);
+              }
+              z = this.nextToken;
+            }
+            var ue = (0, u.default)(q, "."), lt = (0, u.default)(q, "#"), ns = (0, u.default)(q, "#{");
+            ns.length && (lt = lt.filter(function(le) {
+              return !~ns.indexOf(le);
+            }));
+            var Ce = (0, Fe.default)((0, y.default)((0, a.default)([[0], ue, lt])));
+            Ce.forEach(function(le, Ve) {
+              var ct = Ce[Ve + 1] || q.length, pt = q.slice(le, ct);
+              if (Ve === 0 && C) return C.call(L, pt, Ce.length);
+              var ht = void 0;
+              ~ue.indexOf(le) ? ht = new d.default({ value: pt.slice(1), source: { start: { line: L.currToken[2], column: L.currToken[3] + le }, end: { line: L.currToken[4], column: L.currToken[3] + (ct - 1) } }, sourceIndex: L.currToken[6] + Ce[Ve] }) : ~lt.indexOf(le) ? ht = new f.default({ value: pt.slice(1), source: { start: { line: L.currToken[2], column: L.currToken[3] + le }, end: { line: L.currToken[4], column: L.currToken[3] + (ct - 1) } }, sourceIndex: L.currToken[6] + Ce[Ve] }) : ht = new T.default({ value: pt, source: { start: { line: L.currToken[2], column: L.currToken[3] + le }, end: { line: L.currToken[4], column: L.currToken[3] + (ct - 1) } }, sourceIndex: L.currToken[6] + Ce[Ve] }), L.newNode(ht, _);
+            }), this.position++;
+          }, j.prototype.word = function(_) {
+            var C = this.nextToken;
+            return C && C[1] === "|" ? (this.position++, this.namespace()) : this.splitWord(_);
+          }, j.prototype.loop = function() {
+            for (; this.position < this.tokens.length; ) this.parse(!0);
+            return this.root;
+          }, j.prototype.parse = function(_) {
+            switch (this.currToken[0]) {
+              case "space":
+                this.space();
+                break;
+              case "comment":
+                this.comment();
+                break;
+              case "(":
+                this.parentheses();
+                break;
+              case ")":
+                _ && this.missingParenthesis();
+                break;
+              case "[":
+                this.attribute();
+                break;
+              case "]":
+                this.missingSquareBracket();
+                break;
+              case "at-word":
+              case "word":
+                this.word();
+                break;
+              case ":":
+                this.pseudo();
+                break;
+              case ";":
+                this.missingBackslash();
+                break;
+              case ",":
+                this.comma();
+                break;
+              case "*":
+                this.universal();
+                break;
+              case "&":
+                this.nesting();
+                break;
+              case "combinator":
+                this.combinator();
+                break;
+              case "string":
+                this.string();
+                break;
+            }
+          }, j.prototype.parseNamespace = function(_) {
+            if (this.lossy && typeof _ == "string") {
+              var C = _.trim();
+              return C.length ? C : !0;
+            }
+            return _;
+          }, j.prototype.parseSpace = function(_, C) {
+            return this.lossy ? C || "" : _;
+          }, j.prototype.parseValue = function(_) {
+            return this.lossy && _ && typeof _ == "string" ? _.trim() : _;
+          }, j.prototype.parseParenthesisToken = function(_) {
+            return this.lossy ? _[0] === "space" ? this.parseSpace(_[1], " ") : this.parseValue(_[1]) : _[1];
+          }, j.prototype.newNode = function(_, C) {
+            return C && (_.namespace = this.parseNamespace(C)), this.spaces && (_.spaces.before = this.spaces, this.spaces = ""), this.current.append(_);
+          }, i(j, [{ key: "currToken", get: function() {
+            return this.tokens[this.position];
+          } }, { key: "nextToken", get: function() {
+            return this.tokens[this.position + 1];
+          } }, { key: "prevToken", get: function() {
+            return this.tokens[this.position - 1];
+          } }]), j;
+        })();
+        e.default = Gt, s.exports = e.default;
+      }), Js = S((e, s) => {
+        e.__esModule = !0;
+        var i = /* @__PURE__ */ (function() {
+          function y(m, n) {
+            for (var t = 0; t < n.length; t++) {
+              var h = n[t];
+              h.enumerable = h.enumerable || !1, h.configurable = !0, "value" in h && (h.writable = !0), Object.defineProperty(m, h.key, h);
+            }
+          }
+          return function(m, n, t) {
+            return n && y(m.prototype, n), t && y(m, t), m;
+          };
+        })(), r = Hs(), a = o(r);
+        function o(y) {
+          return y && y.__esModule ? y : { default: y };
+        }
+        function u(y, m) {
+          if (!(y instanceof m)) throw new TypeError("Cannot call a class as a function");
+        }
+        var p = (function() {
+          function y(m) {
+            return u(this, y), this.func = m || function() {
+            }, this;
+          }
+          return y.prototype.process = function(m) {
+            var n = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, t = new a.default({ css: m, error: function(h) {
+              throw new Error(h);
+            }, options: n });
+            return this.res = t, this.func(t), this;
+          }, i(y, [{ key: "result", get: function() {
+            return String(this.res);
+          } }]), y;
+        })();
+        e.default = p, s.exports = e.default;
+      }), te = S((e, s) => {
+        var i = function(r, a) {
+          let o = new r.constructor();
+          for (let u in r) {
+            if (!r.hasOwnProperty(u)) continue;
+            let p = r[u], y = typeof p;
+            u === "parent" && y === "object" ? a && (o[u] = a) : u === "source" ? o[u] = p : p instanceof Array ? o[u] = p.map((m) => i(m, o)) : u !== "before" && u !== "after" && u !== "between" && u !== "semicolon" && (y === "object" && p !== null && (p = i(p)), o[u] = p);
+          }
+          return o;
+        };
+        s.exports = class {
+          constructor(r) {
+            r = r || {}, this.raws = { before: "", after: "" };
+            for (let a in r) this[a] = r[a];
+          }
+          remove() {
+            return this.parent && this.parent.removeChild(this), this.parent = void 0, this;
+          }
+          toString() {
+            return [this.raws.before, String(this.value), this.raws.after].join("");
+          }
+          clone(r) {
+            r = r || {};
+            let a = i(this);
+            for (let o in r) a[o] = r[o];
+            return a;
+          }
+          cloneBefore(r) {
+            r = r || {};
+            let a = this.clone(r);
+            return this.parent.insertBefore(this, a), a;
+          }
+          cloneAfter(r) {
+            r = r || {};
+            let a = this.clone(r);
+            return this.parent.insertAfter(this, a), a;
+          }
+          replaceWith() {
+            let r = Array.prototype.slice.call(arguments);
+            if (this.parent) {
+              for (let a of r) this.parent.insertBefore(this, a);
+              this.remove();
+            }
+            return this;
+          }
+          moveTo(r) {
+            return this.cleanRaws(this.root() === r.root()), this.remove(), r.append(this), this;
+          }
+          moveBefore(r) {
+            return this.cleanRaws(this.root() === r.root()), this.remove(), r.parent.insertBefore(r, this), this;
+          }
+          moveAfter(r) {
+            return this.cleanRaws(this.root() === r.root()), this.remove(), r.parent.insertAfter(r, this), this;
+          }
+          next() {
+            let r = this.parent.index(this);
+            return this.parent.nodes[r + 1];
+          }
+          prev() {
+            let r = this.parent.index(this);
+            return this.parent.nodes[r - 1];
+          }
+          toJSON() {
+            let r = {};
+            for (let a in this) {
+              if (!this.hasOwnProperty(a) || a === "parent") continue;
+              let o = this[a];
+              o instanceof Array ? r[a] = o.map((u) => typeof u == "object" && u.toJSON ? u.toJSON() : u) : typeof o == "object" && o.toJSON ? r[a] = o.toJSON() : r[a] = o;
+            }
+            return r;
+          }
+          root() {
+            let r = this;
+            for (; r.parent; ) r = r.parent;
+            return r;
+          }
+          cleanRaws(r) {
+            delete this.raws.before, delete this.raws.after, r || delete this.raws.between;
+          }
+          positionInside(r) {
+            let a = this.toString(), o = this.source.start.column, u = this.source.start.line;
+            for (let p = 0; p < r; p++) a[p] === `
+` ? (o = 1, u += 1) : o += 1;
+            return { line: u, column: o };
+          }
+          positionBy(r) {
+            let a = this.source.start;
+            if (Object(r).index) a = this.positionInside(r.index);
+            else if (Object(r).word) {
+              let o = this.toString().indexOf(r.word);
+              o !== -1 && (a = this.positionInside(o));
+            }
+            return a;
+          }
+        };
+      }), Q = S((e, s) => {
+        var i = te(), r = class extends i {
+          constructor(a) {
+            super(a), this.nodes || (this.nodes = []);
+          }
+          push(a) {
+            return a.parent = this, this.nodes.push(a), this;
+          }
+          each(a) {
+            this.lastEach || (this.lastEach = 0), this.indexes || (this.indexes = {}), this.lastEach += 1;
+            let o = this.lastEach, u, p;
+            if (this.indexes[o] = 0, !!this.nodes) {
+              for (; this.indexes[o] < this.nodes.length && (u = this.indexes[o], p = a(this.nodes[u], u), p !== !1); ) this.indexes[o] += 1;
+              return delete this.indexes[o], p;
+            }
+          }
+          walk(a) {
+            return this.each((o, u) => {
+              let p = a(o, u);
+              return p !== !1 && o.walk && (p = o.walk(a)), p;
+            });
+          }
+          walkType(a, o) {
+            if (!a || !o) throw new Error("Parameters {type} and {callback} are required.");
+            let u = typeof a == "function";
+            return this.walk((p, y) => {
+              if (u && p instanceof a || !u && p.type === a) return o.call(this, p, y);
+            });
+          }
+          append(a) {
+            return a.parent = this, this.nodes.push(a), this;
+          }
+          prepend(a) {
+            return a.parent = this, this.nodes.unshift(a), this;
+          }
+          cleanRaws(a) {
+            if (super.cleanRaws(a), this.nodes) for (let o of this.nodes) o.cleanRaws(a);
+          }
+          insertAfter(a, o) {
+            let u = this.index(a), p;
+            this.nodes.splice(u + 1, 0, o);
+            for (let y in this.indexes) p = this.indexes[y], u <= p && (this.indexes[y] = p + this.nodes.length);
+            return this;
+          }
+          insertBefore(a, o) {
+            let u = this.index(a), p;
+            this.nodes.splice(u, 0, o);
+            for (let y in this.indexes) p = this.indexes[y], u <= p && (this.indexes[y] = p + this.nodes.length);
+            return this;
+          }
+          removeChild(a) {
+            a = this.index(a), this.nodes[a].parent = void 0, this.nodes.splice(a, 1);
+            let o;
+            for (let u in this.indexes) o = this.indexes[u], o >= a && (this.indexes[u] = o - 1);
+            return this;
+          }
+          removeAll() {
+            for (let a of this.nodes) a.parent = void 0;
+            return this.nodes = [], this;
+          }
+          every(a) {
+            return this.nodes.every(a);
+          }
+          some(a) {
+            return this.nodes.some(a);
+          }
+          index(a) {
+            return typeof a == "number" ? a : this.nodes.indexOf(a);
+          }
+          get first() {
+            if (this.nodes) return this.nodes[0];
+          }
+          get last() {
+            if (this.nodes) return this.nodes[this.nodes.length - 1];
+          }
+          toString() {
+            let a = this.nodes.map(String).join("");
+            return this.value && (a = this.value + a), this.raws.before && (a = this.raws.before + a), this.raws.after && (a += this.raws.after), a;
+          }
+        };
+        r.registerWalker = (a) => {
+          let o = "walk" + a.name;
+          o.lastIndexOf("s") !== o.length - 1 && (o += "s"), !r.prototype[o] && (r.prototype[o] = function(u) {
+            return this.walkType(a, u);
+          });
+        }, s.exports = r;
+      }), Qs = S((e, s) => {
+        var i = Q();
+        s.exports = class extends i {
+          constructor(r) {
+            super(r), this.type = "root";
+          }
+        };
+      }), Zs = S((e, s) => {
+        var i = Q();
+        s.exports = class extends i {
+          constructor(r) {
+            super(r), this.type = "value", this.unbalanced = 0;
+          }
+        };
+      }), Ys = S((e, s) => {
+        var i = Q(), r = class extends i {
+          constructor(a) {
+            super(a), this.type = "atword";
+          }
+          toString() {
+            return this.quoted && this.raws.quote, [this.raws.before, "@", String.prototype.toString.call(this.value), this.raws.after].join("");
+          }
+        };
+        i.registerWalker(r), s.exports = r;
+      }), Ks = S((e, s) => {
+        var i = Q(), r = te(), a = class extends r {
+          constructor(o) {
+            super(o), this.type = "colon";
+          }
+        };
+        i.registerWalker(a), s.exports = a;
+      }), Xs = S((e, s) => {
+        var i = Q(), r = te(), a = class extends r {
+          constructor(o) {
+            super(o), this.type = "comma";
+          }
+        };
+        i.registerWalker(a), s.exports = a;
+      }), en = S((e, s) => {
+        var i = Q(), r = te(), a = class extends r {
+          constructor(o) {
+            super(o), this.type = "comment", this.inline = Object(o).inline || !1;
+          }
+          toString() {
+            return [this.raws.before, this.inline ? "//" : "/*", String(this.value), this.inline ? "" : "*/", this.raws.after].join("");
+          }
+        };
+        i.registerWalker(a), s.exports = a;
+      }), tn = S((e, s) => {
+        var i = Q(), r = class extends i {
+          constructor(a) {
+            super(a), this.type = "func", this.unbalanced = -1;
+          }
+        };
+        i.registerWalker(r), s.exports = r;
+      }), rn = S((e, s) => {
+        var i = Q(), r = te(), a = class extends r {
+          constructor(o) {
+            super(o), this.type = "number", this.unit = Object(o).unit || "";
+          }
+          toString() {
+            return [this.raws.before, String(this.value), this.unit, this.raws.after].join("");
+          }
+        };
+        i.registerWalker(a), s.exports = a;
+      }), sn = S((e, s) => {
+        var i = Q(), r = te(), a = class extends r {
+          constructor(o) {
+            super(o), this.type = "operator";
+          }
+        };
+        i.registerWalker(a), s.exports = a;
+      }), nn = S((e, s) => {
+        var i = Q(), r = te(), a = class extends r {
+          constructor(o) {
+            super(o), this.type = "paren", this.parenType = "";
+          }
+        };
+        i.registerWalker(a), s.exports = a;
+      }), on = S((e, s) => {
+        var i = Q(), r = te(), a = class extends r {
+          constructor(o) {
+            super(o), this.type = "string";
+          }
+          toString() {
+            let o = this.quoted ? this.raws.quote : "";
+            return [this.raws.before, o, this.value + "", o, this.raws.after].join("");
+          }
+        };
+        i.registerWalker(a), s.exports = a;
+      }), an = S((e, s) => {
+        var i = Q(), r = te(), a = class extends r {
+          constructor(o) {
+            super(o), this.type = "word";
+          }
+        };
+        i.registerWalker(a), s.exports = a;
+      }), un = S((e, s) => {
+        var i = Q(), r = te(), a = class extends r {
+          constructor(o) {
+            super(o), this.type = "unicode-range";
+          }
+        };
+        i.registerWalker(a), s.exports = a;
+      }), ln = S((e, s) => {
+        var i = class extends Error {
+          constructor(r) {
+            super(r), this.name = this.constructor.name, this.message = r || "An error ocurred while tokzenizing.", typeof Error.captureStackTrace == "function" ? Error.captureStackTrace(this, this.constructor) : this.stack = new Error(r).stack;
+          }
+        };
+        s.exports = i;
+      }), cn = S((e, s) => {
+        var i = /[ \n\t\r\{\(\)'"\\;,/]/g, r = /[ \n\t\r\(\)\{\}\*:;@!&'"\+\|~>,\[\]\\]|\/(?=\*)/g, a = /[ \n\t\r\(\)\{\}\*:;@!&'"\-\+\|~>,\[\]\\]|\//g, o = /^[a-z0-9]/i, u = /^[a-f0-9?\-]/i, p = ln();
+        s.exports = function(y, m) {
+          m = m || {};
+          let n = [], t = y.valueOf(), h = t.length, c = -1, d = 1, l = 0, w = 0, v = null, f, g, T, b, x, k, O, A, E, P, W;
+          function R($) {
+            let M = `Unclosed ${$} at line: ${d}, column: ${l - c}, token: ${l}`;
+            throw new p(M);
+          }
+          for (; l < h; ) {
+            switch (f = t.charCodeAt(l), f === 10 && (c = l, d += 1), f) {
+              case 10:
+              case 32:
+              case 9:
+              case 13:
+              case 12:
+                g = l;
+                do
+                  g += 1, f = t.charCodeAt(g), f === 10 && (c = g, d += 1);
+                while (f === 32 || f === 10 || f === 9 || f === 13 || f === 12);
+                n.push(["space", t.slice(l, g), d, l - c, d, g - c, l]), l = g - 1;
+                break;
+              case 58:
+                g = l + 1, n.push(["colon", t.slice(l, g), d, l - c, d, g - c, l]), l = g - 1;
+                break;
+              case 44:
+                g = l + 1, n.push(["comma", t.slice(l, g), d, l - c, d, g - c, l]), l = g - 1;
+                break;
+              case 123:
+                n.push(["{", "{", d, l - c, d, g - c, l]);
+                break;
+              case 125:
+                n.push(["}", "}", d, l - c, d, g - c, l]);
+                break;
+              case 40:
+                w++, v = !v && w === 1 && n.length > 0 && n[n.length - 1][0] === "word" && n[n.length - 1][1] === "url", n.push(["(", "(", d, l - c, d, g - c, l]);
+                break;
+              case 41:
+                w--, v = v && w > 0, n.push([")", ")", d, l - c, d, g - c, l]);
+                break;
+              case 39:
+              case 34:
+                T = f === 39 ? "'" : '"', g = l;
+                do
+                  for (E = !1, g = t.indexOf(T, g + 1), g === -1 && R("quote"), P = g; t.charCodeAt(P - 1) === 92; ) P -= 1, E = !E;
+                while (E);
+                n.push(["string", t.slice(l, g + 1), d, l - c, d, g - c, l]), l = g;
+                break;
+              case 64:
+                i.lastIndex = l + 1, i.test(t), i.lastIndex === 0 ? g = t.length - 1 : g = i.lastIndex - 2, n.push(["atword", t.slice(l, g + 1), d, l - c, d, g - c, l]), l = g;
+                break;
+              case 92:
+                g = l, f = t.charCodeAt(g + 1), n.push(["word", t.slice(l, g + 1), d, l - c, d, g - c, l]), l = g;
+                break;
+              case 43:
+              case 45:
+              case 42:
+                if (g = l + 1, W = t.slice(l + 1, g + 1), t.slice(l - 1, l), f === 45 && W.charCodeAt(0) === 45) {
+                  g++, n.push(["word", t.slice(l, g), d, l - c, d, g - c, l]), l = g - 1;
+                  break;
+                }
+                n.push(["operator", t.slice(l, g), d, l - c, d, g - c, l]), l = g - 1;
+                break;
+              default:
+                if (f === 47 && (t.charCodeAt(l + 1) === 42 || m.loose && !v && t.charCodeAt(l + 1) === 47)) {
+                  if (t.charCodeAt(l + 1) === 42) g = t.indexOf("*/", l + 2) + 1, g === 0 && R("comment");
+                  else {
+                    let $ = t.indexOf(`
+`, l + 2);
+                    g = $ !== -1 ? $ - 1 : h;
+                  }
+                  k = t.slice(l, g + 1), b = k.split(`
+`), x = b.length - 1, x > 0 ? (O = d + x, A = g - b[x].length) : (O = d, A = c), n.push(["comment", k, d, l - c, O, g - A, l]), c = A, d = O, l = g;
+                } else if (f === 35 && !o.test(t.slice(l + 1, l + 2))) g = l + 1, n.push(["#", t.slice(l, g), d, l - c, d, g - c, l]), l = g - 1;
+                else if ((f === 117 || f === 85) && t.charCodeAt(l + 1) === 43) {
+                  g = l + 2;
+                  do
+                    g += 1, f = t.charCodeAt(g);
+                  while (g < h && u.test(t.slice(g, g + 1)));
+                  n.push(["unicoderange", t.slice(l, g), d, l - c, d, g - c, l]), l = g - 1;
+                } else if (f === 47) g = l + 1, n.push(["operator", t.slice(l, g), d, l - c, d, g - c, l]), l = g - 1;
+                else {
+                  let $ = r;
+                  if (f >= 48 && f <= 57 && ($ = a), $.lastIndex = l + 1, $.test(t), $.lastIndex === 0 ? g = t.length - 1 : g = $.lastIndex - 2, $ === a || f === 46) {
+                    let M = t.charCodeAt(g), I = t.charCodeAt(g + 1), U = t.charCodeAt(g + 2);
+                    (M === 101 || M === 69) && (I === 45 || I === 43) && U >= 48 && U <= 57 && (a.lastIndex = g + 2, a.test(t), a.lastIndex === 0 ? g = t.length - 1 : g = a.lastIndex - 2);
+                  }
+                  n.push(["word", t.slice(l, g + 1), d, l - c, d, g - c, l]), l = g;
+                }
+                break;
+            }
+            l++;
+          }
+          return n;
+        };
+      }), pn = S((e, s) => {
+        var i = class extends Error {
+          constructor(r) {
+            super(r), this.name = this.constructor.name, this.message = r || "An error ocurred while parsing.", typeof Error.captureStackTrace == "function" ? Error.captureStackTrace(this, this.constructor) : this.stack = new Error(r).stack;
+          }
+        };
+        s.exports = i;
+      }), hn = S((e, s) => {
+        var i = Qs(), r = Zs(), a = Ys(), o = Ks(), u = Xs(), p = en(), y = tn(), m = rn(), n = sn(), t = nn(), h = on(), c = an(), d = un(), l = cn(), w = or(), v = ir(), f = ar(), g = pn();
+        function T(b) {
+          return b.sort((x, k) => x - k);
+        }
+        s.exports = class {
+          constructor(b, x) {
+            let k = { loose: !1 };
+            this.cache = [], this.input = b, this.options = Object.assign({}, k, x), this.position = 0, this.unbalanced = 0, this.root = new i();
+            let O = new r();
+            this.root.append(O), this.current = O, this.tokens = l(b, this.options);
+          }
+          parse() {
+            return this.loop();
+          }
+          colon() {
+            let b = this.currToken;
+            this.newNode(new o({ value: b[1], source: { start: { line: b[2], column: b[3] }, end: { line: b[4], column: b[5] } }, sourceIndex: b[6] })), this.position++;
+          }
+          comma() {
+            let b = this.currToken;
+            this.newNode(new u({ value: b[1], source: { start: { line: b[2], column: b[3] }, end: { line: b[4], column: b[5] } }, sourceIndex: b[6] })), this.position++;
+          }
+          comment() {
+            let b = !1, x = this.currToken[1].replace(/\/\*|\*\//g, ""), k;
+            this.options.loose && x.startsWith("//") && (x = x.substring(2), b = !0), k = new p({ value: x, inline: b, source: { start: { line: this.currToken[2], column: this.currToken[3] }, end: { line: this.currToken[4], column: this.currToken[5] } }, sourceIndex: this.currToken[6] }), this.newNode(k), this.position++;
+          }
+          error(b, x) {
+            throw new g(b + ` at line: ${x[2]}, column ${x[3]}`);
+          }
+          loop() {
+            for (; this.position < this.tokens.length; ) this.parseTokens();
+            return !this.current.last && this.spaces ? this.current.raws.before += this.spaces : this.spaces && (this.current.last.raws.after += this.spaces), this.spaces = "", this.root;
+          }
+          operator() {
+            let b = this.currToken[1], x;
+            if (b === "+" || b === "-") {
+              if (this.options.loose || this.position > 0 && (this.current.type === "func" && this.current.value === "calc" ? this.prevToken[0] !== "space" && this.prevToken[0] !== "(" ? this.error("Syntax Error", this.currToken) : this.nextToken[0] !== "space" && this.nextToken[0] !== "word" ? this.error("Syntax Error", this.currToken) : this.nextToken[0] === "word" && this.current.last.type !== "operator" && this.current.last.value !== "(" && this.error("Syntax Error", this.currToken) : (this.nextToken[0] === "space" || this.nextToken[0] === "operator" || this.prevToken[0] === "operator") && this.error("Syntax Error", this.currToken)), this.options.loose) {
+                if ((!this.current.nodes.length || this.current.last && this.current.last.type === "operator") && this.nextToken[0] === "word") return this.word();
+              } else if (this.nextToken[0] === "word") return this.word();
+            }
+            return x = new n({ value: this.currToken[1], source: { start: { line: this.currToken[2], column: this.currToken[3] }, end: { line: this.currToken[2], column: this.currToken[3] } }, sourceIndex: this.currToken[4] }), this.position++, this.newNode(x);
+          }
+          parseTokens() {
+            switch (this.currToken[0]) {
+              case "space":
+                this.space();
+                break;
+              case "colon":
+                this.colon();
+                break;
+              case "comma":
+                this.comma();
+                break;
+              case "comment":
+                this.comment();
+                break;
+              case "(":
+                this.parenOpen();
+                break;
+              case ")":
+                this.parenClose();
+                break;
+              case "atword":
+              case "word":
+                this.word();
+                break;
+              case "operator":
+                this.operator();
+                break;
+              case "string":
+                this.string();
+                break;
+              case "unicoderange":
+                this.unicodeRange();
+                break;
+              default:
+                this.word();
+                break;
+            }
+          }
+          parenOpen() {
+            let b = 1, x = this.position + 1, k = this.currToken, O;
+            for (; x < this.tokens.length && b; ) {
+              let A = this.tokens[x];
+              A[0] === "(" && b++, A[0] === ")" && b--, x++;
+            }
+            if (b && this.error("Expected closing parenthesis", k), O = this.current.last, O && O.type === "func" && O.unbalanced < 0 && (O.unbalanced = 0, this.current = O), this.current.unbalanced++, this.newNode(new t({ value: k[1], source: { start: { line: k[2], column: k[3] }, end: { line: k[4], column: k[5] } }, sourceIndex: k[6] })), this.position++, this.current.type === "func" && this.current.unbalanced && this.current.value === "url" && this.currToken[0] !== "string" && this.currToken[0] !== ")" && !this.options.loose) {
+              let A = this.nextToken, E = this.currToken[1], P = { line: this.currToken[2], column: this.currToken[3] };
+              for (; A && A[0] !== ")" && this.current.unbalanced; ) this.position++, E += this.currToken[1], A = this.nextToken;
+              this.position !== this.tokens.length - 1 && (this.position++, this.newNode(new c({ value: E, source: { start: P, end: { line: this.currToken[4], column: this.currToken[5] } }, sourceIndex: this.currToken[6] })));
+            }
+          }
+          parenClose() {
+            let b = this.currToken;
+            this.newNode(new t({ value: b[1], source: { start: { line: b[2], column: b[3] }, end: { line: b[4], column: b[5] } }, sourceIndex: b[6] })), this.position++, !(this.position >= this.tokens.length - 1 && !this.current.unbalanced) && (this.current.unbalanced--, this.current.unbalanced < 0 && this.error("Expected opening parenthesis", b), !this.current.unbalanced && this.cache.length && (this.current = this.cache.pop()));
+          }
+          space() {
+            let b = this.currToken;
+            this.position === this.tokens.length - 1 || this.nextToken[0] === "," || this.nextToken[0] === ")" ? (this.current.last.raws.after += b[1], this.position++) : (this.spaces = b[1], this.position++);
+          }
+          unicodeRange() {
+            let b = this.currToken;
+            this.newNode(new d({ value: b[1], source: { start: { line: b[2], column: b[3] }, end: { line: b[4], column: b[5] } }, sourceIndex: b[6] })), this.position++;
+          }
+          splitWord() {
+            let b = this.nextToken, x = this.currToken[1], k = /^[\+\-]?((\d+(\.\d*)?)|(\.\d+))([eE][\+\-]?\d+)?/, O = /^(?!\#([a-z0-9]+))[\#\{\}]/gi, A, E;
+            if (!O.test(x)) for (; b && b[0] === "word"; ) {
+              this.position++;
+              let P = this.currToken[1];
+              x += P, b = this.nextToken;
+            }
+            A = v(x, "@"), E = T(f(w([[0], A]))), E.forEach((P, W) => {
+              let R = E[W + 1] || x.length, $ = x.slice(P, R), M;
+              if (~A.indexOf(P)) M = new a({ value: $.slice(1), source: { start: { line: this.currToken[2], column: this.currToken[3] + P }, end: { line: this.currToken[4], column: this.currToken[3] + (R - 1) } }, sourceIndex: this.currToken[6] + E[W] });
+              else if (k.test(this.currToken[1])) {
+                let I = $.replace(k, "");
+                M = new m({ value: $.replace(I, ""), source: { start: { line: this.currToken[2], column: this.currToken[3] + P }, end: { line: this.currToken[4], column: this.currToken[3] + (R - 1) } }, sourceIndex: this.currToken[6] + E[W], unit: I });
+              } else M = new (b && b[0] === "(" ? y : c)({ value: $, source: { start: { line: this.currToken[2], column: this.currToken[3] + P }, end: { line: this.currToken[4], column: this.currToken[3] + (R - 1) } }, sourceIndex: this.currToken[6] + E[W] }), M.type === "word" ? (M.isHex = /^#(.+)/.test($), M.isColor = /^#([0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test($)) : this.cache.push(this.current);
+              this.newNode(M);
+            }), this.position++;
+          }
+          string() {
+            let b = this.currToken, x = this.currToken[1], k = /^(\"|\')/, O = k.test(x), A = "", E;
+            O && (A = x.match(k)[0], x = x.slice(1, x.length - 1)), E = new h({ value: x, source: { start: { line: b[2], column: b[3] }, end: { line: b[4], column: b[5] } }, sourceIndex: b[6], quoted: O }), E.raws.quote = A, this.newNode(E), this.position++;
+          }
+          word() {
+            return this.splitWord();
+          }
+          newNode(b) {
+            return this.spaces && (b.raws.before += this.spaces, this.spaces = ""), this.current.append(b);
+          }
+          get currToken() {
+            return this.tokens[this.position];
+          }
+          get nextToken() {
+            return this.tokens[this.position + 1];
+          }
+          get prevToken() {
+            return this.tokens[this.position - 1];
+          }
+        };
+      }), ur = {};
+      Jt(ur, { languages: () => Oi, options: () => Ci, parsers: () => Qr, printers: () => aa });
+      var lr = (e, s) => (i, r, ...a) => i | 1 && r == null ? void 0 : (s.call(r) ?? r[e]).apply(r, a), fn = String.prototype.replaceAll ?? function(e, s) {
+        return e.global ? this.replace(e, s) : this.split(e).join(s);
+      }, dn = lr("replaceAll", function() {
+        if (typeof this == "string") return fn;
+      }), D = dn;
+      function mn(e) {
+        return this[e < 0 ? this.length + e : e];
+      }
+      var yn = lr("at", function() {
+        if (Array.isArray(this) || typeof this == "string") return mn;
+      }), he = yn, vn = () => {
+      }, gn = vn, cr = "string", pr = "array", hr = "cursor", Ze = "indent", _t = "align", fr = "trim", Ye = "group", Ke = "fill", Xe = "if-break", dr = "indent-if-break", Ct = "line-suffix", mr = "line-suffix-boundary", ve = "line", yr = "label", St = "break-parent", vr = /* @__PURE__ */ new Set([hr, Ze, _t, fr, Ye, Ke, Xe, dr, Ct, mr, ve, yr, St]);
+      function wn(e) {
+        if (typeof e == "string") return cr;
+        if (Array.isArray(e)) return pr;
+        if (!e) return;
+        let { type: s } = e;
+        if (vr.has(s)) return s;
+      }
+      var Me = wn, bn = (e) => new Intl.ListFormat("en-US", { type: "disjunction" }).format(e);
+      function xn(e) {
+        let s = e === null ? "null" : typeof e;
+        if (s !== "string" && s !== "object") return `Unexpected doc '${s}', 
+Expected it to be 'string' or 'object'.`;
+        if (Me(e)) throw new Error("doc is valid.");
+        let i = Object.prototype.toString.call(e);
+        if (i !== "[object Object]") return `Unexpected doc '${i}'.`;
+        let r = bn([...vr].map((a) => `'${a}'`));
+        return `Unexpected doc.type '${e.type}'.
+Expected it to be ${r}.`;
+      }
+      var kn = class extends Error {
+        name = "InvalidDocError";
+        constructor(e) {
+          super(xn(e)), this.doc = e;
+        }
+      }, On = kn;
+      function Tn(e, s) {
+        if (typeof e == "string") return s(e);
+        let i = /* @__PURE__ */ new Map();
+        return r(e);
+        function r(o) {
+          if (i.has(o)) return i.get(o);
+          let u = a(o);
+          return i.set(o, u), u;
+        }
+        function a(o) {
+          switch (Me(o)) {
+            case pr:
+              return s(o.map(r));
+            case Ke:
+              return s({ ...o, parts: o.parts.map(r) });
+            case Xe:
+              return s({ ...o, breakContents: r(o.breakContents), flatContents: r(o.flatContents) });
+            case Ye: {
+              let { expandedStates: u, contents: p } = o;
+              return u ? (u = u.map(r), p = u[0]) : p = r(p), s({ ...o, contents: p, expandedStates: u });
+            }
+            case _t:
+            case Ze:
+            case dr:
+            case yr:
+            case Ct:
+              return s({ ...o, contents: r(o.contents) });
+            case cr:
+            case hr:
+            case fr:
+            case mr:
+            case ve:
+            case St:
+              return s(o);
+            default:
+              throw new On(o);
+          }
+        }
+      }
+      function _n(e) {
+        return e.type === ve && !e.hard ? e.soft ? "" : " " : e.type === Xe ? e.flatContents : e;
+      }
+      function Cn(e) {
+        return Tn(e, _n);
+      }
+      var Sn = gn;
+      function Z(e) {
+        return { type: Ze, contents: e };
+      }
+      function An(e, s) {
+        return { type: _t, contents: s, n: e };
+      }
+      function $e(e) {
+        return An(-1, e);
+      }
+      var At = { type: St };
+      function et(e) {
+        return { type: Ke, parts: e };
+      }
+      function K(e, s = {}) {
+        return Sn(s.expandedStates), { type: Ye, id: s.id, contents: e, break: !!s.shouldBreak, expandedStates: s.expandedStates };
+      }
+      function gr(e, s = "", i = {}) {
+        return { type: Xe, breakContents: e, flatContents: s, groupId: i.groupId };
+      }
+      function ne(e, s) {
+        let i = [];
+        for (let r = 0; r < s.length; r++) r !== 0 && i.push(e), i.push(s[r]);
+        return i;
+      }
+      var V = { type: ve }, X = { type: ve, soft: !0 }, En = { type: ve, hard: !0 }, F = [En, At];
+      function jn(e) {
+        return { type: Ct, contents: e };
+      }
+      function In(e) {
+        return Array.isArray(e) && e.length > 0;
+      }
+      var tt = In, wr = Object.freeze({ character: "'", codePoint: 39 }), br = Object.freeze({ character: '"', codePoint: 34 }), Pn = Object.freeze({ preferred: wr, alternate: br }), Mn = Object.freeze({ preferred: br, alternate: wr });
+      function $n(e, s) {
+        let { preferred: i, alternate: r } = s === !0 || s === "'" ? Pn : Mn, { length: a } = e, o = 0, u = 0;
+        for (let p = 0; p < a; p++) {
+          let y = e.charCodeAt(p);
+          y === i.codePoint ? o++ : y === r.codePoint && u++;
+        }
+        return (o > u ? r : i).character;
+      }
+      var Rn = $n, Nn = /\\(["'\\])|(["'])/gu;
+      function Ln(e, s) {
+        let i = s === '"' ? "'" : '"', r = D(0, e, Nn, (a, o, u) => o ? o === i ? i : a : u === s ? "\\" + u : u);
+        return s + r + s;
+      }
+      var Wn = Ln;
+      function zn(e, s) {
+        let i = e.slice(1, -1), r = s.parser === "json" || s.parser === "jsonc" || s.parser === "json5" && s.quoteProps === "preserve" && !s.singleQuote ? '"' : s.__isInHtmlAttribute ? "'" : Rn(i, s.singleQuote);
+        return e.charAt(0) === r ? e : Wn(i, r);
+      }
+      var xr = zn, Bn = class extends Error {
+        name = "UnexpectedNodeError";
+        constructor(e, s, i = "type") {
+          super(`Unexpected ${s} node ${i}: ${JSON.stringify(e[i])}.`), this.node = e;
+        }
+      }, qn = Bn, kr = /* @__PURE__ */ Symbol.for("PRETTIER_IS_FRONT_MATTER");
+      function Dn(e) {
+        return !!e?.[kr];
+      }
+      var Et = Dn, Re = 3;
+      function Fn(e) {
+        let s = e.slice(0, Re);
+        if (s !== "---" && s !== "+++") return;
+        let i = e.indexOf(`
+`, Re);
+        if (i === -1) return;
+        let r = e.slice(Re, i).trim(), a = e.indexOf(`
+${s}`, i), o = r;
+        if (o || (o = s === "+++" ? "toml" : "yaml"), a === -1 && s === "---" && o === "yaml" && (a = e.indexOf(`
+...`, i)), a === -1) return;
+        let u = a + 1 + Re, p = e.charAt(u + 1);
+        if (!/\s?/u.test(p)) return;
+        let y = e.slice(0, u), m;
+        return { language: o, explicitLanguage: r || null, value: e.slice(i + 1, a), startDelimiter: s, endDelimiter: y.slice(-Re), raw: y, start: { line: 1, column: 0, index: 0 }, end: { index: y.length, get line() {
+          return m ?? (m = y.split(`
+`)), m.length;
+        }, get column() {
+          return m ?? (m = y.split(`
+`)), he(0, m, -1).length;
+        } }, [kr]: !0 };
+      }
+      function Un(e) {
+        let s = Fn(e);
+        return s ? { frontMatter: s, get content() {
+          let { raw: i } = s;
+          return D(0, i, /[^\n]/gu, " ") + e.slice(i.length);
+        } } : { content: e };
+      }
+      var rt = Un, Vn = /* @__PURE__ */ new Set(["raw", "raws", "sourceIndex", "source", "before", "after", "trailingComma", "spaces"]);
+      function Or(e, s, i) {
+        if (e.type === "css-comment" && i.type === "css-root" && i.nodes.length > 0 && ((i.nodes[0] === e || Et(i.nodes[0]) && i.nodes[1] === e) && (delete s.text, /^\*\s*@(?:format|prettier)\s*$/u.test(e.text)) || i.type === "css-root" && he(0, i.nodes, -1) === e)) return null;
+        if (e.type === "value-root" && delete s.text, (e.type === "media-query" || e.type === "media-query-list" || e.type === "media-feature-expression") && delete s.value, e.type === "css-rule" && delete s.params, (e.type === "media-feature" || e.type === "media-keyword" || e.type === "media-type" || e.type === "media-unknown" || e.type === "media-url" || e.type === "media-value" || e.type === "selector-attribute" || e.type === "selector-string" || e.type === "selector-class" || e.type === "selector-combinator" || e.type === "value-string") && e.value && (s.value = Gn(e.value)), e.type === "selector-combinator" && (s.value = D(0, s.value, /\s+/gu, " ")), e.type === "media-feature" && (s.value = D(0, s.value, " ", "")), (e.type === "value-word" && (e.isColor && e.isHex || ["initial", "inherit", "unset", "revert"].includes(e.value.toLowerCase())) || e.type === "media-feature" || e.type === "selector-root-invalid" || e.type === "selector-pseudo") && (s.value = s.value.toLowerCase()), e.type === "css-decl" && (s.prop = e.prop.toLowerCase()), (e.type === "css-atrule" || e.type === "css-import") && (s.name = e.name.toLowerCase()), e.type === "value-number" && (s.unit = e.unit.toLowerCase()), e.type === "value-unknown" && (s.value = D(0, s.value, /;$/gu, "")), e.type === "selector-attribute" && (s.attribute = e.attribute.trim(), e.namespace && typeof e.namespace == "string" && (s.namespace = e.namespace.trim() || !0), e.value)) {
+          let { value: r } = s;
+          /\s[a-zA-Z]$/u.test(r) && (s.__prettier_attribute_selector_flag = he(0, r, -1), r = r.slice(0, -1)), r = r.trim(), r = r.replace(/^(?<quote>["'])(?<value>.*?)\k<quote>$/u, "$<value>"), s.value = r, delete s.quoted;
+        }
+        if ((e.type === "media-value" || e.type === "media-type" || e.type === "value-number" || e.type === "selector-root-invalid" || e.type === "selector-class" || e.type === "selector-combinator" || e.type === "selector-tag") && e.value && (s.value = D(0, s.value, /([\d+.e-]+)([a-z]*)/giu, (r, a, o) => {
+          let u = Number(a);
+          return Number.isNaN(u) ? r : u + o.toLowerCase();
+        })), e.type === "selector-tag") {
+          let r = s.value.toLowerCase();
+          ["from", "to"].includes(r) && (s.value = r);
+        }
+        if (e.type === "css-atrule" && e.name.toLowerCase() === "supports" && delete s.value, e.type === "selector-unknown" && delete s.value, e.type === "value-comma_group") {
+          let r = e.groups.findIndex((a) => a.type === "value-number" && a.unit === "...");
+          r !== -1 && (s.groups[r].unit = "", s.groups.splice(r + 1, 0, { type: "value-word", value: "...", isColor: !1, isHex: !1 }));
+        }
+        if (e.type === "value-comma_group" && e.groups.some((r) => r.type === "value-atword" && (r.value.endsWith("[") || r.value.endsWith("]")) || r.type === "value-word" && (r.value.startsWith("]") || r.value.startsWith("[")))) return { type: "value-atword", value: e.groups.map((r) => r.value).join(""), group: { open: null, close: null, groups: [], type: "value-paren_group" } };
+      }
+      Or.ignoredProperties = Vn;
+      function Gn(e) {
+        return D(0, D(0, e, "'", '"'), /\\([^\da-f])/giu, "$1");
+      }
+      var Hn = Or;
+      function Tr() {
+      }
+      Tr.getVisitorKeys = (e) => e.type === "css-root" ? ["frontMatter"] : [];
+      var Jn = Tr, Ne = null;
+      function Le(e) {
+        if (Ne !== null && typeof Ne.property) {
+          let s = Ne;
+          return Ne = Le.prototype = null, s;
+        }
+        return Ne = Le.prototype = e ?? /* @__PURE__ */ Object.create(null), new Le();
+      }
+      var Qn = 10;
+      for (let e = 0; e <= Qn; e++) Le();
+      function Zn(e) {
+        return Le(e);
+      }
+      function Yn(e, s = "type") {
+        Zn(e);
+        function i(r) {
+          let a = r[s], o = e[a];
+          if (!Array.isArray(o)) throw Object.assign(new Error(`Missing visitor keys for '${a}'.`), { node: r });
+          return o;
+        }
+        return i;
+      }
+      var Kn = Yn, N = [[], ["nodes"], ["group"]], Xn = { "css-root": ["frontMatter", "nodes"], "css-comment": N[0], "css-rule": ["selector", "nodes"], "css-decl": ["value", "selector", "nodes"], "css-atrule": ["selector", "params", "value", "nodes"], "media-query-list": N[1], "media-query": N[1], "media-type": N[0], "media-feature-expression": N[1], "media-feature": N[0], "media-colon": N[0], "media-value": N[0], "media-keyword": N[0], "media-url": N[0], "media-unknown": N[0], "selector-root": N[1], "selector-selector": N[1], "selector-comment": N[0], "selector-string": N[0], "selector-tag": N[0], "selector-id": N[0], "selector-class": N[0], "selector-attribute": N[0], "selector-combinator": N[1], "selector-universal": N[0], "selector-pseudo": N[1], "selector-nesting": N[0], "selector-unknown": N[0], "value-value": N[2], "value-root": N[2], "value-comment": N[0], "value-comma_group": ["groups"], "value-paren_group": ["open", "groups", "close"], "value-func": N[2], "value-paren": N[0], "value-number": N[0], "value-operator": N[0], "value-word": N[0], "value-colon": N[0], "value-comma": N[0], "value-string": N[0], "value-atword": N[0], "value-unicode-range": N[0], "value-unknown": N[0] }, eo = Kn(Xn), to = eo;
+      function ro(e, s) {
+        let i = 0;
+        for (let r = 0; r < e.line - 1; ++r) i = s.indexOf(`
+`, i) + 1;
+        return i + e.column;
+      }
+      var _r = ro;
+      function jt(e) {
+        return (s, i, r) => {
+          let a = !!r?.backwards;
+          if (i === !1) return !1;
+          let { length: o } = s, u = i;
+          for (; u >= 0 && u < o; ) {
+            let p = s.charAt(u);
+            if (e instanceof RegExp) {
+              if (!e.test(p)) return u;
+            } else if (!e.includes(p)) return u;
+            a ? u-- : u++;
+          }
+          return u === -1 || u === o ? u : !1;
+        };
+      }
+      var Cr = jt(" 	"), so = jt(",; 	"), Sr = jt(/[^\n\r]/u);
+      function Ar(e, s) {
+        let { value: i } = e;
+        return i === "-" || i === "--" || i.charAt(0) !== "-" ? s : s - (i.charAt(1) === "-" ? 2 : 1);
+      }
+      function Er(e, s) {
+        if (typeof e.source?.start?.offset == "number") return e.source.start.offset;
+        if (typeof e.sourceIndex == "number") return e.type === "value-word" ? Ar(e, e.sourceIndex) : e.sourceIndex;
+        if (e.source?.start) return _r(e.source.start, s);
+        throw Object.assign(new Error("Can not locate node."), { node: e });
+      }
+      function It(e, s) {
+        if (e.type === "css-comment" && e.inline) return Sr(s, e.source.startOffset);
+        if (typeof e.source?.end?.offset == "number") return e.source.end.offset;
+        if (e.source) {
+          if (e.source.end) {
+            let i = _r(e.source.end, s);
+            return e.type === "value-word" ? Ar(e, i) : i;
+          }
+          if (tt(e.nodes)) return It(he(0, e.nodes, -1), s);
+        }
+        return null;
+      }
+      function jr(e, s) {
+        e.source && (e.source.startOffset = Er(e, s), e.source.endOffset = It(e, s));
+        for (let i in e) {
+          let r = e[i];
+          i === "source" || !r || typeof r != "object" || (r.type === "value-root" || r.type === "value-unknown" ? Ir(r, no(e), r.text || r.value) : jr(r, s));
+        }
+      }
+      function Ir(e, s, i) {
+        e.source && (e.source.startOffset = Er(e, i) + s, e.source.endOffset = It(e, i) + s);
+        for (let r in e) {
+          let a = e[r];
+          r === "source" || !a || typeof a != "object" || Ir(a, s, i);
+        }
+      }
+      function no(e) {
+        let s = e.source.startOffset;
+        return typeof e.prop == "string" && (s += e.prop.length), e.type === "css-atrule" && typeof e.name == "string" && (s += 1 + e.name.length + e.raws.afterName.match(/^\s*:?\s*/u)[0].length), e.type !== "css-atrule" && typeof e.raws?.between == "string" && (s += e.raws.between.length), s;
+      }
+      function oo(e) {
+        let s = "initial", i = "initial", r, a = !1, o = [];
+        for (let u = 0; u < e.length; u++) {
+          let p = e[u];
+          switch (s) {
+            case "initial":
+              if (p === "'") {
+                s = "single-quotes";
+                continue;
+              }
+              if (p === '"') {
+                s = "double-quotes";
+                continue;
+              }
+              if ((p === "u" || p === "U") && e.slice(u, u + 4).toLowerCase() === "url(") {
+                s = "url", u += 3;
+                continue;
+              }
+              if (p === "*" && e[u - 1] === "/") {
+                s = "comment-block";
+                continue;
+              }
+              if (p === "/" && e[u - 1] === "/") {
+                s = "comment-inline", r = u - 1;
+                continue;
+              }
+              continue;
+            case "single-quotes":
+              if (p === "'" && e[u - 1] !== "\\" && (s = i, i = "initial"), p === `
+` || p === "\r") return e;
+              continue;
+            case "double-quotes":
+              if (p === '"' && e[u - 1] !== "\\" && (s = i, i = "initial"), p === `
+` || p === "\r") return e;
+              continue;
+            case "url":
+              if (p === ")" && (s = "initial"), p === `
+` || p === "\r") return e;
+              if (p === "'") {
+                s = "single-quotes", i = "url";
+                continue;
+              }
+              if (p === '"') {
+                s = "double-quotes", i = "url";
+                continue;
+              }
+              continue;
+            case "comment-block":
+              p === "/" && e[u - 1] === "*" && (s = "initial");
+              continue;
+            case "comment-inline":
+              (p === '"' || p === "'" || p === "*") && (a = !0), (p === `
+` || p === "\r") && (a && o.push([r, u]), s = "initial", a = !1);
+              continue;
+          }
+        }
+        for (let [u, p] of o) e = e.slice(0, u) + D(0, e.slice(u, p), /["'*]/gu, " ") + e.slice(p);
+        return e;
+      }
+      var H = (e) => e.source?.startOffset, J = (e) => e.source?.endOffset, io = /\*\/$/, ao = /^\/\*\*?/, Pr = /^\s*(\/\*\*?(.|\r?\n)*?\*\/)/, uo = /(^|\s+)\/\/([^\n\r]*)/g, Mr = /^(\r?\n)+/, lo = /(?:^|\r?\n) *(@[^\n\r]*?) *\r?\n *(?![^\n\r@]*\/\/[^]*)([^\s@][^\n\r@]+?) *\r?\n/g, $r = /(?:^|\r?\n) *@(\S+) *([^\n\r]*)/g, co = /(\r?\n|^) *\* ?/g, Rr = [];
+      function po(e) {
+        let s = e.match(Pr);
+        return s ? s[0].trimStart() : "";
+      }
+      function ho(e) {
+        let s = e.match(Pr)?.[0];
+        return s == null ? e : e.slice(s.length);
+      }
+      function fo(e) {
+        e = D(0, e.replace(ao, "").replace(io, ""), co, "$1");
+        let s = "";
+        for (; s !== e; ) s = e, e = D(0, e, lo, `
+$1 $2
+`);
+        e = e.replace(Mr, "").trimEnd();
+        let i = /* @__PURE__ */ Object.create(null), r = D(0, e, $r, "").replace(Mr, "").trimEnd(), a;
+        for (; a = $r.exec(e); ) {
+          let o = D(0, a[2], uo, "");
+          if (typeof i[a[1]] == "string" || Array.isArray(i[a[1]])) {
+            let u = i[a[1]];
+            i[a[1]] = [...Rr, ...Array.isArray(u) ? u : [u], o];
+          } else i[a[1]] = o;
+        }
+        return { comments: r, pragmas: i };
+      }
+      function mo({ comments: e = "", pragmas: s = {} }) {
+        let i = Object.keys(s), r = i.flatMap((o) => Nr(o, s[o])).map((o) => ` * ${o}
+`).join("");
+        if (!e) {
+          if (i.length === 0) return "";
+          if (i.length === 1 && !Array.isArray(s[i[0]])) {
+            let o = s[i[0]];
+            return `/** ${Nr(i[0], o)[0]} */`;
+          }
+        }
+        let a = e.split(`
+`).map((o) => ` * ${o}`).join(`
+`) + `
+`;
+        return `/**
+` + (e ? a : "") + (e && i.length > 0 ? ` *
+` : "") + r + " */";
+      }
+      function Nr(e, s) {
+        return [...Rr, ...Array.isArray(s) ? s : [s]].map((i) => `@${e} ${i}`.trim());
+      }
+      var yo = ["noformat", "noprettier"], vo = ["format", "prettier"], go = "format";
+      function wo(e) {
+        if (!e.startsWith("#!")) return "";
+        let s = e.indexOf(`
+`);
+        return s === -1 ? e : e.slice(0, s);
+      }
+      var bo = wo;
+      function Pt(e) {
+        let s = bo(e);
+        s && (e = e.slice(s.length + 1));
+        let i = po(e), { pragmas: r, comments: a } = fo(i);
+        return { shebang: s, text: e, pragmas: r, comments: a };
+      }
+      function xo(e) {
+        let { pragmas: s } = Pt(e);
+        return vo.some((i) => Object.prototype.hasOwnProperty.call(s, i));
+      }
+      function ko(e) {
+        let { pragmas: s } = Pt(e);
+        return yo.some((i) => Object.prototype.hasOwnProperty.call(s, i));
+      }
+      function Oo(e) {
+        let { shebang: s, text: i, pragmas: r, comments: a } = Pt(e), o = ho(i), u = mo({ pragmas: { [go]: "", ...r }, comments: a.trimStart() });
+        return (s ? `${s}
+` : "") + u + (o.startsWith(`
+`) ? `
+` : `
+
+`) + o;
+      }
+      var To = (e) => xo(rt(e).content), _o = (e) => ko(rt(e).content), Co = (e) => {
+        let { frontMatter: s, content: i } = rt(e);
+        return (s ? s.raw + `
+
+` : "") + Oo(i);
+      }, So = /* @__PURE__ */ new Set(["red", "green", "blue", "alpha", "a", "rgb", "hue", "h", "saturation", "s", "lightness", "l", "whiteness", "w", "blackness", "b", "tint", "shade", "blend", "blenda", "contrast", "hsl", "hsla", "hwb", "hwba"]);
+      function Ao(e) {
+        return e.findAncestor((s) => s.type === "css-decl")?.prop?.toLowerCase();
+      }
+      var Eo = /* @__PURE__ */ new Set(["initial", "inherit", "unset", "revert"]);
+      function jo(e) {
+        return Eo.has(e.toLowerCase());
+      }
+      function Io(e, s) {
+        return e.findAncestor((i) => i.type === "css-atrule")?.name?.toLowerCase().endsWith("keyframes") && ["from", "to"].includes(s.toLowerCase());
+      }
+      function We(e) {
+        return e.includes("$") || e.includes("@") || e.includes("#") || e.startsWith("%") || e.startsWith("--") || e.startsWith(":--") || e.includes("(") && e.includes(")") ? e : e.toLowerCase();
+      }
+      function st(e, s) {
+        return e.findAncestor((i) => i.type === "value-func")?.value?.toLowerCase() === s;
+      }
+      function Po(e) {
+        return e.hasAncestor((s) => {
+          if (s.type !== "css-rule") return !1;
+          let i = s.raws?.selector;
+          return i && (i.startsWith(":import") || i.startsWith(":export"));
+        });
+      }
+      function ze(e, s) {
+        let i = Array.isArray(s) ? s : [s], r = e.findAncestor((a) => a.type === "css-atrule");
+        return r && i.includes(r.name.toLowerCase());
+      }
+      function Mo(e) {
+        let { node: s } = e;
+        return s.groups[0]?.value === "url" && s.groups.length === 2 && e.findAncestor((i) => i.type === "css-atrule")?.name === "import";
+      }
+      function $o(e) {
+        return e.type === "value-func" && e.value.toLowerCase() === "url";
+      }
+      function Ro(e) {
+        return e.type === "value-func" && e.value.toLowerCase() === "var";
+      }
+      function No(e) {
+        let { selector: s } = e;
+        return s ? typeof s == "string" && /^@.+:.*$/u.test(s) || s.value && /^@.+:.*$/u.test(s.value) : !1;
+      }
+      function Lo(e) {
+        return e.type === "value-word" && ["from", "through", "end"].includes(e.value);
+      }
+      function Wo(e) {
+        return e.type === "value-word" && ["and", "or", "not"].includes(e.value);
+      }
+      function zo(e) {
+        return e.type === "value-word" && e.value === "in";
+      }
+      function Mt(e) {
+        return e.type === "value-operator" && e.value === "*";
+      }
+      function ge(e) {
+        return e?.type === "value-operator" && e.value === "/";
+      }
+      function oe(e) {
+        return e.type === "value-operator" && e.value === "+";
+      }
+      function we(e) {
+        return e.type === "value-operator" && e.value === "-";
+      }
+      function Bo(e) {
+        return e.type === "value-operator" && e.value === "%";
+      }
+      function $t(e) {
+        return Mt(e) || ge(e) || oe(e) || we(e) || Bo(e);
+      }
+      function qo(e) {
+        return e.type === "value-word" && ["==", "!="].includes(e.value);
+      }
+      function Do(e) {
+        return e.type === "value-word" && ["<", ">", "<=", ">="].includes(e.value);
+      }
+      function Rt(e, s) {
+        return s.parser === "scss" && e.type === "css-atrule" && ["if", "else", "for", "each", "while"].includes(e.name);
+      }
+      function Lr(e) {
+        return e.raws?.params && /^\(\s*\)$/u.test(e.raws.params);
+      }
+      function Nt(e) {
+        return e.name.startsWith("prettier-placeholder");
+      }
+      function Fo(e) {
+        return e.prop.startsWith("@prettier-placeholder");
+      }
+      function Uo(e, s) {
+        return e.value === "$$" && e.type === "value-func" && s?.type === "value-word" && !s.raws.before;
+      }
+      function Vo(e) {
+        return e.value?.type === "value-root" && e.value.group?.type === "value-value" && e.prop.toLowerCase() === "composes";
+      }
+      function Go(e) {
+        return e.value?.group?.group?.type === "value-paren_group" && e.value.group.group.open !== null && e.value.group.group.close !== null;
+      }
+      function ie(e) {
+        return e?.raws?.before === "";
+      }
+      function Lt(e) {
+        return e.type === "value-comma_group" && e.groups?.[1]?.type === "value-colon";
+      }
+      function Wt(e) {
+        return e.type === "value-paren_group" && e.groups?.[0] && Lt(e.groups[0]);
+      }
+      function Wr(e, s) {
+        if (s.parser !== "scss") return !1;
+        let { node: i } = e;
+        if (i.groups.length === 0) return !1;
+        let r = e.grandparent;
+        return !Wt(i) && !(r && Wt(r)) ? !1 : !!(e.findAncestor((a) => a.type === "css-decl")?.prop?.startsWith("$") || Wt(r) || r.type === "value-func");
+      }
+      function nt(e) {
+        return e.type === "value-comment" && e.inline;
+      }
+      function zt(e) {
+        return e.type === "value-word" && e.value === "#";
+      }
+      function zr(e) {
+        return e.type === "value-word" && e.value === "{";
+      }
+      function Bt(e) {
+        return e.type === "value-word" && e.value === "}";
+      }
+      function ot(e) {
+        return ["value-word", "value-atword"].includes(e.type);
+      }
+      function qt(e) {
+        return e?.type === "value-colon";
+      }
+      function Ho(e, s) {
+        if (!Lt(s)) return !1;
+        let { groups: i } = s, r = i.indexOf(e);
+        return r === -1 ? !1 : qt(i[r + 1]);
+      }
+      function Jo(e) {
+        return e.value && ["not", "and", "or"].includes(e.value.toLowerCase());
+      }
+      function Qo(e) {
+        return e.type !== "value-func" ? !1 : So.has(e.value.toLowerCase());
+      }
+      function Be(e) {
+        return /\/\//u.test(e.split(/[\n\r]/u).pop());
+      }
+      function it(e) {
+        return e?.type === "value-atword" && e.value.startsWith("prettier-placeholder-");
+      }
+      function Zo(e, s) {
+        if (e.open?.value !== "(" || e.close?.value !== ")" || e.groups.some((i) => i.type !== "value-comma_group")) return !1;
+        if (s.type === "value-comma_group") {
+          let i = s.groups.indexOf(e) - 1, r = s.groups[i];
+          if (r?.type === "value-word" && r.value === "with") return !0;
+        }
+        return !1;
+      }
+      function at(e) {
+        return e.type === "value-paren_group" && e.open?.value === "(" && e.close?.value === ")";
+      }
+      function Yo(e, s, i) {
+        let { node: r } = e, a = e.parent, o = e.grandparent, u = Ao(e), p = u && a.type === "value-value" && (u === "grid" || u.startsWith("grid-template")), y = e.findAncestor((w) => w.type === "css-atrule"), m = y && Rt(y, s), n = r.groups.some((w) => nt(w)), t = e.map(i, "groups"), h = [""], c = st(e, "url"), d = !1, l = !1;
+        for (let w = 0; w < r.groups.length; ++w) {
+          let v = r.groups[w - 1], f = r.groups[w], g = r.groups[w + 1], T = r.groups[w + 2];
+          if (nt(f) && !g) {
+            h.push([h.pop(), jn([" ", t[w]])]);
+            continue;
+          }
+          if (h.push([h.pop(), t[w]]), c) {
+            (g && oe(g) || oe(f)) && h.push([h.pop(), " "]);
+            continue;
+          }
+          if (ze(e, "forward") && f.type === "value-word" && f.value && v !== void 0 && v.type === "value-word" && v.value === "as" && g.type === "value-operator" && g.value === "*" || ze(e, "utility") && f.type === "value-word" && g && g.type === "value-operator" && g.value === "*" || !g || f.type === "value-word" && it(g) && J(f) === H(g)) continue;
+          if (f.type === "value-string" && f.quoted) {
+            let E = f.value.lastIndexOf("#{"), P = f.value.lastIndexOf("}");
+            E !== -1 && P !== -1 ? d = E > P : E !== -1 ? d = !0 : P !== -1 && (d = !1);
+          }
+          if (d || qt(f) || qt(g) || f.type === "value-atword" && (f.value === "" || f.value.endsWith("[")) || g.type === "value-word" && g.value.startsWith("]") || f.value === "~" || s.parser === "less" && (g?.type === "value-word" && g.value === "[" || f.type === "value-word" && f.value === "[" && (g?.type === "value-atword" || g?.type === "value-word") || f.type === "value-word" && f.value === "][" && g?.type === "value-word") || f.type !== "value-string" && f.value && f.value.includes("\\") && g && g.type !== "value-comment" || v?.value && v.value.indexOf("\\") === v.value.length - 1 && f.type === "value-operator" && f.value === "/" || f.value === "\\" || Uo(f, g) || zt(f) || zr(f) || Bt(g) || zr(g) && ie(g) || Bt(f) && ie(g) || f.value === "--" && zt(g)) continue;
+          let b = $t(f), x = $t(g);
+          if ((b && zt(g) || x && Bt(f)) && ie(g) || !v && ge(f) || st(e, "calc") && (oe(f) || oe(g) || we(f) || we(g)) && ie(g)) continue;
+          let k = (oe(f) || we(f)) && w === 0 && (g.type === "value-number" || g.isHex) && o && Qo(o) && !ie(g);
+          if (s.parser === "scss" && b && f.value === "-" && g.type === "value-func" && J(f) !== H(g)) {
+            h.push([h.pop(), " "]);
+            continue;
+          }
+          let O = T?.type === "value-func" || T && ot(T) || f.type === "value-func" || ot(f), A = g.type === "value-func" || ot(g) || v?.type === "value-func" || v && ot(v);
+          if (!(!(Mt(g) || Mt(f)) && !st(e, "calc") && !k && (ge(g) && !O || ge(f) && !A || oe(g) && !O || oe(f) && !A || we(g) || we(f)) && (ie(g) || b && (!v || v && $t(v)))) && !((s.parser === "scss" || s.parser === "less") && b && f.value === "-" && at(g) && J(f) === H(g.open) && g.open.value === "(")) {
+            if (nt(f)) {
+              if (a.type === "value-paren_group") {
+                h.push($e(F), "");
+                continue;
+              }
+              h.push(F, "");
+              continue;
+            }
+            if (m && (qo(g) || Do(g) || Wo(g) || zo(f) || Lo(f))) {
+              h.push([h.pop(), " "]);
+              continue;
+            }
+            if (y && y.name.toLowerCase() === "namespace") {
+              h.push([h.pop(), " "]);
+              continue;
+            }
+            if (p) {
+              f.source && g.source && f.source.start.line !== g.source.start.line ? (h.push(F, ""), l = !0) : h.push([h.pop(), " "]);
+              continue;
+            }
+            if (!(u && (u === "font" || u.startsWith("--")) && (ge(g) && ie(g) && Br(f) || ge(f) && ie(f) && Br(v)))) {
+              if (x) {
+                h.push([h.pop(), " "]);
+                continue;
+              }
+              if (g?.value !== "..." && !(it(f) && it(g) && J(f) === H(g))) {
+                if (it(f) && at(g) && J(f) === H(g.open)) {
+                  h.push(X, "");
+                  continue;
+                }
+                if (f.value === "with" && at(g)) {
+                  h = [[et(h), " "]];
+                  continue;
+                }
+                if (!(f.value?.endsWith("#") && g.value === "{" && at(g.group)) && !(nt(g) && !T)) {
+                  if (!y && f.type === "value-comment" && !f.inline && r.groups.slice(0, w).every((E) => E.type === "value-comment")) {
+                    h.push($e(V), "");
+                    continue;
+                  }
+                  h.push(V, "");
+                }
+              }
+            }
+          }
+        }
+        return n && h.push([h.pop(), At]), l && h.unshift("", F), m ? K(Z(h)) : Mo(e) ? K(et(h)) : K(Z(et(h)));
+      }
+      function Br(e) {
+        if (e?.type === "value-number") return !0;
+        if (e?.type !== "value-func") return !1;
+        let s = e.value.toLowerCase();
+        return s === "var" || s === "calc" || s === "min" || s === "max" || s === "clamp" || s.startsWith("--");
+      }
+      var Ko = Yo;
+      function Xo(e) {
+        return e.length === 1 ? e : e.toLowerCase().replace(/^([+-]?[\d.]+e)(?:\+|(-))?0*(?=\d)/u, "$1$2").replace(/^([+-]?[\d.]+)e[+-]?0+$/u, "$1").replace(/^([+-])?\./u, "$10.").replace(/(\.\d+?)0+(?=e|$)/u, "$1").replace(/\.(?=e|$)/u, "");
+      }
+      var ei = Xo, Dt = /* @__PURE__ */ new Map([["em", "em"], ["rem", "rem"], ["ex", "ex"], ["rex", "rex"], ["cap", "cap"], ["rcap", "rcap"], ["ch", "ch"], ["rch", "rch"], ["ic", "ic"], ["ric", "ric"], ["lh", "lh"], ["rlh", "rlh"], ["vw", "vw"], ["svw", "svw"], ["lvw", "lvw"], ["dvw", "dvw"], ["vh", "vh"], ["svh", "svh"], ["lvh", "lvh"], ["dvh", "dvh"], ["vi", "vi"], ["svi", "svi"], ["lvi", "lvi"], ["dvi", "dvi"], ["vb", "vb"], ["svb", "svb"], ["lvb", "lvb"], ["dvb", "dvb"], ["vmin", "vmin"], ["svmin", "svmin"], ["lvmin", "lvmin"], ["dvmin", "dvmin"], ["vmax", "vmax"], ["svmax", "svmax"], ["lvmax", "lvmax"], ["dvmax", "dvmax"], ["cm", "cm"], ["mm", "mm"], ["q", "Q"], ["in", "in"], ["pt", "pt"], ["pc", "pc"], ["px", "px"], ["deg", "deg"], ["grad", "grad"], ["rad", "rad"], ["turn", "turn"], ["s", "s"], ["ms", "ms"], ["hz", "Hz"], ["khz", "kHz"], ["dpi", "dpi"], ["dpcm", "dpcm"], ["dppx", "dppx"], ["x", "x"], ["cqw", "cqw"], ["cqh", "cqh"], ["cqi", "cqi"], ["cqb", "cqb"], ["cqmin", "cqmin"], ["cqmax", "cqmax"], ["fr", "fr"]]);
+      function qr(e) {
+        let s = e.toLowerCase();
+        return Dt.has(s) ? Dt.get(s) : e;
+      }
+      var Dr = /(["'])(?:(?!\1)[^\\]|\\.)*\1/gsu, ti = /(?:\d*\.\d+|\d+\.?)(?:e[+-]?\d+)?/giu, ri = /[a-z]+/giu, si = /[$@]?[_a-z\u0080-\uFFFF][\w\u0080-\uFFFF-]*/giu, ni = new RegExp(Dr.source + `|(${si.source})?(${ti.source})(${ri.source})?`, "giu");
+      function re(e, s) {
+        return D(0, e, Dr, (i) => xr(i, s));
+      }
+      function oi(e, s) {
+        let i = s.singleQuote ? "'" : '"', r = "", a = e.match(/^(?<value>.+?)\s+(?<flag>[a-zA-Z])$/u);
+        return a && ({ value: e, flag: r } = a.groups), (e.includes('"') || e.includes("'") ? e : i + e + i) + (r ? ` ${r}` : "");
+      }
+      function be(e) {
+        return D(0, e, ni, (s, i, r, a, o) => !r && a && (o ?? (o = ""), o = o.toLowerCase(), !o || o === "n" || Dt.has(o)) ? Fr(a) + (o ? qr(o) : "") : s);
+      }
+      function Fr(e) {
+        return ei(e).replace(/\.0(?=$|e)/u, "");
+      }
+      function ii(e) {
+        return e.trailingComma === "es5" || e.trailingComma === "all";
+      }
+      var Ur = (e) => e === `
+` || e === "\r" || e === "\u2028" || e === "\u2029";
+      function ai(e, s, i) {
+        let r = !!i?.backwards;
+        if (s === !1) return !1;
+        let a = e.charAt(s);
+        if (r) {
+          if (e.charAt(s - 1) === "\r" && a === `
+`) return s - 2;
+          if (Ur(a)) return s - 1;
+        } else {
+          if (a === "\r" && e.charAt(s + 1) === `
+`) return s + 2;
+          if (Ur(a)) return s + 1;
+        }
+        return s;
+      }
+      var Vr = ai;
+      function ui(e, s, i = {}) {
+        let r = Cr(e, i.backwards ? s - 1 : s, i), a = Vr(e, r, i);
+        return r !== a;
+      }
+      var Gr = ui;
+      function li(e, s) {
+        if (s === !1) return !1;
+        if (e.charAt(s) === "/" && e.charAt(s + 1) === "*") {
+          for (let i = s + 2; i < e.length; ++i) if (e.charAt(i) === "*" && e.charAt(i + 1) === "/") return i + 2;
+        }
+        return s;
+      }
+      var ci = li;
+      function pi(e, s) {
+        return s === !1 ? !1 : e.charAt(s) === "/" && e.charAt(s + 1) === "/" ? Sr(e, s) : s;
+      }
+      var hi = pi;
+      function fi(e, s) {
+        let i = null, r = s;
+        for (; r !== i; ) i = r, r = so(e, r), r = ci(e, r), r = Cr(e, r);
+        return r = hi(e, r), r = Vr(e, r), r !== !1 && Gr(e, r);
+      }
+      var Hr = fi;
+      function di({ node: e, parent: s }, i) {
+        return !!(e.source && i.originalText.slice(H(e), H(s.close)).trimEnd().endsWith(","));
+      }
+      function mi(e, s) {
+        return Ro(e.grandparent) && di(e, s) ? "," : e.node.type !== "value-comment" && !(e.node.type === "value-comma_group" && e.node.groups.every((i) => i.type === "value-comment")) && ii(s) && e.callParent(() => Wr(e, s)) ? gr(",") : "";
+      }
+      function yi(e, s, i) {
+        let { node: r, parent: a } = e, o = e.map(({ node: c }) => typeof c == "string" ? c : i(), "groups");
+        if (a && $o(a) && (r.groups.length === 1 || r.groups.length > 0 && r.groups[0].type === "value-comma_group" && r.groups[0].groups.length > 0 && r.groups[0].groups[0].type === "value-word" && r.groups[0].groups[0].value.startsWith("data:"))) return [r.open ? i("open") : "", ne(",", o), r.close ? i("close") : ""];
+        if (!r.open) {
+          let c = Jr(e), d = gi(ne(",", o), 2), l = ne(c ? F : V, d);
+          return Z(c ? [F, l] : K([vi(e) ? X : "", et(l)]));
+        }
+        let u = e.map(({ node: c, isLast: d, index: l }) => {
+          let w = o[l];
+          Lt(c) && c.type === "value-comma_group" && c.groups && c.groups[0].type !== "value-paren_group" && c.groups[2]?.type === "value-paren_group" && Me(w) === Ye && Me(w.contents) === Ze && Me(w.contents.contents) === Ke && (w = K($e(w)));
+          let v = [w, d ? mi(e, s) : ","];
+          if (!d && c.type === "value-comma_group" && tt(c.groups)) {
+            let f = he(0, c.groups, -1);
+            !f.source && f.close && (f = f.close), f.source && Hr(s.originalText, J(f)) && v.push(F);
+          }
+          return v;
+        }, "groups"), p = Ho(r, a), y = Zo(r, a), m = Wr(e, s), n = y || m && !p, t = y || p, h = K([r.open ? i("open") : "", Z([X, ne(V, u)]), X, r.close ? i("close") : ""], { shouldBreak: n });
+        return t ? $e(h) : h;
+      }
+      function Jr(e) {
+        return e.match((s) => s.type === "value-paren_group" && !s.open && s.groups.some((i) => i.type === "value-comma_group"), (s, i) => i === "group" && s.type === "value-value", (s, i) => i === "group" && s.type === "value-root", (s, i) => i === "value" && (s.type === "css-decl" && !s.prop.startsWith("--") || s.type === "css-atrule" && s.variable));
+      }
+      function vi(e) {
+        return e.match((s) => s.type === "value-paren_group" && !s.open, (s, i) => i === "group" && s.type === "value-value", (s, i) => i === "group" && s.type === "value-root", (s, i) => i === "value" && s.type === "css-decl");
+      }
+      function gi(e, s) {
+        let i = [];
+        for (let r = 0; r < e.length; r += s) i.push(e.slice(r, r + s));
+        return i;
+      }
+      function wi(e, s, i) {
+        let r = [];
+        return e.each(() => {
+          let { node: a, previous: o } = e;
+          if (o?.type === "css-comment" && o.text.trim() === "prettier-ignore" ? r.push(s.originalText.slice(H(a), J(a))) : r.push(i()), e.isLast) return;
+          let { next: u } = e;
+          u.type === "css-comment" && !Gr(s.originalText, H(u), { backwards: !0 }) && !Et(a) || u.type === "css-atrule" && u.name === "else" && a.type !== "css-comment" ? r.push(" ") : (r.push(s.__isHTMLStyleAttribute ? V : F), Hr(s.originalText, J(a)) && !Et(a) && r.push(F));
+        }, "nodes"), r;
+      }
+      var qe = wi;
+      function bi(e, s, i) {
+        let { node: r } = e;
+        switch (r.type) {
+          case "css-root": {
+            let a = qe(e, s, i), o = r.raws.after.trim();
+            return o.startsWith(";") && (o = o.slice(1).trim()), [r.frontMatter ? [i("frontMatter"), F, r.nodes.length > 0 ? F : ""] : "", a, o ? ` ${o}` : "", r.nodes.length > 0 ? F : ""];
+          }
+          case "css-comment": {
+            let a = r.inline || r.raws.inline, o = s.originalText.slice(H(r), J(r));
+            return a ? o.trimEnd() : o;
+          }
+          case "css-rule":
+            return [i("selector"), r.important ? " !important" : "", r.nodes ? [r.selector?.type === "selector-unknown" && Be(r.selector.value) ? V : r.selector ? " " : "", "{", r.nodes.length > 0 ? Z([F, qe(e, s, i)]) : "", F, "}", No(r) ? ";" : ""] : ";"];
+          case "css-decl": {
+            let a = e.parent, { between: o } = r.raws, u = o.trim(), p = u === ":", y = typeof r.value == "string" && /^ *$/u.test(r.value), m = typeof r.value == "string" ? r.value : i("value");
+            return m = Vo(r) ? Cn(m) : m, !p && Be(u) && !e.call(() => Jr(e), "value", "group", "group") && (m = Z([F, $e(m)])), [D(0, r.raws.before, /[\s;]/gu, ""), a.type === "css-atrule" && a.variable || Po(e) ? r.prop : We(r.prop), u.startsWith("//") ? " " : "", u, r.extend || y ? "" : " ", s.parser === "less" && r.extend && r.selector ? ["extend(", i("selector"), ")"] : "", m, r.raws.important ? r.raws.important.replace(/\s*!\s*important/iu, " !important") : r.important ? " !important" : "", r.raws.scssDefault ? r.raws.scssDefault.replace(/\s*!default/iu, " !default") : r.scssDefault ? " !default" : "", r.raws.scssGlobal ? r.raws.scssGlobal.replace(/\s*!global/iu, " !global") : r.scssGlobal ? " !global" : "", r.nodes ? [" {", Z([X, qe(e, s, i)]), X, "}"] : Fo(r) && !a.raws.semicolon && s.originalText[J(r) - 1] !== ";" ? "" : s.__isHTMLStyleAttribute && e.isLast ? gr(";") : ";"];
+          }
+          case "css-atrule": {
+            let a = e.parent, o = Nt(r) && !a.raws.semicolon && s.originalText[J(r) - 1] !== ";";
+            if (s.parser === "less") {
+              if (r.mixin) return [i("selector"), r.important ? " !important" : "", o ? "" : ";"];
+              if (r.function) return [r.name, typeof r.params == "string" ? r.params : i("params"), o ? "" : ";"];
+              if (r.variable) return ["@", r.name, ": ", r.value ? i("value") : "", r.raws.between.trim() ? r.raws.between.trim() + " " : "", r.nodes ? ["{", Z([r.nodes.length > 0 ? X : "", qe(e, s, i)]), X, "}"] : "", o ? "" : ";"];
+            }
+            let u = r.name === "import" && r.params?.type === "value-unknown" && r.params.value.endsWith(";");
+            return ["@", Lr(r) || r.name.endsWith(":") || Nt(r) ? r.name : We(r.name), r.params ? [Lr(r) ? "" : Nt(r) ? r.raws.afterName === "" ? "" : r.name.endsWith(":") ? " " : /^\s*\n\s*\n/u.test(r.raws.afterName) ? [F, F] : /^\s*\n/u.test(r.raws.afterName) ? F : " " : " ", typeof r.params == "string" ? r.params : i("params")] : "", r.selector ? Z([" ", i("selector")]) : "", r.value ? K([" ", i("value"), Rt(r, s) ? Go(r) ? " " : V : ""]) : r.name === "else" ? " " : "", r.nodes ? [Rt(r, s) ? "" : r.selector && !r.selector.nodes && typeof r.selector.value == "string" && Be(r.selector.value) || !r.selector && typeof r.params == "string" && Be(r.params) ? V : " ", "{", Z([r.nodes.length > 0 ? X : "", qe(e, s, i)]), X, "}"] : o || u ? "" : ";"];
+          }
+          case "media-query-list": {
+            let a = [];
+            return e.each(({ node: o }) => {
+              o.type === "media-query" && o.value === "" || a.push(i());
+            }, "nodes"), K(Z(ne(V, a)));
+          }
+          case "media-query":
+            return [ne(" ", e.map(i, "nodes")), e.isLast ? "" : ","];
+          case "media-type":
+            return be(re(r.value, s));
+          case "media-feature-expression":
+            return r.nodes ? ["(", ...e.map(i, "nodes"), ")"] : r.value;
+          case "media-feature":
+            return We(re(D(0, r.value, / +/gu, " "), s));
+          case "media-colon":
+            return [r.value, " "];
+          case "media-value":
+            return be(re(r.value, s));
+          case "media-keyword":
+            return re(r.value, s);
+          case "media-url":
+            return re(D(0, D(0, r.value, /^url\(\s+/giu, "url("), /\s+\)$/gu, ")"), s);
+          case "media-unknown":
+            return r.value;
+          case "selector-root":
+            return K([ze(e, "custom-selector") ? [e.findAncestor((a) => a.type === "css-atrule").customSelector, V] : "", ne([",", ze(e, ["extend", "custom-selector", "nest"]) ? V : F], e.map(i, "nodes"))]);
+          case "selector-selector": {
+            let a = r.nodes.length > 2;
+            return K((a ? Z : (o) => o)(e.map(i, "nodes")));
+          }
+          case "selector-comment":
+            return r.value;
+          case "selector-string":
+            return re(r.value, s);
+          case "selector-tag":
+            return [r.namespace ? [r.namespace === !0 ? "" : r.namespace.trim(), "|"] : "", e.previous?.type === "selector-nesting" ? r.value : be(Io(e, r.value) ? r.value.toLowerCase() : r.value)];
+          case "selector-id":
+            return ["#", r.value];
+          case "selector-class":
+            return [".", be(re(r.value, s))];
+          case "selector-attribute":
+            return ["[", r.namespace ? [r.namespace === !0 ? "" : r.namespace.trim(), "|"] : "", r.attribute.trim(), r.operator ?? "", r.value ? oi(re(r.value.trim(), s), s) : "", r.insensitive ? " i" : "", "]"];
+          case "selector-combinator": {
+            if (r.value === "+" || r.value === ">" || r.value === "~" || r.value === ">>>") {
+              let u = e.parent;
+              return [u.type === "selector-selector" && u.nodes[0] === r ? "" : V, r.value, e.isLast ? "" : " "];
+            }
+            let a = r.value.trim().startsWith("(") ? V : "", o = be(re(r.value.trim(), s)) || V;
+            return [a, o];
+          }
+          case "selector-universal":
+            return [r.namespace ? [r.namespace === !0 ? "" : r.namespace.trim(), "|"] : "", r.value];
+          case "selector-pseudo":
+            return [We(r.value), tt(r.nodes) ? K(["(", Z([X, ne([",", V], e.map(i, "nodes"))]), X, ")"]) : ""];
+          case "selector-nesting":
+            return r.value;
+          case "selector-unknown": {
+            if (e.findAncestor((u) => u.type === "css-rule")?.isSCSSNesterProperty) return be(re(We(r.value), s));
+            let a = e.parent;
+            if (a.raws?.selector) {
+              let u = H(a), p = u + a.raws.selector.length;
+              return s.originalText.slice(u, p).trim();
+            }
+            let o = e.grandparent;
+            if (a.type === "value-paren_group" && o?.type === "value-func" && o.value === "selector") {
+              let u = J(a.open) + 1, p = H(a.close), y = s.originalText.slice(u, p).trim();
+              return Be(y) ? [At, y] : y;
+            }
+            return r.value;
+          }
+          case "value-value":
+          case "value-root":
+            return i("group");
+          case "value-comment":
+            return s.originalText.slice(H(r), J(r));
+          case "value-comma_group":
+            return Ko(e, s, i);
+          case "value-paren_group":
+            return yi(e, s, i);
+          case "value-func":
+            return [r.value, ze(e, "supports") && Jo(r) ? " " : "", i("group")];
+          case "value-paren":
+            return r.value;
+          case "value-number":
+            return [Fr(r.value), qr(r.unit)];
+          case "value-operator":
+            return r.value;
+          case "value-word":
+            return r.isColor && r.isHex || jo(r.value) ? r.value.toLowerCase() : r.value;
+          case "value-colon": {
+            let { previous: a } = e;
+            return K([r.value, typeof a?.value == "string" && a.value.endsWith("\\") || st(e, "url") ? "" : V]);
+          }
+          case "value-string":
+            return xr(r.raws.quote + r.value + r.raws.quote, s);
+          case "value-atword":
+            return ["@", r.value];
+          case "value-unicode-range":
+            return r.value;
+          case "value-unknown":
+            return r.value;
+          default:
+            throw new qn(r, "PostCSS");
+        }
+      }
+      var xi = { features: { experimental_frontMatterSupport: { massageAstNode: !0, embed: !0, print: !0 } }, print: bi, embed: Jn, insertPragma: Co, massageAstNode: Hn, getVisitorKeys: to }, ki = xi, Oi = [{ name: "CSS", type: "markup", aceMode: "css", extensions: [".css", ".wxss"], tmScope: "source.css", codemirrorMode: "css", codemirrorMimeType: "text/css", parsers: ["css"], vscodeLanguageIds: ["css"], linguistLanguageId: 50 }, { name: "PostCSS", type: "markup", aceMode: "text", extensions: [".pcss", ".postcss"], tmScope: "source.postcss", group: "CSS", parsers: ["css"], vscodeLanguageIds: ["postcss"], linguistLanguageId: 262764437 }, { name: "Less", type: "markup", aceMode: "less", extensions: [".less"], tmScope: "source.css.less", aliases: ["less-css"], codemirrorMode: "css", codemirrorMimeType: "text/x-less", parsers: ["less"], vscodeLanguageIds: ["less"], linguistLanguageId: 198 }, { name: "SCSS", type: "markup", aceMode: "scss", extensions: [".scss"], tmScope: "source.css.scss", codemirrorMode: "css", codemirrorMimeType: "text/x-scss", parsers: ["scss"], vscodeLanguageIds: ["scss"], linguistLanguageId: 329 }], Ti = { singleQuote: { category: "Common", type: "boolean", default: !1, description: "Use single quotes instead of double quotes." } }, _i = { singleQuote: Ti.singleQuote }, Ci = _i, Qr = {};
+      Jt(Qr, { css: () => na, less: () => oa, scss: () => ia });
+      var Si = me(Qe()), Ai = me(Os()), Ei = me(js());
+      function ji(e, s) {
+        let i = new SyntaxError(e + " (" + s.loc.start.line + ":" + s.loc.start.column + ")");
+        return Object.assign(i, s);
+      }
+      var Ii = ji;
+      function Pi(e) {
+        return e !== null && typeof e == "object";
+      }
+      var ut = Pi, Mi = me(Ps());
+      function De(e, s, i) {
+        if (ut(e)) {
+          delete e.parent;
+          for (let r in e) De(e[r], s, i), r === "type" && typeof e[r] == "string" && !e[r].startsWith(s) && (!i || !i.test(e[r])) && (e[r] = s + e[r]);
+        }
+        return e;
+      }
+      function Zr(e) {
+        if (ut(e)) {
+          delete e.parent;
+          for (let s in e) Zr(e[s]);
+          !Array.isArray(e) && e.value && !e.type && (e.type = "unknown");
+        }
+        return e;
+      }
+      var $i = Mi.default.default;
+      function Ri(e) {
+        let s;
+        try {
+          s = $i(e);
+        } catch {
+          return { type: "selector-unknown", value: e };
+        }
+        return De(Zr(s), "media-");
+      }
+      var Ni = Ri, Li = me(Js());
+      function Wi(e) {
+        if (/\/[/*]/u.test(D(0, e, /"[^"]+"|'[^']+'/gu, ""))) return { type: "selector-unknown", value: e.trim() };
+        let s;
+        try {
+          new Li.default((i) => {
+            s = i;
+          }).process(e);
+        } catch {
+          return { type: "selector-unknown", value: e };
+        }
+        return De(s, "selector-");
+      }
+      var fe = Wi, zi = me(hn()), Bi = (e) => {
+        for (; e.parent; ) e = e.parent;
+        return e;
+      }, Yr = Bi;
+      function qi(e) {
+        return Yr(e).text.slice(e.group.open.sourceIndex + 1, e.group.close.sourceIndex).trim();
+      }
+      var Di = qi;
+      function Fi(e) {
+        if (tt(e)) {
+          for (let s = e.length - 1; s > 0; s--) if (e[s].type === "word" && e[s].value === "{" && e[s - 1].type === "word" && e[s - 1].value.endsWith("#")) return !0;
+        }
+        return !1;
+      }
+      var Ui = Fi;
+      function Vi(e) {
+        return e.some((s) => s.type === "string" || s.type === "func" && !s.value.endsWith("\\"));
+      }
+      var Gi = Vi;
+      function Hi(e, s) {
+        return !!(s.parser === "scss" && e?.type === "word" && e.value.startsWith("$"));
+      }
+      var Ji = Hi, Kr = (e) => e.type === "paren" && e.value === ")";
+      function Qi(e, s) {
+        let { nodes: i } = e, r = { open: null, close: null, groups: [], type: "paren_group" }, a = [r], o = r, u = { groups: [], type: "comma_group" }, p = [u];
+        for (let y = 0; y < i.length; ++y) {
+          let m = i[y];
+          if (s.parser === "scss" && m.type === "number" && m.unit === ".." && m.value.endsWith(".") && (m.value = m.value.slice(0, -1), m.unit = "..."), m.type === "func" && m.value === "selector" && (m.group.groups = [fe(Yr(e).text.slice(m.group.open.sourceIndex + 1, m.group.close.sourceIndex))]), m.type === "func" && m.value === "url") {
+            let n = m.group?.groups ?? [], t = [];
+            for (let h = 0; h < n.length; h++) {
+              let c = n[h];
+              c.type === "comma_group" ? t = [...t, ...c.groups] : t.push(c);
+            }
+            (Ui(t) || !Gi(t) && !Ji(t[0], s)) && (m.group.groups = [Di(m)]);
+          }
+          if (m.type === "paren" && m.value === "(") r = { open: m, close: null, groups: [], type: "paren_group" }, a.push(r), u = { groups: [], type: "comma_group" }, p.push(u);
+          else if (Kr(m)) {
+            if (u.groups.length > 0 && r.groups.push(u), r.close = m, p.length === 1) throw new Error("Unbalanced parenthesis");
+            p.pop(), u = he(0, p, -1), u.groups.push(r), a.pop(), r = he(0, a, -1);
+          } else if (m.type === "comma") {
+            if (y === i.length - 3 && i[y + 1].type === "comment" && Kr(i[y + 2])) continue;
+            r.groups.push(u), u = { groups: [], type: "comma_group" }, p[p.length - 1] = u;
+          } else u.groups.push(m);
+        }
+        return u.groups.length > 0 && r.groups.push(u), o;
+      }
+      function Ft(e) {
+        return e.type === "paren_group" && !e.open && !e.close && e.groups.length === 1 || e.type === "comma_group" && e.groups.length === 1 ? Ft(e.groups[0]) : e.type === "paren_group" || e.type === "comma_group" ? { ...e, groups: e.groups.map(Ft) } : e;
+      }
+      function Xr(e, s) {
+        if (ut(e)) for (let i in e) i !== "parent" && (Xr(e[i], s), i === "nodes" && (e.group = Ft(Qi(e, s)), delete e[i]));
+        return e;
+      }
+      function Zi(e, s) {
+        if (s.parser === "less" && e.startsWith("~`")) return { type: "value-unknown", value: e };
+        let i = null;
+        try {
+          i = new zi.default(e, { loose: !0 }).parse();
+        } catch {
+          return { type: "value-unknown", value: e };
+        }
+        i.text = e;
+        let r = Xr(i, s);
+        return De(r, "value-", /^selector-/u);
+      }
+      var de = Zi, Yi = /* @__PURE__ */ new Set(["import", "use", "forward"]);
+      function Ki(e) {
+        return Yi.has(e);
+      }
+      var Xi = Ki;
+      function ea(e, s) {
+        return s.parser !== "scss" || !e.selector ? !1 : e.selector.replace(/\/\*.*?\*\//u, "").replace(/\/\/.*\n/u, "").trim().endsWith(":");
+      }
+      var ta = ea, ra = /(\s*)(!default).*$/u, sa = /(\s*)(!global).*$/u;
+      function es(e, s) {
+        if (ut(e)) {
+          delete e.parent;
+          for (let o in e) es(e[o], s);
+          if (!e.type) return e;
+          if (e.raws ?? (e.raws = {}), e.type === "css-decl" && typeof e.prop == "string" && e.prop.startsWith("--") && typeof e.value == "string" && e.value.startsWith("{")) {
+            let o;
+            if (e.value.trimEnd().endsWith("}")) {
+              let u = s.originalText.slice(0, e.source.start.offset), p = "a".repeat(e.prop.length) + s.originalText.slice(e.source.start.offset + e.prop.length, e.source.end.offset), y = D(0, u, /[^\n]/gu, " ") + p, m;
+              s.parser === "scss" ? m = ss : s.parser === "less" ? m = rs : m = ts;
+              let n;
+              try {
+                n = m(y, { ...s });
+              } catch {
+              }
+              n?.nodes?.length === 1 && n.nodes[0].type === "css-rule" && (o = n.nodes[0].nodes);
+            }
+            return o ? e.value = { type: "css-rule", nodes: o } : e.value = { type: "value-unknown", value: e.raws.value.raw }, e;
+          }
+          let i = "";
+          typeof e.selector == "string" && (i = e.raws.selector ? e.raws.selector.scss ?? e.raws.selector.raw : e.selector, e.raws.between && e.raws.between.trim().length > 0 && (i += e.raws.between), e.raws.selector = i);
+          let r = "";
+          typeof e.value == "string" && (r = e.raws.value ? e.raws.value.scss ?? e.raws.value.raw : e.value, e.raws.value = r.trim());
+          let a = "";
+          if (typeof e.params == "string" && (a = e.raws.params ? e.raws.params.scss ?? e.raws.params.raw : e.params, e.raws.afterName && e.raws.afterName.trim().length > 0 && (a = e.raws.afterName + a), e.raws.between && e.raws.between.trim().length > 0 && (a = a + e.raws.between), a = a.trim(), e.raws.params = a), i.trim().length > 0) return i.startsWith("@") && i.endsWith(":") ? e : e.mixin ? (e.selector = de(i, s), e) : (ta(e, s) && (e.isSCSSNesterProperty = !0), e.selector = fe(i), e);
+          if (r.trim().length > 0) {
+            let o = r.match(ra);
+            o && (r = r.slice(0, o.index), e.scssDefault = !0, o[0].trim() !== "!default" && (e.raws.scssDefault = o[0]));
+            let u = r.match(sa);
+            if (u && (r = r.slice(0, u.index), e.scssGlobal = !0, u[0].trim() !== "!global" && (e.raws.scssGlobal = u[0])), r.startsWith("progid:")) return { type: "value-unknown", value: r };
+            e.value = de(r, s);
+          }
+          if (s.parser === "less" && e.type === "css-decl" && r.startsWith("extend(") && (e.extend || (e.extend = e.raws.between === ":"), e.extend && !e.selector && (delete e.value, e.selector = fe(r.slice(7, -1)))), e.type === "css-atrule") {
+            if (s.parser === "less") {
+              if (e.mixin) {
+                let o = e.raws.identifier + e.name + e.raws.afterName + e.raws.params;
+                return e.selector = fe(o), delete e.params, e;
+              }
+              if (e.function) return e;
+            }
+            if (s.parser === "css" && e.name === "custom-selector") {
+              let o = e.params.match(/:--\S+\s+/u)[0].trim();
+              return e.customSelector = o, e.selector = fe(e.params.slice(o.length).trim()), delete e.params, e;
+            }
+            if (s.parser === "less") {
+              if (e.name.includes(":")) {
+                e.variable = !0;
+                let o = e.name.split(":");
+                e.name = o[0];
+                let u = o.slice(1).join(":");
+                e.params && (u += e.params), e.value = de(u, s);
+              }
+              if (!["page", "nest", "keyframes"].includes(e.name) && e.params?.[0] === ":") {
+                e.variable = !0;
+                let o = e.params.slice(1);
+                o && (e.value = de(o, s)), e.raws.afterName += ":";
+              }
+              if (e.variable) return delete e.params, e.value || delete e.value, e;
+            }
+          }
+          if (e.type === "css-atrule" && a.length > 0) {
+            let { name: o } = e, u = e.name.toLowerCase();
+            return o === "warn" || o === "error" ? (e.params = { type: "media-unknown", value: a }, e) : o === "extend" || o === "nest" ? (e.selector = fe(a), delete e.params, e) : o === "at-root" ? (/^\(\s*(?:without|with)\s*:.+\)$/su.test(a) ? e.params = de(a, s) : (e.selector = fe(a), delete e.params), e) : Xi(u) ? (e.import = !0, delete e.filename, e.params = de(a, s), e) : ["namespace", "supports", "if", "else", "for", "each", "while", "debug", "mixin", "include", "function", "return", "define-mixin", "add-mixin"].includes(o) ? (a = a.replace(/(\$\S+?)(\s+)?\.{3}/u, "$1...$2"), a = a.replace(/^(?!if)([^"'\s(]+)(\s+)\(/u, "$1($2"), e.value = de(a, s), delete e.params, e) : ["media", "custom-media"].includes(u) ? a.includes("#{") ? { type: "media-unknown", value: a } : (e.params = Ni(a), e) : (e.params = a, e);
+          }
+        }
+        return e;
+      }
+      function Ut(e, s, i) {
+        let { frontMatter: r, content: a } = rt(s), o;
+        try {
+          o = e(a, { map: !1 });
+        } catch (u) {
+          let { name: p, reason: y, line: m, column: n } = u;
+          throw typeof m != "number" ? u : Ii(`${p}: ${y}`, { loc: { start: { line: m, column: n } }, cause: u });
+        }
+        return i.originalText = s, o = es(De(o, "css-"), i), jr(o, s), r && (o.frontMatter = { ...r, type: "front-matter", source: { startOffset: r.start.index, endOffset: r.end.index } }), o;
+      }
+      function ts(e, s = {}) {
+        return Ut(Si.default.default, e, s);
+      }
+      function rs(e, s = {}) {
+        return Ut((i) => Ai.default.parse(oo(i)), e, s);
+      }
+      function ss(e, s = {}) {
+        return Ut(Ei.default, e, s);
+      }
+      var Vt = { astFormat: "postcss", hasPragma: To, hasIgnorePragma: _o, locStart: H, locEnd: J }, na = { ...Vt, parse: ts }, oa = { ...Vt, parse: rs }, ia = { ...Vt, parse: ss }, aa = { postcss: ki };
+      return hs(ur);
+    });
+  })(Ht)), Ht.exports;
+}
+var ls = /* @__PURE__ */ ca();
+const pa = /* @__PURE__ */ ua(ls), fa = /* @__PURE__ */ la({
+  __proto__: null,
+  default: pa
+}, [ls]);
+export {
+  fa as p
+};