hldesigner 0.0.1

package/index-8d537d38.js

@@ -0,0 +1,2393 @@
+import { c as Ve, a as st } from "./_commonjsHelpers-e7ea1525.js";
+function at(s, t) {
+  for (var m = 0; m < t.length; m++) {
+    const h = t[m];
+    if (typeof h != "string" && !Array.isArray(h)) {
+      for (const _ in h)
+        if (_ !== "default" && !(_ in s)) {
+          const y = Object.getOwnPropertyDescriptor(h, _);
+          y && Object.defineProperty(s, _, y.get ? y : {
+            enumerable: !0,
+            get: () => h[_]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(s, Symbol.toStringTag, { value: "Module" }));
+}
+var Se = {}, ot = {
+  get exports() {
+    return Se;
+  },
+  set exports(s) {
+    Se = s;
+  }
+}, Me = {}, ut = {
+  get exports() {
+    return Me;
+  },
+  set exports(s) {
+    Me = s;
+  }
+}, Fe = {}, ft = {
+  get exports() {
+    return Fe;
+  },
+  set exports(s) {
+    Fe = s;
+  }
+}, Te = {}, ct = {
+  get exports() {
+    return Te;
+  },
+  set exports(s) {
+    Te = s;
+  }
+}, ve = {}, lt = {
+  get exports() {
+    return ve;
+  },
+  set exports(s) {
+    ve = s;
+  }
+}, ue = {}, ht = {
+  get exports() {
+    return ue;
+  },
+  set exports(s) {
+    ue = s;
+  }
+}, ne = {}, Oe = {}, pt = {
+  get exports() {
+    return Oe;
+  },
+  set exports(s) {
+    Oe = s;
+  }
+};
+(function(s, t) {
+  t.__esModule = !0, t.default = _;
+  function m(y) {
+    for (var d = y.toLowerCase(), S = "", r = !1, n = 0; n < 6 && d[n] !== void 0; n++) {
+      var i = d.charCodeAt(n), a = i >= 97 && i <= 102 || i >= 48 && i <= 57;
+      if (r = i === 32, !a)
+        break;
+      S += d[n];
+    }
+    if (S.length !== 0) {
+      var f = parseInt(S, 16), b = f >= 55296 && f <= 57343;
+      return b || f === 0 || f > 1114111 ? ["�", S.length + (r ? 1 : 0)] : [String.fromCodePoint(f), S.length + (r ? 1 : 0)];
+    }
+  }
+  var h = /\\/;
+  function _(y) {
+    var d = h.test(y);
+    if (!d)
+      return y;
+    for (var S = "", r = 0; r < y.length; r++) {
+      if (y[r] === "\\") {
+        var n = m(y.slice(r + 1, r + 7));
+        if (n !== void 0) {
+          S += n[0], r += n[1];
+          continue;
+        }
+        if (y[r + 1] === "\\") {
+          S += "\\", r++;
+          continue;
+        }
+        y.length === r + 1 && (S += y[r]);
+        continue;
+      }
+      S += y[r];
+    }
+    return S;
+  }
+  s.exports = t.default;
+})(pt, Oe);
+var Ne = {}, vt = {
+  get exports() {
+    return Ne;
+  },
+  set exports(s) {
+    Ne = s;
+  }
+};
+(function(s, t) {
+  t.__esModule = !0, t.default = m;
+  function m(h) {
+    for (var _ = arguments.length, y = new Array(_ > 1 ? _ - 1 : 0), d = 1; d < _; d++)
+      y[d - 1] = arguments[d];
+    for (; y.length > 0; ) {
+      var S = y.shift();
+      if (!h[S])
+        return;
+      h = h[S];
+    }
+    return h;
+  }
+  s.exports = t.default;
+})(vt, Ne);
+var Re = {}, dt = {
+  get exports() {
+    return Re;
+  },
+  set exports(s) {
+    Re = s;
+  }
+};
+(function(s, t) {
+  t.__esModule = !0, t.default = m;
+  function m(h) {
+    for (var _ = arguments.length, y = new Array(_ > 1 ? _ - 1 : 0), d = 1; d < _; d++)
+      y[d - 1] = arguments[d];
+    for (; y.length > 0; ) {
+      var S = y.shift();
+      h[S] || (h[S] = {}), h = h[S];
+    }
+  }
+  s.exports = t.default;
+})(dt, Re);
+var qe = {}, _t = {
+  get exports() {
+    return qe;
+  },
+  set exports(s) {
+    qe = s;
+  }
+};
+(function(s, t) {
+  t.__esModule = !0, t.default = m;
+  function m(h) {
+    for (var _ = "", y = h.indexOf("/*"), d = 0; y >= 0; ) {
+      _ = _ + h.slice(d, y);
+      var S = h.indexOf("*/", y + 2);
+      if (S < 0)
+        return _;
+      d = S + 2, y = h.indexOf("/*", d);
+    }
+    return _ = _ + h.slice(d), _;
+  }
+  s.exports = t.default;
+})(_t, qe);
+ne.__esModule = !0;
+ne.unesc = ne.stripComments = ne.getProp = ne.ensureObject = void 0;
+var gt = Ue(Oe);
+ne.unesc = gt.default;
+var St = Ue(Ne);
+ne.getProp = St.default;
+var Tt = Ue(Re);
+ne.ensureObject = Tt.default;
+var Ot = Ue(qe);
+ne.stripComments = Ot.default;
+function Ue(s) {
+  return s && s.__esModule ? s : { default: s };
+}
+(function(s, t) {
+  t.__esModule = !0, t.default = void 0;
+  var m = ne;
+  function h(S, r) {
+    for (var n = 0; n < r.length; n++) {
+      var i = r[n];
+      i.enumerable = i.enumerable || !1, i.configurable = !0, "value" in i && (i.writable = !0), Object.defineProperty(S, i.key, i);
+    }
+  }
+  function _(S, r, n) {
+    return r && h(S.prototype, r), n && h(S, n), Object.defineProperty(S, "prototype", { writable: !1 }), S;
+  }
+  var y = function S(r, n) {
+    if (typeof r != "object" || r === null)
+      return r;
+    var i = new r.constructor();
+    for (var a in r)
+      if (r.hasOwnProperty(a)) {
+        var f = r[a], b = typeof f;
+        a === "parent" && b === "object" ? n && (i[a] = n) : f instanceof Array ? i[a] = f.map(function(I) {
+          return S(I, i);
+        }) : i[a] = S(f, i);
+      }
+    return i;
+  }, d = /* @__PURE__ */ function() {
+    function S(n) {
+      n === void 0 && (n = {}), Object.assign(this, n), this.spaces = this.spaces || {}, this.spaces.before = this.spaces.before || "", this.spaces.after = this.spaces.after || "";
+    }
+    var r = S.prototype;
+    return r.remove = function() {
+      return this.parent && this.parent.removeChild(this), this.parent = void 0, this;
+    }, r.replaceWith = function() {
+      if (this.parent) {
+        for (var i in arguments)
+          this.parent.insertBefore(this, arguments[i]);
+        this.remove();
+      }
+      return this;
+    }, r.next = function() {
+      return this.parent.at(this.parent.index(this) + 1);
+    }, r.prev = function() {
+      return this.parent.at(this.parent.index(this) - 1);
+    }, r.clone = function(i) {
+      i === void 0 && (i = {});
+      var a = y(this);
+      for (var f in i)
+        a[f] = i[f];
+      return a;
+    }, r.appendToPropertyAndEscape = function(i, a, f) {
+      this.raws || (this.raws = {});
+      var b = this[i], I = this.raws[i];
+      this[i] = b + a, I || f !== a ? this.raws[i] = (I || b) + f : delete this.raws[i];
+    }, r.setPropertyAndEscape = function(i, a, f) {
+      this.raws || (this.raws = {}), this[i] = a, this.raws[i] = f;
+    }, r.setPropertyWithoutEscape = function(i, a) {
+      this[i] = a, this.raws && delete this.raws[i];
+    }, r.isAtPosition = function(i, a) {
+      if (this.source && this.source.start && this.source.end)
+        return !(this.source.start.line > i || this.source.end.line < i || this.source.start.line === i && this.source.start.column > a || this.source.end.line === i && this.source.end.column < a);
+    }, r.stringifyProperty = function(i) {
+      return this.raws && this.raws[i] || this[i];
+    }, r.valueToString = function() {
+      return String(this.stringifyProperty("value"));
+    }, r.toString = function() {
+      return [this.rawSpaceBefore, this.valueToString(), this.rawSpaceAfter].join("");
+    }, _(S, [{
+      key: "rawSpaceBefore",
+      get: function() {
+        var i = this.raws && this.raws.spaces && this.raws.spaces.before;
+        return i === void 0 && (i = this.spaces && this.spaces.before), i || "";
+      },
+      set: function(i) {
+        (0, m.ensureObject)(this, "raws", "spaces"), this.raws.spaces.before = i;
+      }
+    }, {
+      key: "rawSpaceAfter",
+      get: function() {
+        var i = this.raws && this.raws.spaces && this.raws.spaces.after;
+        return i === void 0 && (i = this.spaces.after), i || "";
+      },
+      set: function(i) {
+        (0, m.ensureObject)(this, "raws", "spaces"), this.raws.spaces.after = i;
+      }
+    }]), S;
+  }();
+  t.default = d, s.exports = t.default;
+})(ht, ue);
+var q = {};
+q.__esModule = !0;
+q.UNIVERSAL = q.TAG = q.STRING = q.SELECTOR = q.ROOT = q.PSEUDO = q.NESTING = q.ID = q.COMMENT = q.COMBINATOR = q.CLASS = q.ATTRIBUTE = void 0;
+var yt = "tag";
+q.TAG = yt;
+var Et = "string";
+q.STRING = Et;
+var wt = "selector";
+q.SELECTOR = wt;
+var mt = "root";
+q.ROOT = mt;
+var Pt = "pseudo";
+q.PSEUDO = Pt;
+var kt = "nesting";
+q.NESTING = kt;
+var bt = "id";
+q.ID = bt;
+var It = "comment";
+q.COMMENT = It;
+var Dt = "combinator";
+q.COMBINATOR = Dt;
+var Lt = "class";
+q.CLASS = Lt;
+var At = "attribute";
+q.ATTRIBUTE = At;
+var xt = "universal";
+q.UNIVERSAL = xt;
+(function(s, t) {
+  t.__esModule = !0, t.default = void 0;
+  var m = d(ue), h = y(q);
+  function _(e) {
+    if (typeof WeakMap != "function")
+      return null;
+    var o = /* @__PURE__ */ new WeakMap(), p = /* @__PURE__ */ new WeakMap();
+    return (_ = function(g) {
+      return g ? p : o;
+    })(e);
+  }
+  function y(e, o) {
+    if (!o && e && e.__esModule)
+      return e;
+    if (e === null || typeof e != "object" && typeof e != "function")
+      return { default: e };
+    var p = _(o);
+    if (p && p.has(e))
+      return p.get(e);
+    var v = {}, g = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for (var O in e)
+      if (O !== "default" && Object.prototype.hasOwnProperty.call(e, O)) {
+        var c = g ? Object.getOwnPropertyDescriptor(e, O) : null;
+        c && (c.get || c.set) ? Object.defineProperty(v, O, c) : v[O] = e[O];
+      }
+    return v.default = e, p && p.set(e, v), v;
+  }
+  function d(e) {
+    return e && e.__esModule ? e : { default: e };
+  }
+  function S(e, o) {
+    var p = typeof Symbol < "u" && e[Symbol.iterator] || e["@@iterator"];
+    if (p)
+      return (p = p.call(e)).next.bind(p);
+    if (Array.isArray(e) || (p = r(e)) || o && e && typeof e.length == "number") {
+      p && (e = p);
+      var v = 0;
+      return function() {
+        return v >= e.length ? { done: !0 } : { done: !1, value: e[v++] };
+      };
+    }
+    throw new TypeError(`Invalid attempt to iterate non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+  }
+  function r(e, o) {
+    if (e) {
+      if (typeof e == "string")
+        return n(e, o);
+      var p = Object.prototype.toString.call(e).slice(8, -1);
+      if (p === "Object" && e.constructor && (p = e.constructor.name), p === "Map" || p === "Set")
+        return Array.from(e);
+      if (p === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(p))
+        return n(e, o);
+    }
+  }
+  function n(e, o) {
+    (o == null || o > e.length) && (o = e.length);
+    for (var p = 0, v = new Array(o); p < o; p++)
+      v[p] = e[p];
+    return v;
+  }
+  function i(e, o) {
+    for (var p = 0; p < o.length; p++) {
+      var v = o[p];
+      v.enumerable = v.enumerable || !1, v.configurable = !0, "value" in v && (v.writable = !0), Object.defineProperty(e, v.key, v);
+    }
+  }
+  function a(e, o, p) {
+    return o && i(e.prototype, o), p && i(e, p), Object.defineProperty(e, "prototype", { writable: !1 }), e;
+  }
+  function f(e, o) {
+    e.prototype = Object.create(o.prototype), e.prototype.constructor = e, b(e, o);
+  }
+  function b(e, o) {
+    return b = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(v, g) {
+      return v.__proto__ = g, v;
+    }, b(e, o);
+  }
+  var I = /* @__PURE__ */ function(e) {
+    f(o, e);
+    function o(v) {
+      var g;
+      return g = e.call(this, v) || this, g.nodes || (g.nodes = []), g;
+    }
+    var p = o.prototype;
+    return p.append = function(g) {
+      return g.parent = this, this.nodes.push(g), this;
+    }, p.prepend = function(g) {
+      g.parent = this, this.nodes.unshift(g);
+      for (var O in this.indexes)
+        this.indexes[O]++;
+      return this;
+    }, p.at = function(g) {
+      return this.nodes[g];
+    }, p.index = function(g) {
+      return typeof g == "number" ? g : this.nodes.indexOf(g);
+    }, p.removeChild = function(g) {
+      g = this.index(g), this.at(g).parent = void 0, this.nodes.splice(g, 1);
+      var O;
+      for (var c in this.indexes)
+        O = this.indexes[c], O >= g && (this.indexes[c] = O - 1);
+      return this;
+    }, p.removeAll = function() {
+      for (var g = S(this.nodes), O; !(O = g()).done; ) {
+        var c = O.value;
+        c.parent = void 0;
+      }
+      return this.nodes = [], this;
+    }, p.empty = function() {
+      return this.removeAll();
+    }, p.insertAfter = function(g, O) {
+      var c;
+      O.parent = this;
+      for (var E = this.index(g), M = [], w = 2; w < arguments.length; w++)
+        M.push(arguments[w]);
+      (c = this.nodes).splice.apply(c, [E + 1, 0, O].concat(M)), O.parent = this;
+      var T;
+      for (var k in this.indexes)
+        T = this.indexes[k], E < T && (this.indexes[k] = T + arguments.length - 1);
+      return this;
+    }, p.insertBefore = function(g, O) {
+      var c;
+      O.parent = this;
+      for (var E = this.index(g), M = [], w = 2; w < arguments.length; w++)
+        M.push(arguments[w]);
+      (c = this.nodes).splice.apply(c, [E, 0, O].concat(M)), O.parent = this;
+      var T;
+      for (var k in this.indexes)
+        T = this.indexes[k], T >= E && (this.indexes[k] = T + arguments.length - 1);
+      return this;
+    }, p._findChildAtPosition = function(g, O) {
+      var c = void 0;
+      return this.each(function(E) {
+        if (E.atPosition) {
+          var M = E.atPosition(g, O);
+          if (M)
+            return c = M, !1;
+        } else if (E.isAtPosition(g, O))
+          return c = E, !1;
+      }), c;
+    }, p.atPosition = function(g, O) {
+      if (this.isAtPosition(g, O))
+        return this._findChildAtPosition(g, O) || this;
+    }, p._inferEndPosition = function() {
+      this.last && this.last.source && this.last.source.end && (this.source = this.source || {}, this.source.end = this.source.end || {}, Object.assign(this.source.end, this.last.source.end));
+    }, p.each = function(g) {
+      this.lastEach || (this.lastEach = 0), this.indexes || (this.indexes = {}), this.lastEach++;
+      var O = this.lastEach;
+      if (this.indexes[O] = 0, !!this.length) {
+        for (var c, E; this.indexes[O] < this.length && (c = this.indexes[O], E = g(this.at(c), c), E !== !1); )
+          this.indexes[O] += 1;
+        if (delete this.indexes[O], E === !1)
+          return !1;
+      }
+    }, p.walk = function(g) {
+      return this.each(function(O, c) {
+        var E = g(O, c);
+        if (E !== !1 && O.length && (E = O.walk(g)), E === !1)
+          return !1;
+      });
+    }, p.walkAttributes = function(g) {
+      var O = this;
+      return this.walk(function(c) {
+        if (c.type === h.ATTRIBUTE)
+          return g.call(O, c);
+      });
+    }, p.walkClasses = function(g) {
+      var O = this;
+      return this.walk(function(c) {
+        if (c.type === h.CLASS)
+          return g.call(O, c);
+      });
+    }, p.walkCombinators = function(g) {
+      var O = this;
+      return this.walk(function(c) {
+        if (c.type === h.COMBINATOR)
+          return g.call(O, c);
+      });
+    }, p.walkComments = function(g) {
+      var O = this;
+      return this.walk(function(c) {
+        if (c.type === h.COMMENT)
+          return g.call(O, c);
+      });
+    }, p.walkIds = function(g) {
+      var O = this;
+      return this.walk(function(c) {
+        if (c.type === h.ID)
+          return g.call(O, c);
+      });
+    }, p.walkNesting = function(g) {
+      var O = this;
+      return this.walk(function(c) {
+        if (c.type === h.NESTING)
+          return g.call(O, c);
+      });
+    }, p.walkPseudos = function(g) {
+      var O = this;
+      return this.walk(function(c) {
+        if (c.type === h.PSEUDO)
+          return g.call(O, c);
+      });
+    }, p.walkTags = function(g) {
+      var O = this;
+      return this.walk(function(c) {
+        if (c.type === h.TAG)
+          return g.call(O, c);
+      });
+    }, p.walkUniversals = function(g) {
+      var O = this;
+      return this.walk(function(c) {
+        if (c.type === h.UNIVERSAL)
+          return g.call(O, c);
+      });
+    }, p.split = function(g) {
+      var O = this, c = [];
+      return this.reduce(function(E, M, w) {
+        var T = g.call(O, M);
+        return c.push(M), T ? (E.push(c), c = []) : w === O.length - 1 && E.push(c), E;
+      }, []);
+    }, p.map = function(g) {
+      return this.nodes.map(g);
+    }, p.reduce = function(g, O) {
+      return this.nodes.reduce(g, O);
+    }, p.every = function(g) {
+      return this.nodes.every(g);
+    }, p.some = function(g) {
+      return this.nodes.some(g);
+    }, p.filter = function(g) {
+      return this.nodes.filter(g);
+    }, p.sort = function(g) {
+      return this.nodes.sort(g);
+    }, p.toString = function() {
+      return this.map(String).join("");
+    }, a(o, [{
+      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;
+      }
+    }]), o;
+  }(m.default);
+  t.default = I, s.exports = t.default;
+})(lt, ve);
+(function(s, t) {
+  t.__esModule = !0, t.default = void 0;
+  var m = _(ve), h = q;
+  function _(i) {
+    return i && i.__esModule ? i : { default: i };
+  }
+  function y(i, a) {
+    for (var f = 0; f < a.length; f++) {
+      var b = a[f];
+      b.enumerable = b.enumerable || !1, b.configurable = !0, "value" in b && (b.writable = !0), Object.defineProperty(i, b.key, b);
+    }
+  }
+  function d(i, a, f) {
+    return a && y(i.prototype, a), f && y(i, f), Object.defineProperty(i, "prototype", { writable: !1 }), i;
+  }
+  function S(i, a) {
+    i.prototype = Object.create(a.prototype), i.prototype.constructor = i, r(i, a);
+  }
+  function r(i, a) {
+    return r = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(b, I) {
+      return b.__proto__ = I, b;
+    }, r(i, a);
+  }
+  var n = /* @__PURE__ */ function(i) {
+    S(a, i);
+    function a(b) {
+      var I;
+      return I = i.call(this, b) || this, I.type = h.ROOT, I;
+    }
+    var f = a.prototype;
+    return f.toString = function() {
+      var I = this.reduce(function(e, o) {
+        return e.push(String(o)), e;
+      }, []).join(",");
+      return this.trailingComma ? I + "," : I;
+    }, f.error = function(I, e) {
+      return this._error ? this._error(I, e) : new Error(I);
+    }, d(a, [{
+      key: "errorGenerator",
+      set: function(I) {
+        this._error = I;
+      }
+    }]), a;
+  }(m.default);
+  t.default = n, s.exports = t.default;
+})(ct, Te);
+var ye = {}, Mt = {
+  get exports() {
+    return ye;
+  },
+  set exports(s) {
+    ye = s;
+  }
+};
+(function(s, t) {
+  t.__esModule = !0, t.default = void 0;
+  var m = _(ve), h = q;
+  function _(r) {
+    return r && r.__esModule ? r : { default: r };
+  }
+  function y(r, n) {
+    r.prototype = Object.create(n.prototype), r.prototype.constructor = r, d(r, n);
+  }
+  function d(r, n) {
+    return d = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(a, f) {
+      return a.__proto__ = f, a;
+    }, d(r, n);
+  }
+  var S = /* @__PURE__ */ function(r) {
+    y(n, r);
+    function n(i) {
+      var a;
+      return a = r.call(this, i) || this, a.type = h.SELECTOR, a;
+    }
+    return n;
+  }(m.default);
+  t.default = S, s.exports = t.default;
+})(Mt, ye);
+var Ee = {}, Ft = {
+  get exports() {
+    return Ee;
+  },
+  set exports(s) {
+    Ee = s;
+  }
+};
+/*! https://mths.be/cssesc v3.0.0 by @mathias */
+var Nt = {}, Rt = Nt.hasOwnProperty, qt = function(t, m) {
+  if (!t)
+    return m;
+  var h = {};
+  for (var _ in m)
+    h[_] = Rt.call(t, _) ? t[_] : m[_];
+  return h;
+}, Ct = /[ -,\.\/:-@\[-\^`\{-~]/, Ut = /[ -,\.\/:-@\[\]\^`\{-~]/, Wt = /(^|\\+)?(\\[A-F0-9]{1,6})\x20(?![a-fA-F0-9\x20])/g, Be = function s(t, m) {
+  m = qt(m, s.options), m.quotes != "single" && m.quotes != "double" && (m.quotes = "single");
+  for (var h = m.quotes == "double" ? '"' : "'", _ = m.isIdentifier, y = t.charAt(0), d = "", S = 0, r = t.length; S < r; ) {
+    var n = t.charAt(S++), i = n.charCodeAt(), a = void 0;
+    if (i < 32 || i > 126) {
+      if (i >= 55296 && i <= 56319 && S < r) {
+        var f = t.charCodeAt(S++);
+        (f & 64512) == 56320 ? i = ((i & 1023) << 10) + (f & 1023) + 65536 : S--;
+      }
+      a = "\\" + i.toString(16).toUpperCase() + " ";
+    } else
+      m.escapeEverything ? Ct.test(n) ? a = "\\" + n : a = "\\" + i.toString(16).toUpperCase() + " " : /[\t\n\f\r\x0B]/.test(n) ? a = "\\" + i.toString(16).toUpperCase() + " " : n == "\\" || !_ && (n == '"' && h == n || n == "'" && h == n) || _ && Ut.test(n) ? a = "\\" + n : a = n;
+    d += a;
+  }
+  return _ && (/^-[-\d]/.test(d) ? d = "\\-" + d.slice(1) : /\d/.test(y) && (d = "\\3" + y + " " + d.slice(1))), d = d.replace(Wt, function(b, I, e) {
+    return I && I.length % 2 ? b : (I || "") + e;
+  }), !_ && m.wrap ? h + d + h : d;
+};
+Be.options = {
+  escapeEverything: !1,
+  isIdentifier: !1,
+  quotes: "single",
+  wrap: !1
+};
+Be.version = "3.0.0";
+var Qe = Be;
+(function(s, t) {
+  t.__esModule = !0, t.default = void 0;
+  var m = d(Qe), h = ne, _ = d(ue), y = q;
+  function d(f) {
+    return f && f.__esModule ? f : { default: f };
+  }
+  function S(f, b) {
+    for (var I = 0; I < b.length; I++) {
+      var e = b[I];
+      e.enumerable = e.enumerable || !1, e.configurable = !0, "value" in e && (e.writable = !0), Object.defineProperty(f, e.key, e);
+    }
+  }
+  function r(f, b, I) {
+    return b && S(f.prototype, b), I && S(f, I), Object.defineProperty(f, "prototype", { writable: !1 }), f;
+  }
+  function n(f, b) {
+    f.prototype = Object.create(b.prototype), f.prototype.constructor = f, i(f, b);
+  }
+  function i(f, b) {
+    return i = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(e, o) {
+      return e.__proto__ = o, e;
+    }, i(f, b);
+  }
+  var a = /* @__PURE__ */ function(f) {
+    n(b, f);
+    function b(e) {
+      var o;
+      return o = f.call(this, e) || this, o.type = y.CLASS, o._constructed = !0, o;
+    }
+    var I = b.prototype;
+    return I.valueToString = function() {
+      return "." + f.prototype.valueToString.call(this);
+    }, r(b, [{
+      key: "value",
+      get: function() {
+        return this._value;
+      },
+      set: function(o) {
+        if (this._constructed) {
+          var p = (0, m.default)(o, {
+            isIdentifier: !0
+          });
+          p !== o ? ((0, h.ensureObject)(this, "raws"), this.raws.value = p) : this.raws && delete this.raws.value;
+        }
+        this._value = o;
+      }
+    }]), b;
+  }(_.default);
+  t.default = a, s.exports = t.default;
+})(Ft, Ee);
+var we = {}, Bt = {
+  get exports() {
+    return we;
+  },
+  set exports(s) {
+    we = s;
+  }
+};
+(function(s, t) {
+  t.__esModule = !0, t.default = void 0;
+  var m = _(ue), h = q;
+  function _(r) {
+    return r && r.__esModule ? r : { default: r };
+  }
+  function y(r, n) {
+    r.prototype = Object.create(n.prototype), r.prototype.constructor = r, d(r, n);
+  }
+  function d(r, n) {
+    return d = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(a, f) {
+      return a.__proto__ = f, a;
+    }, d(r, n);
+  }
+  var S = /* @__PURE__ */ function(r) {
+    y(n, r);
+    function n(i) {
+      var a;
+      return a = r.call(this, i) || this, a.type = h.COMMENT, a;
+    }
+    return n;
+  }(m.default);
+  t.default = S, s.exports = t.default;
+})(Bt, we);
+var me = {}, Qt = {
+  get exports() {
+    return me;
+  },
+  set exports(s) {
+    me = s;
+  }
+};
+(function(s, t) {
+  t.__esModule = !0, t.default = void 0;
+  var m = _(ue), h = q;
+  function _(r) {
+    return r && r.__esModule ? r : { default: r };
+  }
+  function y(r, n) {
+    r.prototype = Object.create(n.prototype), r.prototype.constructor = r, d(r, n);
+  }
+  function d(r, n) {
+    return d = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(a, f) {
+      return a.__proto__ = f, a;
+    }, d(r, n);
+  }
+  var S = /* @__PURE__ */ function(r) {
+    y(n, r);
+    function n(a) {
+      var f;
+      return f = r.call(this, a) || this, f.type = h.ID, f;
+    }
+    var i = n.prototype;
+    return i.valueToString = function() {
+      return "#" + r.prototype.valueToString.call(this);
+    }, n;
+  }(m.default);
+  t.default = S, s.exports = t.default;
+})(Qt, me);
+var Pe = {}, Yt = {
+  get exports() {
+    return Pe;
+  },
+  set exports(s) {
+    Pe = s;
+  }
+}, de = {}, Gt = {
+  get exports() {
+    return de;
+  },
+  set exports(s) {
+    de = s;
+  }
+};
+(function(s, t) {
+  t.__esModule = !0, t.default = void 0;
+  var m = y(Qe), h = ne, _ = y(ue);
+  function y(a) {
+    return a && a.__esModule ? a : { default: a };
+  }
+  function d(a, f) {
+    for (var b = 0; b < f.length; b++) {
+      var I = f[b];
+      I.enumerable = I.enumerable || !1, I.configurable = !0, "value" in I && (I.writable = !0), Object.defineProperty(a, I.key, I);
+    }
+  }
+  function S(a, f, b) {
+    return f && d(a.prototype, f), b && d(a, b), Object.defineProperty(a, "prototype", { writable: !1 }), a;
+  }
+  function r(a, f) {
+    a.prototype = Object.create(f.prototype), a.prototype.constructor = a, n(a, f);
+  }
+  function n(a, f) {
+    return n = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(I, e) {
+      return I.__proto__ = e, I;
+    }, n(a, f);
+  }
+  var i = /* @__PURE__ */ function(a) {
+    r(f, a);
+    function f() {
+      return a.apply(this, arguments) || this;
+    }
+    var b = f.prototype;
+    return b.qualifiedName = function(e) {
+      return this.namespace ? this.namespaceString + "|" + e : e;
+    }, b.valueToString = function() {
+      return this.qualifiedName(a.prototype.valueToString.call(this));
+    }, S(f, [{
+      key: "namespace",
+      get: function() {
+        return this._namespace;
+      },
+      set: function(e) {
+        if (e === !0 || e === "*" || e === "&") {
+          this._namespace = e, this.raws && delete this.raws.namespace;
+          return;
+        }
+        var o = (0, m.default)(e, {
+          isIdentifier: !0
+        });
+        this._namespace = e, o !== e ? ((0, h.ensureObject)(this, "raws"), this.raws.namespace = o) : this.raws && delete this.raws.namespace;
+      }
+    }, {
+      key: "ns",
+      get: function() {
+        return this._namespace;
+      },
+      set: function(e) {
+        this.namespace = e;
+      }
+    }, {
+      key: "namespaceString",
+      get: function() {
+        if (this.namespace) {
+          var e = this.stringifyProperty("namespace");
+          return e === !0 ? "" : e;
+        } else
+          return "";
+      }
+    }]), f;
+  }(_.default);
+  t.default = i, s.exports = t.default;
+})(Gt, de);
+(function(s, t) {
+  t.__esModule = !0, t.default = void 0;
+  var m = _(de), h = q;
+  function _(r) {
+    return r && r.__esModule ? r : { default: r };
+  }
+  function y(r, n) {
+    r.prototype = Object.create(n.prototype), r.prototype.constructor = r, d(r, n);
+  }
+  function d(r, n) {
+    return d = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(a, f) {
+      return a.__proto__ = f, a;
+    }, d(r, n);
+  }
+  var S = /* @__PURE__ */ function(r) {
+    y(n, r);
+    function n(i) {
+      var a;
+      return a = r.call(this, i) || this, a.type = h.TAG, a;
+    }
+    return n;
+  }(m.default);
+  t.default = S, s.exports = t.default;
+})(Yt, Pe);
+var ke = {}, $t = {
+  get exports() {
+    return ke;
+  },
+  set exports(s) {
+    ke = s;
+  }
+};
+(function(s, t) {
+  t.__esModule = !0, t.default = void 0;
+  var m = _(ue), h = q;
+  function _(r) {
+    return r && r.__esModule ? r : { default: r };
+  }
+  function y(r, n) {
+    r.prototype = Object.create(n.prototype), r.prototype.constructor = r, d(r, n);
+  }
+  function d(r, n) {
+    return d = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(a, f) {
+      return a.__proto__ = f, a;
+    }, d(r, n);
+  }
+  var S = /* @__PURE__ */ function(r) {
+    y(n, r);
+    function n(i) {
+      var a;
+      return a = r.call(this, i) || this, a.type = h.STRING, a;
+    }
+    return n;
+  }(m.default);
+  t.default = S, s.exports = t.default;
+})($t, ke);
+var be = {}, Vt = {
+  get exports() {
+    return be;
+  },
+  set exports(s) {
+    be = s;
+  }
+};
+(function(s, t) {
+  t.__esModule = !0, t.default = void 0;
+  var m = _(ve), h = q;
+  function _(r) {
+    return r && r.__esModule ? r : { default: r };
+  }
+  function y(r, n) {
+    r.prototype = Object.create(n.prototype), r.prototype.constructor = r, d(r, n);
+  }
+  function d(r, n) {
+    return d = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(a, f) {
+      return a.__proto__ = f, a;
+    }, d(r, n);
+  }
+  var S = /* @__PURE__ */ function(r) {
+    y(n, r);
+    function n(a) {
+      var f;
+      return f = r.call(this, a) || this, f.type = h.PSEUDO, f;
+    }
+    var i = n.prototype;
+    return i.toString = function() {
+      var f = this.length ? "(" + this.map(String).join(",") + ")" : "";
+      return [this.rawSpaceBefore, this.stringifyProperty("value"), f, this.rawSpaceAfter].join("");
+    }, n;
+  }(m.default);
+  t.default = S, s.exports = t.default;
+})(Vt, be);
+var Ye = {}, jt = Ht;
+function Ht(s, t) {
+  if (We("noDeprecation"))
+    return s;
+  var m = !1;
+  function h() {
+    if (!m) {
+      if (We("throwDeprecation"))
+        throw new Error(t);
+      We("traceDeprecation") ? console.trace(t) : console.warn(t), m = !0;
+    }
+    return s.apply(this, arguments);
+  }
+  return h;
+}
+function We(s) {
+  try {
+    if (!Ve.localStorage)
+      return !1;
+  } catch {
+    return !1;
+  }
+  var t = Ve.localStorage[s];
+  return t == null ? !1 : String(t).toLowerCase() === "true";
+}
+(function(s) {
+  s.__esModule = !0, s.default = void 0, s.unescapeValue = o;
+  var t = d(Qe), m = d(Oe), h = d(de), _ = q, y;
+  function d(c) {
+    return c && c.__esModule ? c : { default: c };
+  }
+  function S(c, E) {
+    for (var M = 0; M < E.length; M++) {
+      var w = E[M];
+      w.enumerable = w.enumerable || !1, w.configurable = !0, "value" in w && (w.writable = !0), Object.defineProperty(c, w.key, w);
+    }
+  }
+  function r(c, E, M) {
+    return E && S(c.prototype, E), M && S(c, M), Object.defineProperty(c, "prototype", { writable: !1 }), c;
+  }
+  function n(c, E) {
+    c.prototype = Object.create(E.prototype), c.prototype.constructor = c, i(c, E);
+  }
+  function i(c, E) {
+    return i = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(w, T) {
+      return w.__proto__ = T, w;
+    }, i(c, E);
+  }
+  var a = jt, f = /^('|")([^]*)\1$/, b = a(function() {
+  }, "Assigning an attribute a value containing characters that might need to be escaped is deprecated. Call attribute.setValue() instead."), I = a(function() {
+  }, "Assigning attr.quoted is deprecated and has no effect. Assign to attr.quoteMark instead."), e = a(function() {
+  }, "Constructing an Attribute selector with a value without specifying quoteMark is deprecated. Note: The value should be unescaped now.");
+  function o(c) {
+    var E = !1, M = null, w = c, T = w.match(f);
+    return T && (M = T[1], w = T[2]), w = (0, m.default)(w), w !== c && (E = !0), {
+      deprecatedUsage: E,
+      unescaped: w,
+      quoteMark: M
+    };
+  }
+  function p(c) {
+    if (c.quoteMark !== void 0 || c.value === void 0)
+      return c;
+    e();
+    var E = o(c.value), M = E.quoteMark, w = E.unescaped;
+    return c.raws || (c.raws = {}), c.raws.value === void 0 && (c.raws.value = c.value), c.value = w, c.quoteMark = M, c;
+  }
+  var v = /* @__PURE__ */ function(c) {
+    n(E, c);
+    function E(w) {
+      var T;
+      return w === void 0 && (w = {}), T = c.call(this, p(w)) || this, T.type = _.ATTRIBUTE, T.raws = T.raws || {}, Object.defineProperty(T.raws, "unquoted", {
+        get: a(function() {
+          return T.value;
+        }, "attr.raws.unquoted is deprecated. Call attr.value instead."),
+        set: a(function() {
+          return T.value;
+        }, "Setting attr.raws.unquoted is deprecated and has no effect. attr.value is unescaped by default now.")
+      }), T._constructed = !0, T;
+    }
+    var M = E.prototype;
+    return M.getQuotedValue = function(T) {
+      T === void 0 && (T = {});
+      var k = this._determineQuoteMark(T), W = g[k], G = (0, t.default)(this._value, W);
+      return G;
+    }, M._determineQuoteMark = function(T) {
+      return T.smart ? this.smartQuoteMark(T) : this.preferredQuoteMark(T);
+    }, M.setValue = function(T, k) {
+      k === void 0 && (k = {}), this._value = T, this._quoteMark = this._determineQuoteMark(k), this._syncRawValue();
+    }, M.smartQuoteMark = function(T) {
+      var k = this.value, W = k.replace(/[^']/g, "").length, G = k.replace(/[^"]/g, "").length;
+      if (W + G === 0) {
+        var Z = (0, t.default)(k, {
+          isIdentifier: !0
+        });
+        if (Z === k)
+          return E.NO_QUOTE;
+        var z = this.preferredQuoteMark(T);
+        if (z === E.NO_QUOTE) {
+          var J = this.quoteMark || T.quoteMark || E.DOUBLE_QUOTE, U = g[J], te = (0, t.default)(k, U);
+          if (te.length < Z.length)
+            return J;
+        }
+        return z;
+      } else
+        return G === W ? this.preferredQuoteMark(T) : G < W ? E.DOUBLE_QUOTE : E.SINGLE_QUOTE;
+    }, M.preferredQuoteMark = function(T) {
+      var k = T.preferCurrentQuoteMark ? this.quoteMark : T.quoteMark;
+      return k === void 0 && (k = T.preferCurrentQuoteMark ? T.quoteMark : this.quoteMark), k === void 0 && (k = E.DOUBLE_QUOTE), k;
+    }, M._syncRawValue = function() {
+      var T = (0, t.default)(this._value, g[this.quoteMark]);
+      T === this._value ? this.raws && delete this.raws.value : this.raws.value = T;
+    }, M._handleEscapes = function(T, k) {
+      if (this._constructed) {
+        var W = (0, t.default)(k, {
+          isIdentifier: !0
+        });
+        W !== k ? this.raws[T] = W : delete this.raws[T];
+      }
+    }, M._spacesFor = function(T) {
+      var k = {
+        before: "",
+        after: ""
+      }, W = this.spaces[T] || {}, G = this.raws.spaces && this.raws.spaces[T] || {};
+      return Object.assign(k, W, G);
+    }, M._stringFor = function(T, k, W) {
+      k === void 0 && (k = T), W === void 0 && (W = O);
+      var G = this._spacesFor(k);
+      return W(this.stringifyProperty(T), G);
+    }, M.offsetOf = function(T) {
+      var k = 1, W = this._spacesFor("attribute");
+      if (k += W.before.length, T === "namespace" || T === "ns")
+        return this.namespace ? k : -1;
+      if (T === "attributeNS" || (k += this.namespaceString.length, this.namespace && (k += 1), T === "attribute"))
+        return k;
+      k += this.stringifyProperty("attribute").length, k += W.after.length;
+      var G = this._spacesFor("operator");
+      k += G.before.length;
+      var Z = this.stringifyProperty("operator");
+      if (T === "operator")
+        return Z ? k : -1;
+      k += Z.length, k += G.after.length;
+      var z = this._spacesFor("value");
+      k += z.before.length;
+      var J = this.stringifyProperty("value");
+      if (T === "value")
+        return J ? k : -1;
+      k += J.length, k += z.after.length;
+      var U = this._spacesFor("insensitive");
+      return k += U.before.length, T === "insensitive" && this.insensitive ? k : -1;
+    }, M.toString = function() {
+      var T = this, k = [this.rawSpaceBefore, "["];
+      return k.push(this._stringFor("qualifiedAttribute", "attribute")), this.operator && (this.value || this.value === "") && (k.push(this._stringFor("operator")), k.push(this._stringFor("value")), k.push(this._stringFor("insensitiveFlag", "insensitive", function(W, G) {
+        return W.length > 0 && !T.quoted && G.before.length === 0 && !(T.spaces.value && T.spaces.value.after) && (G.before = " "), O(W, G);
+      }))), k.push("]"), k.push(this.rawSpaceAfter), k.join("");
+    }, r(E, [{
+      key: "quoted",
+      get: function() {
+        var T = this.quoteMark;
+        return T === "'" || T === '"';
+      },
+      set: function(T) {
+        I();
+      }
+      /**
+       * returns a single (`'`) or double (`"`) quote character if the value is quoted.
+       * returns `null` if the value is not quoted.
+       * returns `undefined` if the quotation state is unknown (this can happen when
+       * the attribute is constructed without specifying a quote mark.)
+       */
+    }, {
+      key: "quoteMark",
+      get: function() {
+        return this._quoteMark;
+      },
+      set: function(T) {
+        if (!this._constructed) {
+          this._quoteMark = T;
+          return;
+        }
+        this._quoteMark !== T && (this._quoteMark = T, this._syncRawValue());
+      }
+    }, {
+      key: "qualifiedAttribute",
+      get: function() {
+        return this.qualifiedName(this.raws.attribute || this.attribute);
+      }
+    }, {
+      key: "insensitiveFlag",
+      get: function() {
+        return this.insensitive ? "i" : "";
+      }
+    }, {
+      key: "value",
+      get: function() {
+        return this._value;
+      },
+      set: (
+        /**
+         * Before 3.0, the value had to be set to an escaped value including any wrapped
+         * quote marks. In 3.0, the semantics of `Attribute.value` changed so that the value
+         * is unescaped during parsing and any quote marks are removed.
+         *
+         * Because the ambiguity of this semantic change, if you set `attr.value = newValue`,
+         * a deprecation warning is raised when the new value contains any characters that would
+         * require escaping (including if it contains wrapped quotes).
+         *
+         * Instead, you should call `attr.setValue(newValue, opts)` and pass options that describe
+         * how the new value is quoted.
+         */
+        function(T) {
+          if (this._constructed) {
+            var k = o(T), W = k.deprecatedUsage, G = k.unescaped, Z = k.quoteMark;
+            if (W && b(), G === this._value && Z === this._quoteMark)
+              return;
+            this._value = G, this._quoteMark = Z, this._syncRawValue();
+          } else
+            this._value = T;
+        }
+      )
+    }, {
+      key: "insensitive",
+      get: function() {
+        return this._insensitive;
+      },
+      set: function(T) {
+        T || (this._insensitive = !1, this.raws && (this.raws.insensitiveFlag === "I" || this.raws.insensitiveFlag === "i") && (this.raws.insensitiveFlag = void 0)), this._insensitive = T;
+      }
+    }, {
+      key: "attribute",
+      get: function() {
+        return this._attribute;
+      },
+      set: function(T) {
+        this._handleEscapes("attribute", T), this._attribute = T;
+      }
+    }]), E;
+  }(h.default);
+  s.default = v, v.NO_QUOTE = null, v.SINGLE_QUOTE = "'", v.DOUBLE_QUOTE = '"';
+  var g = (y = {
+    "'": {
+      quotes: "single",
+      wrap: !0
+    },
+    '"': {
+      quotes: "double",
+      wrap: !0
+    }
+  }, y[null] = {
+    isIdentifier: !0
+  }, y);
+  function O(c, E) {
+    return "" + E.before + c + E.after;
+  }
+})(Ye);
+var Ie = {}, zt = {
+  get exports() {
+    return Ie;
+  },
+  set exports(s) {
+    Ie = s;
+  }
+};
+(function(s, t) {
+  t.__esModule = !0, t.default = void 0;
+  var m = _(de), h = q;
+  function _(r) {
+    return r && r.__esModule ? r : { default: r };
+  }
+  function y(r, n) {
+    r.prototype = Object.create(n.prototype), r.prototype.constructor = r, d(r, n);
+  }
+  function d(r, n) {
+    return d = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(a, f) {
+      return a.__proto__ = f, a;
+    }, d(r, n);
+  }
+  var S = /* @__PURE__ */ function(r) {
+    y(n, r);
+    function n(i) {
+      var a;
+      return a = r.call(this, i) || this, a.type = h.UNIVERSAL, a.value = "*", a;
+    }
+    return n;
+  }(m.default);
+  t.default = S, s.exports = t.default;
+})(zt, Ie);
+var De = {}, Kt = {
+  get exports() {
+    return De;
+  },
+  set exports(s) {
+    De = s;
+  }
+};
+(function(s, t) {
+  t.__esModule = !0, t.default = void 0;
+  var m = _(ue), h = q;
+  function _(r) {
+    return r && r.__esModule ? r : { default: r };
+  }
+  function y(r, n) {
+    r.prototype = Object.create(n.prototype), r.prototype.constructor = r, d(r, n);
+  }
+  function d(r, n) {
+    return d = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(a, f) {
+      return a.__proto__ = f, a;
+    }, d(r, n);
+  }
+  var S = /* @__PURE__ */ function(r) {
+    y(n, r);
+    function n(i) {
+      var a;
+      return a = r.call(this, i) || this, a.type = h.COMBINATOR, a;
+    }
+    return n;
+  }(m.default);
+  t.default = S, s.exports = t.default;
+})(Kt, De);
+var Le = {}, Jt = {
+  get exports() {
+    return Le;
+  },
+  set exports(s) {
+    Le = s;
+  }
+};
+(function(s, t) {
+  t.__esModule = !0, t.default = void 0;
+  var m = _(ue), h = q;
+  function _(r) {
+    return r && r.__esModule ? r : { default: r };
+  }
+  function y(r, n) {
+    r.prototype = Object.create(n.prototype), r.prototype.constructor = r, d(r, n);
+  }
+  function d(r, n) {
+    return d = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(a, f) {
+      return a.__proto__ = f, a;
+    }, d(r, n);
+  }
+  var S = /* @__PURE__ */ function(r) {
+    y(n, r);
+    function n(i) {
+      var a;
+      return a = r.call(this, i) || this, a.type = h.NESTING, a.value = "&", a;
+    }
+    return n;
+  }(m.default);
+  t.default = S, s.exports = t.default;
+})(Jt, Le);
+var Ce = {}, Xt = {
+  get exports() {
+    return Ce;
+  },
+  set exports(s) {
+    Ce = s;
+  }
+};
+(function(s, t) {
+  t.__esModule = !0, t.default = m;
+  function m(h) {
+    return h.sort(function(_, y) {
+      return _ - y;
+    });
+  }
+  s.exports = t.default;
+})(Xt, Ce);
+var je = {}, A = {};
+A.__esModule = !0;
+A.word = A.tilde = A.tab = A.str = A.space = A.slash = A.singleQuote = A.semicolon = A.plus = A.pipe = A.openSquare = A.openParenthesis = A.newline = A.greaterThan = A.feed = A.equals = A.doubleQuote = A.dollar = A.cr = A.comment = A.comma = A.combinator = A.colon = A.closeSquare = A.closeParenthesis = A.caret = A.bang = A.backslash = A.at = A.asterisk = A.ampersand = void 0;
+var Zt = 38;
+A.ampersand = Zt;
+var er = 42;
+A.asterisk = er;
+var tr = 64;
+A.at = tr;
+var rr = 44;
+A.comma = rr;
+var nr = 58;
+A.colon = nr;
+var ir = 59;
+A.semicolon = ir;
+var sr = 40;
+A.openParenthesis = sr;
+var ar = 41;
+A.closeParenthesis = ar;
+var or = 91;
+A.openSquare = or;
+var ur = 93;
+A.closeSquare = ur;
+var fr = 36;
+A.dollar = fr;
+var cr = 126;
+A.tilde = cr;
+var lr = 94;
+A.caret = lr;
+var hr = 43;
+A.plus = hr;
+var pr = 61;
+A.equals = pr;
+var vr = 124;
+A.pipe = vr;
+var dr = 62;
+A.greaterThan = dr;
+var _r = 32;
+A.space = _r;
+var He = 39;
+A.singleQuote = He;
+var gr = 34;
+A.doubleQuote = gr;
+var Sr = 47;
+A.slash = Sr;
+var Tr = 33;
+A.bang = Tr;
+var Or = 92;
+A.backslash = Or;
+var yr = 13;
+A.cr = yr;
+var Er = 12;
+A.feed = Er;
+var wr = 10;
+A.newline = wr;
+var mr = 9;
+A.tab = mr;
+var Pr = He;
+A.str = Pr;
+var kr = -1;
+A.comment = kr;
+var br = -2;
+A.word = br;
+var Ir = -3;
+A.combinator = Ir;
+(function(s) {
+  s.__esModule = !0, s.FIELDS = void 0, s.default = I;
+  var t = y(A), m, h;
+  function _(e) {
+    if (typeof WeakMap != "function")
+      return null;
+    var o = /* @__PURE__ */ new WeakMap(), p = /* @__PURE__ */ new WeakMap();
+    return (_ = function(g) {
+      return g ? p : o;
+    })(e);
+  }
+  function y(e, o) {
+    if (!o && e && e.__esModule)
+      return e;
+    if (e === null || typeof e != "object" && typeof e != "function")
+      return { default: e };
+    var p = _(o);
+    if (p && p.has(e))
+      return p.get(e);
+    var v = {}, g = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for (var O in e)
+      if (O !== "default" && Object.prototype.hasOwnProperty.call(e, O)) {
+        var c = g ? Object.getOwnPropertyDescriptor(e, O) : null;
+        c && (c.get || c.set) ? Object.defineProperty(v, O, c) : v[O] = e[O];
+      }
+    return v.default = e, p && p.set(e, v), v;
+  }
+  for (var d = (m = {}, m[t.tab] = !0, m[t.newline] = !0, m[t.cr] = !0, m[t.feed] = !0, m), S = (h = {}, h[t.space] = !0, h[t.tab] = !0, h[t.newline] = !0, h[t.cr] = !0, h[t.feed] = !0, h[t.ampersand] = !0, h[t.asterisk] = !0, h[t.bang] = !0, h[t.comma] = !0, h[t.colon] = !0, h[t.semicolon] = !0, h[t.openParenthesis] = !0, h[t.closeParenthesis] = !0, h[t.openSquare] = !0, h[t.closeSquare] = !0, h[t.singleQuote] = !0, h[t.doubleQuote] = !0, h[t.plus] = !0, h[t.pipe] = !0, h[t.tilde] = !0, h[t.greaterThan] = !0, h[t.equals] = !0, h[t.dollar] = !0, h[t.caret] = !0, h[t.slash] = !0, h), r = {}, n = "0123456789abcdefABCDEF", i = 0; i < n.length; i++)
+    r[n.charCodeAt(i)] = !0;
+  function a(e, o) {
+    var p = o, v;
+    do {
+      if (v = e.charCodeAt(p), S[v])
+        return p - 1;
+      v === t.backslash ? p = f(e, p) + 1 : p++;
+    } while (p < e.length);
+    return p - 1;
+  }
+  function f(e, o) {
+    var p = o, v = e.charCodeAt(p + 1);
+    if (!d[v])
+      if (r[v]) {
+        var g = 0;
+        do
+          p++, g++, v = e.charCodeAt(p + 1);
+        while (r[v] && g < 6);
+        g < 6 && v === t.space && p++;
+      } else
+        p++;
+    return p;
+  }
+  var b = {
+    TYPE: 0,
+    START_LINE: 1,
+    START_COL: 2,
+    END_LINE: 3,
+    END_COL: 4,
+    START_POS: 5,
+    END_POS: 6
+  };
+  s.FIELDS = b;
+  function I(e) {
+    var o = [], p = e.css.valueOf(), v = p, g = v.length, O = -1, c = 1, E = 0, M = 0, w, T, k, W, G, Z, z, J, U, te, fe, _e, ce;
+    function L(x, D) {
+      if (e.safe)
+        p += D, U = p.length - 1;
+      else
+        throw e.error("Unclosed " + x, c, E - O, E);
+    }
+    for (; E < g; ) {
+      switch (w = p.charCodeAt(E), w === t.newline && (O = E, c += 1), w) {
+        case t.space:
+        case t.tab:
+        case t.newline:
+        case t.cr:
+        case t.feed:
+          U = E;
+          do
+            U += 1, w = p.charCodeAt(U), w === t.newline && (O = U, c += 1);
+          while (w === t.space || w === t.newline || w === t.tab || w === t.cr || w === t.feed);
+          ce = t.space, W = c, k = U - O - 1, M = U;
+          break;
+        case t.plus:
+        case t.greaterThan:
+        case t.tilde:
+        case t.pipe:
+          U = E;
+          do
+            U += 1, w = p.charCodeAt(U);
+          while (w === t.plus || w === t.greaterThan || w === t.tilde || w === t.pipe);
+          ce = t.combinator, W = c, k = E - O, M = U;
+          break;
+        case t.asterisk:
+        case t.ampersand:
+        case t.bang:
+        case t.comma:
+        case t.equals:
+        case t.dollar:
+        case t.caret:
+        case t.openSquare:
+        case t.closeSquare:
+        case t.colon:
+        case t.semicolon:
+        case t.openParenthesis:
+        case t.closeParenthesis:
+          U = E, ce = w, W = c, k = E - O, M = U + 1;
+          break;
+        case t.singleQuote:
+        case t.doubleQuote:
+          _e = w === t.singleQuote ? "'" : '"', U = E;
+          do
+            for (G = !1, U = p.indexOf(_e, U + 1), U === -1 && L("quote", _e), Z = U; p.charCodeAt(Z - 1) === t.backslash; )
+              Z -= 1, G = !G;
+          while (G);
+          ce = t.str, W = c, k = E - O, M = U + 1;
+          break;
+        default:
+          w === t.slash && p.charCodeAt(E + 1) === t.asterisk ? (U = p.indexOf("*/", E + 2) + 1, U === 0 && L("comment", "*/"), T = p.slice(E, U + 1), J = T.split(`
+`), z = J.length - 1, z > 0 ? (te = c + z, fe = U - J[z].length) : (te = c, fe = O), ce = t.comment, c = te, W = te, k = U - fe) : w === t.slash ? (U = E, ce = w, W = c, k = E - O, M = U + 1) : (U = a(p, E), ce = t.word, W = c, k = U - O), M = U + 1;
+          break;
+      }
+      o.push([
+        ce,
+        // [0] Token type
+        c,
+        // [1] Starting line
+        E - O,
+        // [2] Starting column
+        W,
+        // [3] Ending line
+        k,
+        // [4] Ending column
+        E,
+        // [5] Start position / Source index
+        M
+        // [6] End position
+      ]), fe && (O = fe, fe = null), E = M;
+    }
+    return o;
+  }
+})(je);
+(function(s, t) {
+  t.__esModule = !0, t.default = void 0;
+  var m = M(Te), h = M(ye), _ = M(Ee), y = M(we), d = M(me), S = M(Pe), r = M(ke), n = M(be), i = E(Ye), a = M(Ie), f = M(De), b = M(Le), I = M(Ce), e = E(je), o = E(A), p = E(q), v = ne, g, O;
+  function c(L) {
+    if (typeof WeakMap != "function")
+      return null;
+    var x = /* @__PURE__ */ new WeakMap(), D = /* @__PURE__ */ new WeakMap();
+    return (c = function(P) {
+      return P ? D : x;
+    })(L);
+  }
+  function E(L, x) {
+    if (!x && L && L.__esModule)
+      return L;
+    if (L === null || typeof L != "object" && typeof L != "function")
+      return { default: L };
+    var D = c(x);
+    if (D && D.has(L))
+      return D.get(L);
+    var u = {}, P = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for (var F in L)
+      if (F !== "default" && Object.prototype.hasOwnProperty.call(L, F)) {
+        var l = P ? Object.getOwnPropertyDescriptor(L, F) : null;
+        l && (l.get || l.set) ? Object.defineProperty(u, F, l) : u[F] = L[F];
+      }
+    return u.default = L, D && D.set(L, u), u;
+  }
+  function M(L) {
+    return L && L.__esModule ? L : { default: L };
+  }
+  function w(L, x) {
+    for (var D = 0; D < x.length; D++) {
+      var u = x[D];
+      u.enumerable = u.enumerable || !1, u.configurable = !0, "value" in u && (u.writable = !0), Object.defineProperty(L, u.key, u);
+    }
+  }
+  function T(L, x, D) {
+    return x && w(L.prototype, x), D && w(L, D), Object.defineProperty(L, "prototype", { writable: !1 }), L;
+  }
+  var k = (g = {}, g[o.space] = !0, g[o.cr] = !0, g[o.feed] = !0, g[o.newline] = !0, g[o.tab] = !0, g), W = Object.assign({}, k, (O = {}, O[o.comment] = !0, O));
+  function G(L) {
+    return {
+      line: L[e.FIELDS.START_LINE],
+      column: L[e.FIELDS.START_COL]
+    };
+  }
+  function Z(L) {
+    return {
+      line: L[e.FIELDS.END_LINE],
+      column: L[e.FIELDS.END_COL]
+    };
+  }
+  function z(L, x, D, u) {
+    return {
+      start: {
+        line: L,
+        column: x
+      },
+      end: {
+        line: D,
+        column: u
+      }
+    };
+  }
+  function J(L) {
+    return z(L[e.FIELDS.START_LINE], L[e.FIELDS.START_COL], L[e.FIELDS.END_LINE], L[e.FIELDS.END_COL]);
+  }
+  function U(L, x) {
+    if (L)
+      return z(L[e.FIELDS.START_LINE], L[e.FIELDS.START_COL], x[e.FIELDS.END_LINE], x[e.FIELDS.END_COL]);
+  }
+  function te(L, x) {
+    var D = L[x];
+    if (typeof D == "string")
+      return D.indexOf("\\") !== -1 && ((0, v.ensureObject)(L, "raws"), L[x] = (0, v.unesc)(D), L.raws[x] === void 0 && (L.raws[x] = D)), L;
+  }
+  function fe(L, x) {
+    for (var D = -1, u = []; (D = L.indexOf(x, D + 1)) !== -1; )
+      u.push(D);
+    return u;
+  }
+  function _e() {
+    var L = Array.prototype.concat.apply([], arguments);
+    return L.filter(function(x, D) {
+      return D === L.indexOf(x);
+    });
+  }
+  var ce = /* @__PURE__ */ function() {
+    function L(D, u) {
+      u === void 0 && (u = {}), this.rule = D, this.options = Object.assign({
+        lossy: !1,
+        safe: !1
+      }, u), this.position = 0, this.css = typeof this.rule == "string" ? this.rule : this.rule.selector, this.tokens = (0, e.default)({
+        css: this.css,
+        error: this._errorGenerator(),
+        safe: this.options.safe
+      });
+      var P = U(this.tokens[0], this.tokens[this.tokens.length - 1]);
+      this.root = new m.default({
+        source: P
+      }), this.root.errorGenerator = this._errorGenerator();
+      var F = new h.default({
+        source: {
+          start: {
+            line: 1,
+            column: 1
+          }
+        },
+        sourceIndex: 0
+      });
+      this.root.append(F), this.current = F, this.loop();
+    }
+    var x = L.prototype;
+    return x._errorGenerator = function() {
+      var u = this;
+      return function(P, F) {
+        return typeof u.rule == "string" ? new Error(P) : u.rule.error(P, F);
+      };
+    }, x.attribute = function() {
+      var u = [], P = this.currToken;
+      for (this.position++; this.position < this.tokens.length && this.currToken[e.FIELDS.TYPE] !== o.closeSquare; )
+        u.push(this.currToken), this.position++;
+      if (this.currToken[e.FIELDS.TYPE] !== o.closeSquare)
+        return this.expected("closing square bracket", this.currToken[e.FIELDS.START_POS]);
+      var F = u.length, l = {
+        source: z(P[1], P[2], this.currToken[3], this.currToken[4]),
+        sourceIndex: P[e.FIELDS.START_POS]
+      };
+      if (F === 1 && !~[o.word].indexOf(u[0][e.FIELDS.TYPE]))
+        return this.expected("attribute", u[0][e.FIELDS.START_POS]);
+      for (var C = 0, Y = "", B = "", N = null, $ = !1; C < F; ) {
+        var K = u[C], R = this.content(K), H = u[C + 1];
+        switch (K[e.FIELDS.TYPE]) {
+          case o.space:
+            if ($ = !0, this.options.lossy)
+              break;
+            if (N) {
+              (0, v.ensureObject)(l, "spaces", N);
+              var he = l.spaces[N].after || "";
+              l.spaces[N].after = he + R;
+              var le = (0, v.getProp)(l, "raws", "spaces", N, "after") || null;
+              le && (l.raws.spaces[N].after = le + R);
+            } else
+              Y = Y + R, B = B + R;
+            break;
+          case o.asterisk:
+            if (H[e.FIELDS.TYPE] === o.equals)
+              l.operator = R, N = "operator";
+            else if ((!l.namespace || N === "namespace" && !$) && H) {
+              Y && ((0, v.ensureObject)(l, "spaces", "attribute"), l.spaces.attribute.before = Y, Y = ""), B && ((0, v.ensureObject)(l, "raws", "spaces", "attribute"), l.raws.spaces.attribute.before = Y, B = ""), l.namespace = (l.namespace || "") + R;
+              var re = (0, v.getProp)(l, "raws", "namespace") || null;
+              re && (l.raws.namespace += R), N = "namespace";
+            }
+            $ = !1;
+            break;
+          case o.dollar:
+            if (N === "value") {
+              var X = (0, v.getProp)(l, "raws", "value");
+              l.value += "$", X && (l.raws.value = X + "$");
+              break;
+            }
+          case o.caret:
+            H[e.FIELDS.TYPE] === o.equals && (l.operator = R, N = "operator"), $ = !1;
+            break;
+          case o.combinator:
+            if (R === "~" && H[e.FIELDS.TYPE] === o.equals && (l.operator = R, N = "operator"), R !== "|") {
+              $ = !1;
+              break;
+            }
+            H[e.FIELDS.TYPE] === o.equals ? (l.operator = R, N = "operator") : !l.namespace && !l.attribute && (l.namespace = !0), $ = !1;
+            break;
+          case o.word:
+            if (H && this.content(H) === "|" && u[C + 2] && u[C + 2][e.FIELDS.TYPE] !== o.equals && // this look-ahead probably fails with comment nodes involved.
+            !l.operator && !l.namespace)
+              l.namespace = R, N = "namespace";
+            else if (!l.attribute || N === "attribute" && !$) {
+              Y && ((0, v.ensureObject)(l, "spaces", "attribute"), l.spaces.attribute.before = Y, Y = ""), B && ((0, v.ensureObject)(l, "raws", "spaces", "attribute"), l.raws.spaces.attribute.before = B, B = ""), l.attribute = (l.attribute || "") + R;
+              var ae = (0, v.getProp)(l, "raws", "attribute") || null;
+              ae && (l.raws.attribute += R), N = "attribute";
+            } else if (!l.value && l.value !== "" || N === "value" && !($ || l.quoteMark)) {
+              var oe = (0, v.unesc)(R), pe = (0, v.getProp)(l, "raws", "value") || "", Ae = l.value || "";
+              l.value = Ae + oe, l.quoteMark = null, (oe !== R || pe) && ((0, v.ensureObject)(l, "raws"), l.raws.value = (pe || Ae) + R), N = "value";
+            } else {
+              var xe = R === "i" || R === "I";
+              (l.value || l.value === "") && (l.quoteMark || $) ? (l.insensitive = xe, (!xe || R === "I") && ((0, v.ensureObject)(l, "raws"), l.raws.insensitiveFlag = R), N = "insensitive", Y && ((0, v.ensureObject)(l, "spaces", "insensitive"), l.spaces.insensitive.before = Y, Y = ""), B && ((0, v.ensureObject)(l, "raws", "spaces", "insensitive"), l.raws.spaces.insensitive.before = B, B = "")) : (l.value || l.value === "") && (N = "value", l.value += R, l.raws.value && (l.raws.value += R));
+            }
+            $ = !1;
+            break;
+          case o.str:
+            if (!l.attribute || !l.operator)
+              return this.error("Expected an attribute followed by an operator preceding the string.", {
+                index: K[e.FIELDS.START_POS]
+              });
+            var ge = (0, i.unescapeValue)(R), Ze = ge.unescaped, et = ge.quoteMark;
+            l.value = Ze, l.quoteMark = et, N = "value", (0, v.ensureObject)(l, "raws"), l.raws.value = R, $ = !1;
+            break;
+          case o.equals:
+            if (!l.attribute)
+              return this.expected("attribute", K[e.FIELDS.START_POS], R);
+            if (l.value)
+              return this.error('Unexpected "=" found; an operator was already defined.', {
+                index: K[e.FIELDS.START_POS]
+              });
+            l.operator = l.operator ? l.operator + R : R, N = "operator", $ = !1;
+            break;
+          case o.comment:
+            if (N)
+              if ($ || H && H[e.FIELDS.TYPE] === o.space || N === "insensitive") {
+                var tt = (0, v.getProp)(l, "spaces", N, "after") || "", rt = (0, v.getProp)(l, "raws", "spaces", N, "after") || tt;
+                (0, v.ensureObject)(l, "raws", "spaces", N), l.raws.spaces[N].after = rt + R;
+              } else {
+                var nt = l[N] || "", it = (0, v.getProp)(l, "raws", N) || nt;
+                (0, v.ensureObject)(l, "raws"), l.raws[N] = it + R;
+              }
+            else
+              B = B + R;
+            break;
+          default:
+            return this.error('Unexpected "' + R + '" found.', {
+              index: K[e.FIELDS.START_POS]
+            });
+        }
+        C++;
+      }
+      te(l, "attribute"), te(l, "namespace"), this.newNode(new i.default(l)), this.position++;
+    }, x.parseWhitespaceEquivalentTokens = function(u) {
+      u < 0 && (u = this.tokens.length);
+      var P = this.position, F = [], l = "", C = void 0;
+      do
+        if (k[this.currToken[e.FIELDS.TYPE]])
+          this.options.lossy || (l += this.content());
+        else if (this.currToken[e.FIELDS.TYPE] === o.comment) {
+          var Y = {};
+          l && (Y.before = l, l = ""), C = new y.default({
+            value: this.content(),
+            source: J(this.currToken),
+            sourceIndex: this.currToken[e.FIELDS.START_POS],
+            spaces: Y
+          }), F.push(C);
+        }
+      while (++this.position < u);
+      if (l) {
+        if (C)
+          C.spaces.after = l;
+        else if (!this.options.lossy) {
+          var B = this.tokens[P], N = this.tokens[this.position - 1];
+          F.push(new r.default({
+            value: "",
+            source: z(B[e.FIELDS.START_LINE], B[e.FIELDS.START_COL], N[e.FIELDS.END_LINE], N[e.FIELDS.END_COL]),
+            sourceIndex: B[e.FIELDS.START_POS],
+            spaces: {
+              before: l,
+              after: ""
+            }
+          }));
+        }
+      }
+      return F;
+    }, x.convertWhitespaceNodesToSpace = function(u, P) {
+      var F = this;
+      P === void 0 && (P = !1);
+      var l = "", C = "";
+      u.forEach(function(B) {
+        var N = F.lossySpace(B.spaces.before, P), $ = F.lossySpace(B.rawSpaceBefore, P);
+        l += N + F.lossySpace(B.spaces.after, P && N.length === 0), C += N + B.value + F.lossySpace(B.rawSpaceAfter, P && $.length === 0);
+      }), C === l && (C = void 0);
+      var Y = {
+        space: l,
+        rawSpace: C
+      };
+      return Y;
+    }, x.isNamedCombinator = function(u) {
+      return u === void 0 && (u = this.position), this.tokens[u + 0] && this.tokens[u + 0][e.FIELDS.TYPE] === o.slash && this.tokens[u + 1] && this.tokens[u + 1][e.FIELDS.TYPE] === o.word && this.tokens[u + 2] && this.tokens[u + 2][e.FIELDS.TYPE] === o.slash;
+    }, x.namedCombinator = function() {
+      if (this.isNamedCombinator()) {
+        var u = this.content(this.tokens[this.position + 1]), P = (0, v.unesc)(u).toLowerCase(), F = {};
+        P !== u && (F.value = "/" + u + "/");
+        var l = new f.default({
+          value: "/" + P + "/",
+          source: z(this.currToken[e.FIELDS.START_LINE], this.currToken[e.FIELDS.START_COL], this.tokens[this.position + 2][e.FIELDS.END_LINE], this.tokens[this.position + 2][e.FIELDS.END_COL]),
+          sourceIndex: this.currToken[e.FIELDS.START_POS],
+          raws: F
+        });
+        return this.position = this.position + 3, l;
+      } else
+        this.unexpected();
+    }, x.combinator = function() {
+      var u = this;
+      if (this.content() === "|")
+        return this.namespace();
+      var P = this.locateNextMeaningfulToken(this.position);
+      if (P < 0 || this.tokens[P][e.FIELDS.TYPE] === o.comma || this.tokens[P][e.FIELDS.TYPE] === o.closeParenthesis) {
+        var F = this.parseWhitespaceEquivalentTokens(P);
+        if (F.length > 0) {
+          var l = this.current.last;
+          if (l) {
+            var C = this.convertWhitespaceNodesToSpace(F), Y = C.space, B = C.rawSpace;
+            B !== void 0 && (l.rawSpaceAfter += B), l.spaces.after += Y;
+          } else
+            F.forEach(function(pe) {
+              return u.newNode(pe);
+            });
+        }
+        return;
+      }
+      var N = this.currToken, $ = void 0;
+      P > this.position && ($ = this.parseWhitespaceEquivalentTokens(P));
+      var K;
+      if (this.isNamedCombinator() ? K = this.namedCombinator() : this.currToken[e.FIELDS.TYPE] === o.combinator ? (K = new f.default({
+        value: this.content(),
+        source: J(this.currToken),
+        sourceIndex: this.currToken[e.FIELDS.START_POS]
+      }), this.position++) : k[this.currToken[e.FIELDS.TYPE]] || $ || this.unexpected(), K) {
+        if ($) {
+          var R = this.convertWhitespaceNodesToSpace($), H = R.space, he = R.rawSpace;
+          K.spaces.before = H, K.rawSpaceBefore = he;
+        }
+      } else {
+        var le = this.convertWhitespaceNodesToSpace($, !0), re = le.space, X = le.rawSpace;
+        X || (X = re);
+        var ae = {}, oe = {
+          spaces: {}
+        };
+        re.endsWith(" ") && X.endsWith(" ") ? (ae.before = re.slice(0, re.length - 1), oe.spaces.before = X.slice(0, X.length - 1)) : re.startsWith(" ") && X.startsWith(" ") ? (ae.after = re.slice(1), oe.spaces.after = X.slice(1)) : oe.value = X, K = new f.default({
+          value: " ",
+          source: U(N, this.tokens[this.position - 1]),
+          sourceIndex: N[e.FIELDS.START_POS],
+          spaces: ae,
+          raws: oe
+        });
+      }
+      return this.currToken && this.currToken[e.FIELDS.TYPE] === o.space && (K.spaces.after = this.optionalSpace(this.content()), this.position++), this.newNode(K);
+    }, x.comma = function() {
+      if (this.position === this.tokens.length - 1) {
+        this.root.trailingComma = !0, this.position++;
+        return;
+      }
+      this.current._inferEndPosition();
+      var u = new h.default({
+        source: {
+          start: G(this.tokens[this.position + 1])
+        },
+        sourceIndex: this.tokens[this.position + 1][e.FIELDS.START_POS]
+      });
+      this.current.parent.append(u), this.current = u, this.position++;
+    }, x.comment = function() {
+      var u = this.currToken;
+      this.newNode(new y.default({
+        value: this.content(),
+        source: J(u),
+        sourceIndex: u[e.FIELDS.START_POS]
+      })), this.position++;
+    }, x.error = function(u, P) {
+      throw this.root.error(u, P);
+    }, x.missingBackslash = function() {
+      return this.error("Expected a backslash preceding the semicolon.", {
+        index: this.currToken[e.FIELDS.START_POS]
+      });
+    }, x.missingParenthesis = function() {
+      return this.expected("opening parenthesis", this.currToken[e.FIELDS.START_POS]);
+    }, x.missingSquareBracket = function() {
+      return this.expected("opening square bracket", this.currToken[e.FIELDS.START_POS]);
+    }, x.unexpected = function() {
+      return this.error("Unexpected '" + this.content() + "'. Escaping special characters with \\ may help.", this.currToken[e.FIELDS.START_POS]);
+    }, x.unexpectedPipe = function() {
+      return this.error("Unexpected '|'.", this.currToken[e.FIELDS.START_POS]);
+    }, x.namespace = function() {
+      var u = this.prevToken && this.content(this.prevToken) || !0;
+      if (this.nextToken[e.FIELDS.TYPE] === o.word)
+        return this.position++, this.word(u);
+      if (this.nextToken[e.FIELDS.TYPE] === o.asterisk)
+        return this.position++, this.universal(u);
+      this.unexpectedPipe();
+    }, x.nesting = function() {
+      if (this.nextToken) {
+        var u = this.content(this.nextToken);
+        if (u === "|") {
+          this.position++;
+          return;
+        }
+      }
+      var P = this.currToken;
+      this.newNode(new b.default({
+        value: this.content(),
+        source: J(P),
+        sourceIndex: P[e.FIELDS.START_POS]
+      })), this.position++;
+    }, x.parentheses = function() {
+      var u = this.current.last, P = 1;
+      if (this.position++, u && u.type === p.PSEUDO) {
+        var F = new h.default({
+          source: {
+            start: G(this.tokens[this.position])
+          },
+          sourceIndex: this.tokens[this.position][e.FIELDS.START_POS]
+        }), l = this.current;
+        for (u.append(F), this.current = F; this.position < this.tokens.length && P; )
+          this.currToken[e.FIELDS.TYPE] === o.openParenthesis && P++, this.currToken[e.FIELDS.TYPE] === o.closeParenthesis && P--, P ? this.parse() : (this.current.source.end = Z(this.currToken), this.current.parent.source.end = Z(this.currToken), this.position++);
+        this.current = l;
+      } else {
+        for (var C = this.currToken, Y = "(", B; this.position < this.tokens.length && P; )
+          this.currToken[e.FIELDS.TYPE] === o.openParenthesis && P++, this.currToken[e.FIELDS.TYPE] === o.closeParenthesis && P--, B = this.currToken, Y += this.parseParenthesisToken(this.currToken), this.position++;
+        u ? u.appendToPropertyAndEscape("value", Y, Y) : this.newNode(new r.default({
+          value: Y,
+          source: z(C[e.FIELDS.START_LINE], C[e.FIELDS.START_COL], B[e.FIELDS.END_LINE], B[e.FIELDS.END_COL]),
+          sourceIndex: C[e.FIELDS.START_POS]
+        }));
+      }
+      if (P)
+        return this.expected("closing parenthesis", this.currToken[e.FIELDS.START_POS]);
+    }, x.pseudo = function() {
+      for (var u = this, P = "", F = this.currToken; this.currToken && this.currToken[e.FIELDS.TYPE] === o.colon; )
+        P += this.content(), this.position++;
+      if (!this.currToken)
+        return this.expected(["pseudo-class", "pseudo-element"], this.position - 1);
+      if (this.currToken[e.FIELDS.TYPE] === o.word)
+        this.splitWord(!1, function(l, C) {
+          P += l, u.newNode(new n.default({
+            value: P,
+            source: U(F, u.currToken),
+            sourceIndex: F[e.FIELDS.START_POS]
+          })), C > 1 && u.nextToken && u.nextToken[e.FIELDS.TYPE] === o.openParenthesis && u.error("Misplaced parenthesis.", {
+            index: u.nextToken[e.FIELDS.START_POS]
+          });
+        });
+      else
+        return this.expected(["pseudo-class", "pseudo-element"], this.currToken[e.FIELDS.START_POS]);
+    }, x.space = function() {
+      var u = this.content();
+      this.position === 0 || this.prevToken[e.FIELDS.TYPE] === o.comma || this.prevToken[e.FIELDS.TYPE] === o.openParenthesis || this.current.nodes.every(function(P) {
+        return P.type === "comment";
+      }) ? (this.spaces = this.optionalSpace(u), this.position++) : this.position === this.tokens.length - 1 || this.nextToken[e.FIELDS.TYPE] === o.comma || this.nextToken[e.FIELDS.TYPE] === o.closeParenthesis ? (this.current.last.spaces.after = this.optionalSpace(u), this.position++) : this.combinator();
+    }, x.string = function() {
+      var u = this.currToken;
+      this.newNode(new r.default({
+        value: this.content(),
+        source: J(u),
+        sourceIndex: u[e.FIELDS.START_POS]
+      })), this.position++;
+    }, x.universal = function(u) {
+      var P = this.nextToken;
+      if (P && this.content(P) === "|")
+        return this.position++, this.namespace();
+      var F = this.currToken;
+      this.newNode(new a.default({
+        value: this.content(),
+        source: J(F),
+        sourceIndex: F[e.FIELDS.START_POS]
+      }), u), this.position++;
+    }, x.splitWord = function(u, P) {
+      for (var F = this, l = this.nextToken, C = this.content(); l && ~[o.dollar, o.caret, o.equals, o.word].indexOf(l[e.FIELDS.TYPE]); ) {
+        this.position++;
+        var Y = this.content();
+        if (C += Y, Y.lastIndexOf("\\") === Y.length - 1) {
+          var B = this.nextToken;
+          B && B[e.FIELDS.TYPE] === o.space && (C += this.requiredSpace(this.content(B)), this.position++);
+        }
+        l = this.nextToken;
+      }
+      var N = fe(C, ".").filter(function(H) {
+        var he = C[H - 1] === "\\", le = /^\d+\.\d+%$/.test(C);
+        return !he && !le;
+      }), $ = fe(C, "#").filter(function(H) {
+        return C[H - 1] !== "\\";
+      }), K = fe(C, "#{");
+      K.length && ($ = $.filter(function(H) {
+        return !~K.indexOf(H);
+      }));
+      var R = (0, I.default)(_e([0].concat(N, $)));
+      R.forEach(function(H, he) {
+        var le = R[he + 1] || C.length, re = C.slice(H, le);
+        if (he === 0 && P)
+          return P.call(F, re, R.length);
+        var X, ae = F.currToken, oe = ae[e.FIELDS.START_POS] + R[he], pe = z(ae[1], ae[2] + H, ae[3], ae[2] + (le - 1));
+        if (~N.indexOf(H)) {
+          var Ae = {
+            value: re.slice(1),
+            source: pe,
+            sourceIndex: oe
+          };
+          X = new _.default(te(Ae, "value"));
+        } else if (~$.indexOf(H)) {
+          var xe = {
+            value: re.slice(1),
+            source: pe,
+            sourceIndex: oe
+          };
+          X = new d.default(te(xe, "value"));
+        } else {
+          var ge = {
+            value: re,
+            source: pe,
+            sourceIndex: oe
+          };
+          te(ge, "value"), X = new S.default(ge);
+        }
+        F.newNode(X, u), u = null;
+      }), this.position++;
+    }, x.word = function(u) {
+      var P = this.nextToken;
+      return P && this.content(P) === "|" ? (this.position++, this.namespace()) : this.splitWord(u);
+    }, x.loop = function() {
+      for (; this.position < this.tokens.length; )
+        this.parse(!0);
+      return this.current._inferEndPosition(), this.root;
+    }, x.parse = function(u) {
+      switch (this.currToken[e.FIELDS.TYPE]) {
+        case o.space:
+          this.space();
+          break;
+        case o.comment:
+          this.comment();
+          break;
+        case o.openParenthesis:
+          this.parentheses();
+          break;
+        case o.closeParenthesis:
+          u && this.missingParenthesis();
+          break;
+        case o.openSquare:
+          this.attribute();
+          break;
+        case o.dollar:
+        case o.caret:
+        case o.equals:
+        case o.word:
+          this.word();
+          break;
+        case o.colon:
+          this.pseudo();
+          break;
+        case o.comma:
+          this.comma();
+          break;
+        case o.asterisk:
+          this.universal();
+          break;
+        case o.ampersand:
+          this.nesting();
+          break;
+        case o.slash:
+        case o.combinator:
+          this.combinator();
+          break;
+        case o.str:
+          this.string();
+          break;
+        case o.closeSquare:
+          this.missingSquareBracket();
+        case o.semicolon:
+          this.missingBackslash();
+        default:
+          this.unexpected();
+      }
+    }, x.expected = function(u, P, F) {
+      if (Array.isArray(u)) {
+        var l = u.pop();
+        u = u.join(", ") + " or " + l;
+      }
+      var C = /^[aeiou]/.test(u[0]) ? "an" : "a";
+      return F ? this.error("Expected " + C + " " + u + ', found "' + F + '" instead.', {
+        index: P
+      }) : this.error("Expected " + C + " " + u + ".", {
+        index: P
+      });
+    }, x.requiredSpace = function(u) {
+      return this.options.lossy ? " " : u;
+    }, x.optionalSpace = function(u) {
+      return this.options.lossy ? "" : u;
+    }, x.lossySpace = function(u, P) {
+      return this.options.lossy ? P ? " " : "" : u;
+    }, x.parseParenthesisToken = function(u) {
+      var P = this.content(u);
+      return u[e.FIELDS.TYPE] === o.space ? this.requiredSpace(P) : P;
+    }, x.newNode = function(u, P) {
+      return P && (/^ +$/.test(P) && (this.options.lossy || (this.spaces = (this.spaces || "") + P), P = !0), u.namespace = P, te(u, "namespace")), this.spaces && (u.spaces.before = this.spaces, this.spaces = ""), this.current.append(u);
+    }, x.content = function(u) {
+      return u === void 0 && (u = this.currToken), this.css.slice(u[e.FIELDS.START_POS], u[e.FIELDS.END_POS]);
+    }, x.locateNextMeaningfulToken = function(u) {
+      u === void 0 && (u = this.position + 1);
+      for (var P = u; P < this.tokens.length; )
+        if (W[this.tokens[P][e.FIELDS.TYPE]]) {
+          P++;
+          continue;
+        } else
+          return P;
+      return -1;
+    }, T(L, [{
+      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];
+      }
+    }]), L;
+  }();
+  t.default = ce, s.exports = t.default;
+})(ft, Fe);
+(function(s, t) {
+  t.__esModule = !0, t.default = void 0;
+  var m = h(Fe);
+  function h(y) {
+    return y && y.__esModule ? y : { default: y };
+  }
+  var _ = /* @__PURE__ */ function() {
+    function y(S, r) {
+      this.func = S || function() {
+      }, this.funcRes = null, this.options = r;
+    }
+    var d = y.prototype;
+    return d._shouldUpdateSelector = function(r, n) {
+      n === void 0 && (n = {});
+      var i = Object.assign({}, this.options, n);
+      return i.updateSelector === !1 ? !1 : typeof r != "string";
+    }, d._isLossy = function(r) {
+      r === void 0 && (r = {});
+      var n = Object.assign({}, this.options, r);
+      return n.lossless === !1;
+    }, d._root = function(r, n) {
+      n === void 0 && (n = {});
+      var i = new m.default(r, this._parseOptions(n));
+      return i.root;
+    }, d._parseOptions = function(r) {
+      return {
+        lossy: this._isLossy(r)
+      };
+    }, d._run = function(r, n) {
+      var i = this;
+      return n === void 0 && (n = {}), new Promise(function(a, f) {
+        try {
+          var b = i._root(r, n);
+          Promise.resolve(i.func(b)).then(function(I) {
+            var e = void 0;
+            return i._shouldUpdateSelector(r, n) && (e = b.toString(), r.selector = e), {
+              transform: I,
+              root: b,
+              string: e
+            };
+          }).then(a, f);
+        } catch (I) {
+          f(I);
+          return;
+        }
+      });
+    }, d._runSync = function(r, n) {
+      n === void 0 && (n = {});
+      var i = this._root(r, n), a = this.func(i);
+      if (a && typeof a.then == "function")
+        throw new Error("Selector processor returned a promise to a synchronous call.");
+      var f = void 0;
+      return n.updateSelector && typeof r != "string" && (f = i.toString(), r.selector = f), {
+        transform: a,
+        root: i,
+        string: f
+      };
+    }, d.ast = function(r, n) {
+      return this._run(r, n).then(function(i) {
+        return i.root;
+      });
+    }, d.astSync = function(r, n) {
+      return this._runSync(r, n).root;
+    }, d.transform = function(r, n) {
+      return this._run(r, n).then(function(i) {
+        return i.transform;
+      });
+    }, d.transformSync = function(r, n) {
+      return this._runSync(r, n).transform;
+    }, d.process = function(r, n) {
+      return this._run(r, n).then(function(i) {
+        return i.string || i.root.toString();
+      });
+    }, d.processSync = function(r, n) {
+      var i = this._runSync(r, n);
+      return i.string || i.root.toString();
+    }, y;
+  }();
+  t.default = _, s.exports = t.default;
+})(ut, Me);
+var ze = {}, V = {};
+V.__esModule = !0;
+V.universal = V.tag = V.string = V.selector = V.root = V.pseudo = V.nesting = V.id = V.comment = V.combinator = V.className = V.attribute = void 0;
+var Dr = ie(Ye), Lr = ie(Ee), Ar = ie(De), xr = ie(we), Mr = ie(me), Fr = ie(Le), Nr = ie(be), Rr = ie(Te), qr = ie(ye), Cr = ie(ke), Ur = ie(Pe), Wr = ie(Ie);
+function ie(s) {
+  return s && s.__esModule ? s : { default: s };
+}
+var Br = function(t) {
+  return new Dr.default(t);
+};
+V.attribute = Br;
+var Qr = function(t) {
+  return new Lr.default(t);
+};
+V.className = Qr;
+var Yr = function(t) {
+  return new Ar.default(t);
+};
+V.combinator = Yr;
+var Gr = function(t) {
+  return new xr.default(t);
+};
+V.comment = Gr;
+var $r = function(t) {
+  return new Mr.default(t);
+};
+V.id = $r;
+var Vr = function(t) {
+  return new Fr.default(t);
+};
+V.nesting = Vr;
+var jr = function(t) {
+  return new Nr.default(t);
+};
+V.pseudo = jr;
+var Hr = function(t) {
+  return new Rr.default(t);
+};
+V.root = Hr;
+var zr = function(t) {
+  return new qr.default(t);
+};
+V.selector = zr;
+var Kr = function(t) {
+  return new Cr.default(t);
+};
+V.string = Kr;
+var Jr = function(t) {
+  return new Ur.default(t);
+};
+V.tag = Jr;
+var Xr = function(t) {
+  return new Wr.default(t);
+};
+V.universal = Xr;
+var Q = {};
+Q.__esModule = !0;
+Q.isComment = Q.isCombinator = Q.isClassName = Q.isAttribute = void 0;
+Q.isContainer = ln;
+Q.isIdentifier = void 0;
+Q.isNamespace = hn;
+Q.isNesting = void 0;
+Q.isNode = Ge;
+Q.isPseudo = void 0;
+Q.isPseudoClass = cn;
+Q.isPseudoElement = Xe;
+Q.isUniversal = Q.isTag = Q.isString = Q.isSelector = Q.isRoot = void 0;
+var j = q, ee, Zr = (ee = {}, ee[j.ATTRIBUTE] = !0, ee[j.CLASS] = !0, ee[j.COMBINATOR] = !0, ee[j.COMMENT] = !0, ee[j.ID] = !0, ee[j.NESTING] = !0, ee[j.PSEUDO] = !0, ee[j.ROOT] = !0, ee[j.SELECTOR] = !0, ee[j.STRING] = !0, ee[j.TAG] = !0, ee[j.UNIVERSAL] = !0, ee);
+function Ge(s) {
+  return typeof s == "object" && Zr[s.type];
+}
+function se(s, t) {
+  return Ge(t) && t.type === s;
+}
+var Ke = se.bind(null, j.ATTRIBUTE);
+Q.isAttribute = Ke;
+var en = se.bind(null, j.CLASS);
+Q.isClassName = en;
+var tn = se.bind(null, j.COMBINATOR);
+Q.isCombinator = tn;
+var rn = se.bind(null, j.COMMENT);
+Q.isComment = rn;
+var nn = se.bind(null, j.ID);
+Q.isIdentifier = nn;
+var sn = se.bind(null, j.NESTING);
+Q.isNesting = sn;
+var $e = se.bind(null, j.PSEUDO);
+Q.isPseudo = $e;
+var an = se.bind(null, j.ROOT);
+Q.isRoot = an;
+var on = se.bind(null, j.SELECTOR);
+Q.isSelector = on;
+var un = se.bind(null, j.STRING);
+Q.isString = un;
+var Je = se.bind(null, j.TAG);
+Q.isTag = Je;
+var fn = se.bind(null, j.UNIVERSAL);
+Q.isUniversal = fn;
+function Xe(s) {
+  return $e(s) && s.value && (s.value.startsWith("::") || s.value.toLowerCase() === ":before" || s.value.toLowerCase() === ":after" || s.value.toLowerCase() === ":first-letter" || s.value.toLowerCase() === ":first-line");
+}
+function cn(s) {
+  return $e(s) && !Xe(s);
+}
+function ln(s) {
+  return !!(Ge(s) && s.walk);
+}
+function hn(s) {
+  return Ke(s) || Je(s);
+}
+(function(s) {
+  s.__esModule = !0;
+  var t = q;
+  Object.keys(t).forEach(function(_) {
+    _ === "default" || _ === "__esModule" || _ in s && s[_] === t[_] || (s[_] = t[_]);
+  });
+  var m = V;
+  Object.keys(m).forEach(function(_) {
+    _ === "default" || _ === "__esModule" || _ in s && s[_] === m[_] || (s[_] = m[_]);
+  });
+  var h = Q;
+  Object.keys(h).forEach(function(_) {
+    _ === "default" || _ === "__esModule" || _ in s && s[_] === h[_] || (s[_] = h[_]);
+  });
+})(ze);
+(function(s, t) {
+  t.__esModule = !0, t.default = void 0;
+  var m = d(Me), h = y(ze);
+  function _(n) {
+    if (typeof WeakMap != "function")
+      return null;
+    var i = /* @__PURE__ */ new WeakMap(), a = /* @__PURE__ */ new WeakMap();
+    return (_ = function(b) {
+      return b ? a : i;
+    })(n);
+  }
+  function y(n, i) {
+    if (!i && n && n.__esModule)
+      return n;
+    if (n === null || typeof n != "object" && typeof n != "function")
+      return { default: n };
+    var a = _(i);
+    if (a && a.has(n))
+      return a.get(n);
+    var f = {}, b = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for (var I in n)
+      if (I !== "default" && Object.prototype.hasOwnProperty.call(n, I)) {
+        var e = b ? Object.getOwnPropertyDescriptor(n, I) : null;
+        e && (e.get || e.set) ? Object.defineProperty(f, I, e) : f[I] = n[I];
+      }
+    return f.default = n, a && a.set(n, f), f;
+  }
+  function d(n) {
+    return n && n.__esModule ? n : { default: n };
+  }
+  var S = function(i) {
+    return new m.default(i);
+  };
+  Object.assign(S, h), delete S.__esModule;
+  var r = S;
+  t.default = r, s.exports = t.default;
+})(ot, Se);
+const pn = /* @__PURE__ */ st(Se), dn = /* @__PURE__ */ at({
+  __proto__: null,
+  default: pn
+}, [Se]);
+export {
+  dn as i
+};