eddyter 1.3.61 → 1.3.63

package/dist/postcss-CGIcwj_g.js

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