@projectwallace/css-analyzer 5.15.0 → 6.0.0-beta.1

package/dist/analyze-css.js

@@ -0,0 +1,3636 @@
+import oi from "css-tree/parser";
+import pe from "css-tree/walker";
+let De = null;
+class H {
+  static createItem(e) {
+    return {
+      prev: null,
+      next: null,
+      data: e
+    };
+  }
+  constructor() {
+    this.head = null, this.tail = null, this.cursor = null;
+  }
+  createItem(e) {
+    return H.createItem(e);
+  }
+  // cursor helpers
+  allocateCursor(e, n) {
+    let r;
+    return De !== null ? (r = De, De = De.cursor, r.prev = e, r.next = n, r.cursor = this.cursor) : r = {
+      prev: e,
+      next: n,
+      cursor: this.cursor
+    }, this.cursor = r, r;
+  }
+  releaseCursor() {
+    const { cursor: e } = this;
+    this.cursor = e.cursor, e.prev = null, e.next = null, e.cursor = De, De = e;
+  }
+  updateCursors(e, n, r, i) {
+    let { cursor: o } = this;
+    for (; o !== null; )
+      o.prev === e && (o.prev = n), o.next === r && (o.next = i), o = o.cursor;
+  }
+  *[Symbol.iterator]() {
+    for (let e = this.head; e !== null; e = e.next)
+      yield e.data;
+  }
+  // getters
+  get size() {
+    let e = 0;
+    for (let n = this.head; n !== null; n = n.next)
+      e++;
+    return e;
+  }
+  get isEmpty() {
+    return this.head === null;
+  }
+  get first() {
+    return this.head && this.head.data;
+  }
+  get last() {
+    return this.tail && this.tail.data;
+  }
+  // convertors
+  fromArray(e) {
+    let n = null;
+    this.head = null;
+    for (let r of e) {
+      const i = H.createItem(r);
+      n !== null ? n.next = i : this.head = i, i.prev = n, n = i;
+    }
+    return this.tail = n, this;
+  }
+  toArray() {
+    return [...this];
+  }
+  toJSON() {
+    return [...this];
+  }
+  // array-like methods
+  forEach(e, n = this) {
+    const r = this.allocateCursor(null, this.head);
+    for (; r.next !== null; ) {
+      const i = r.next;
+      r.next = i.next, e.call(n, i.data, i, this);
+    }
+    this.releaseCursor();
+  }
+  forEachRight(e, n = this) {
+    const r = this.allocateCursor(this.tail, null);
+    for (; r.prev !== null; ) {
+      const i = r.prev;
+      r.prev = i.prev, e.call(n, i.data, i, this);
+    }
+    this.releaseCursor();
+  }
+  reduce(e, n, r = this) {
+    let i = this.allocateCursor(null, this.head), o = n, a;
+    for (; i.next !== null; )
+      a = i.next, i.next = a.next, o = e.call(r, o, a.data, a, this);
+    return this.releaseCursor(), o;
+  }
+  reduceRight(e, n, r = this) {
+    let i = this.allocateCursor(this.tail, null), o = n, a;
+    for (; i.prev !== null; )
+      a = i.prev, i.prev = a.prev, o = e.call(r, o, a.data, a, this);
+    return this.releaseCursor(), o;
+  }
+  some(e, n = this) {
+    for (let r = this.head; r !== null; r = r.next)
+      if (e.call(n, r.data, r, this))
+        return !0;
+    return !1;
+  }
+  map(e, n = this) {
+    const r = new H();
+    for (let i = this.head; i !== null; i = i.next)
+      r.appendData(e.call(n, i.data, i, this));
+    return r;
+  }
+  filter(e, n = this) {
+    const r = new H();
+    for (let i = this.head; i !== null; i = i.next)
+      e.call(n, i.data, i, this) && r.appendData(i.data);
+    return r;
+  }
+  nextUntil(e, n, r = this) {
+    if (e === null)
+      return;
+    const i = this.allocateCursor(null, e);
+    for (; i.next !== null; ) {
+      const o = i.next;
+      if (i.next = o.next, n.call(r, o.data, o, this))
+        break;
+    }
+    this.releaseCursor();
+  }
+  prevUntil(e, n, r = this) {
+    if (e === null)
+      return;
+    const i = this.allocateCursor(e, null);
+    for (; i.prev !== null; ) {
+      const o = i.prev;
+      if (i.prev = o.prev, n.call(r, o.data, o, this))
+        break;
+    }
+    this.releaseCursor();
+  }
+  // mutation
+  clear() {
+    this.head = null, this.tail = null;
+  }
+  copy() {
+    const e = new H();
+    for (let n of this)
+      e.appendData(n);
+    return e;
+  }
+  prepend(e) {
+    return this.updateCursors(null, e, this.head, e), this.head !== null ? (this.head.prev = e, e.next = this.head) : this.tail = e, this.head = e, this;
+  }
+  prependData(e) {
+    return this.prepend(H.createItem(e));
+  }
+  append(e) {
+    return this.insert(e);
+  }
+  appendData(e) {
+    return this.insert(H.createItem(e));
+  }
+  insert(e, n = null) {
+    if (n !== null)
+      if (this.updateCursors(n.prev, e, n, e), n.prev === null) {
+        if (this.head !== n)
+          throw new Error("before doesn't belong to list");
+        this.head = e, n.prev = e, e.next = n, this.updateCursors(null, e);
+      } else
+        n.prev.next = e, e.prev = n.prev, n.prev = e, e.next = n;
+    else
+      this.updateCursors(this.tail, e, null, e), this.tail !== null ? (this.tail.next = e, e.prev = this.tail) : this.head = e, this.tail = e;
+    return this;
+  }
+  insertData(e, n) {
+    return this.insert(H.createItem(e), n);
+  }
+  remove(e) {
+    if (this.updateCursors(e, e.prev, e, e.next), e.prev !== null)
+      e.prev.next = e.next;
+    else {
+      if (this.head !== e)
+        throw new Error("item doesn't belong to list");
+      this.head = e.next;
+    }
+    if (e.next !== null)
+      e.next.prev = e.prev;
+    else {
+      if (this.tail !== e)
+        throw new Error("item doesn't belong to list");
+      this.tail = e.prev;
+    }
+    return e.prev = null, e.next = null, e;
+  }
+  push(e) {
+    this.insert(H.createItem(e));
+  }
+  pop() {
+    return this.tail !== null ? this.remove(this.tail) : null;
+  }
+  unshift(e) {
+    this.prepend(H.createItem(e));
+  }
+  shift() {
+    return this.head !== null ? this.remove(this.head) : null;
+  }
+  prependList(e) {
+    return this.insertList(e, this.head);
+  }
+  appendList(e) {
+    return this.insertList(e);
+  }
+  insertList(e, n) {
+    return e.head === null ? this : (n != null ? (this.updateCursors(n.prev, e.tail, n, e.head), n.prev !== null ? (n.prev.next = e.head, e.head.prev = n.prev) : this.head = e.head, n.prev = e.tail, e.tail.next = n) : (this.updateCursors(this.tail, e.tail, null, e.head), this.tail !== null ? (this.tail.next = e.head, e.head.prev = this.tail) : this.head = e.head, this.tail = e.tail), e.head = null, e.tail = null, this);
+  }
+  replace(e, n) {
+    "head" in n ? this.insertList(n, e) : this.insert(n, e), this.remove(e);
+  }
+}
+function ai(t, e) {
+  const n = Object.create(SyntaxError.prototype), r = new Error();
+  return Object.assign(n, {
+    name: t,
+    message: e,
+    get stack() {
+      return (r.stack || "").replace(/^(.+\n){1,3}/, `${t}: ${e}
+`);
+    }
+  });
+}
+const Gt = 100, nr = 60, rr = "    ";
+function ir({ source: t, line: e, column: n, baseLine: r, baseColumn: i }, o) {
+  function a(_, q) {
+    return s.slice(_, q).map(
+      (V, me) => String(_ + me + 1).padStart(y) + " |" + V
+    ).join(`
+`);
+  }
+  const f = `
+`.repeat(Math.max(r - 1, 0)), c = " ".repeat(Math.max(i - 1, 0)), s = (f + c + t).split(/\r\n?|\n|\f/), l = Math.max(1, e - o) - 1, m = Math.min(e + o, s.length + 1), y = Math.max(4, String(m).length) + 1;
+  let C = 0;
+  n += (rr.length - 1) * (s[e - 1].substr(0, n - 1).match(/\t/g) || []).length, n > Gt && (C = n - nr + 3, n = nr - 2);
+  for (let _ = l; _ <= m; _++)
+    _ >= 0 && _ < s.length && (s[_] = s[_].replace(/\t/g, rr), s[_] = (C > 0 && s[_].length > C ? "…" : "") + s[_].substr(C, Gt - 2) + (s[_].length > C + Gt - 1 ? "…" : ""));
+  return [
+    a(l, e),
+    new Array(n + y + 2).join("-") + "^",
+    a(e, m)
+  ].filter(Boolean).join(`
+`).replace(/^(\s+\d+\s+\|\n)+/, "").replace(/\n(\s+\d+\s+\|)+$/, "");
+}
+function sr(t, e, n, r, i, o = 1, a = 1) {
+  return Object.assign(ai("SyntaxError", t), {
+    source: e,
+    offset: n,
+    line: r,
+    column: i,
+    sourceFragment(c) {
+      return ir({ source: e, line: r, column: i, baseLine: o, baseColumn: a }, isNaN(c) ? 0 : c);
+    },
+    get formattedMessage() {
+      return `Parse error: ${t}
+` + ir({ source: e, line: r, column: i, baseLine: o, baseColumn: a }, 2);
+    }
+  });
+}
+const He = 0, k = 1, N = 2, U = 3, z = 4, Re = 5, li = 6, se = 7, oe = 8, $ = 9, E = 10, M = 11, I = 12, J = 13, Er = 14, ae = 15, ee = 16, Ct = 17, qe = 18, bt = 19, mt = 20, te = 21, O = 22, dn = 23, mn = 24, fe = 25, ci = 0;
+function Q(t) {
+  return t >= 48 && t <= 57;
+}
+function Ke(t) {
+  return Q(t) || // 0 .. 9
+  t >= 65 && t <= 70 || // A .. F
+  t >= 97 && t <= 102;
+}
+function gn(t) {
+  return t >= 65 && t <= 90;
+}
+function ui(t) {
+  return t >= 97 && t <= 122;
+}
+function hi(t) {
+  return gn(t) || ui(t);
+}
+function fi(t) {
+  return t >= 128;
+}
+function gt(t) {
+  return hi(t) || fi(t) || t === 95;
+}
+function _r(t) {
+  return gt(t) || Q(t) || t === 45;
+}
+function pi(t) {
+  return t >= 0 && t <= 8 || t === 11 || t >= 14 && t <= 31 || t === 127;
+}
+function kt(t) {
+  return t === 10 || t === 13 || t === 12;
+}
+function Ye(t) {
+  return kt(t) || t === 32 || t === 9;
+}
+function ye(t, e) {
+  return !(t !== 92 || kt(e) || e === ci);
+}
+function Ht(t, e, n) {
+  return t === 45 ? gt(e) || e === 45 || ye(e, n) : gt(t) ? !0 : t === 92 ? ye(t, e) : !1;
+}
+function Wt(t, e, n) {
+  return t === 43 || t === 45 ? Q(e) ? 2 : e === 46 && Q(n) ? 3 : 0 : t === 46 ? Q(e) ? 2 : 0 : Q(t) ? 1 : 0;
+}
+function Tr(t) {
+  return t === 65279 || t === 65534 ? 1 : 0;
+}
+const an = new Array(128), di = 128, ht = 130, Or = 131, kn = 132, Ir = 133;
+for (let t = 0; t < an.length; t++)
+  an[t] = Ye(t) && ht || Q(t) && Or || gt(t) && kn || pi(t) && Ir || t || di;
+function Kt(t) {
+  return t < 128 ? an[t] : kn;
+}
+function Fe(t, e) {
+  return e < t.length ? t.charCodeAt(e) : 0;
+}
+function ln(t, e, n) {
+  return n === 13 && Fe(t, e + 1) === 10 ? 2 : 1;
+}
+function $r(t, e, n) {
+  let r = t.charCodeAt(e);
+  return gn(r) && (r = r | 32), r === n;
+}
+function yt(t, e, n, r) {
+  if (n - e !== r.length || e < 0 || n > t.length)
+    return !1;
+  for (let i = e; i < n; i++) {
+    const o = r.charCodeAt(i - e);
+    let a = t.charCodeAt(i);
+    if (gn(a) && (a = a | 32), a !== o)
+      return !1;
+  }
+  return !0;
+}
+function mi(t, e) {
+  for (; e >= 0 && Ye(t.charCodeAt(e)); e--)
+    ;
+  return e + 1;
+}
+function at(t, e) {
+  for (; e < t.length && Ye(t.charCodeAt(e)); e++)
+    ;
+  return e;
+}
+function Qt(t, e) {
+  for (; e < t.length && Q(t.charCodeAt(e)); e++)
+    ;
+  return e;
+}
+function Qe(t, e) {
+  if (e += 2, Ke(Fe(t, e - 1))) {
+    for (const r = Math.min(t.length, e + 5); e < r && Ke(Fe(t, e)); e++)
+      ;
+    const n = Fe(t, e);
+    Ye(n) && (e += ln(t, e, n));
+  }
+  return e;
+}
+function lt(t, e) {
+  for (; e < t.length; e++) {
+    const n = t.charCodeAt(e);
+    if (!_r(n)) {
+      if (ye(n, Fe(t, e + 1))) {
+        e = Qe(t, e) - 1;
+        continue;
+      }
+      break;
+    }
+  }
+  return e;
+}
+function Nr(t, e) {
+  let n = t.charCodeAt(e);
+  if ((n === 43 || n === 45) && (n = t.charCodeAt(e += 1)), Q(n) && (e = Qt(t, e + 1), n = t.charCodeAt(e)), n === 46 && Q(t.charCodeAt(e + 1)) && (e += 2, e = Qt(t, e)), $r(
+    t,
+    e,
+    101
+    /* e */
+  )) {
+    let r = 0;
+    n = t.charCodeAt(e + 1), (n === 45 || n === 43) && (r = 1, n = t.charCodeAt(e + 2)), Q(n) && (e = Qt(t, e + 1 + r + 1));
+  }
+  return e;
+}
+function Jt(t, e) {
+  for (; e < t.length; e++) {
+    const n = t.charCodeAt(e);
+    if (n === 41) {
+      e++;
+      break;
+    }
+    ye(n, Fe(t, e + 1)) && (e = Qe(t, e));
+  }
+  return e;
+}
+function gi(t) {
+  if (t.length === 1 && !Ke(t.charCodeAt(0)))
+    return t[0];
+  let e = parseInt(t, 16);
+  return (e === 0 || // If this number is zero,
+  e >= 55296 && e <= 57343 || // or is for a surrogate,
+  e > 1114111) && (e = 65533), String.fromCodePoint(e);
+}
+const Dr = [
+  "EOF-token",
+  "ident-token",
+  "function-token",
+  "at-keyword-token",
+  "hash-token",
+  "string-token",
+  "bad-string-token",
+  "url-token",
+  "bad-url-token",
+  "delim-token",
+  "number-token",
+  "percentage-token",
+  "dimension-token",
+  "whitespace-token",
+  "CDO-token",
+  "CDC-token",
+  "colon-token",
+  "semicolon-token",
+  "comma-token",
+  "[-token",
+  "]-token",
+  "(-token",
+  ")-token",
+  "{-token",
+  "}-token",
+  "comment-token"
+], ki = 16 * 1024;
+function St(t = null, e) {
+  return t === null || t.length < e ? new Uint32Array(Math.max(e + 1024, ki)) : t;
+}
+const or = 10, yi = 12, ar = 13;
+function lr(t) {
+  const e = t.source, n = e.length, r = e.length > 0 ? Tr(e.charCodeAt(0)) : 0, i = St(t.lines, n), o = St(t.columns, n);
+  let a = t.startLine, f = t.startColumn;
+  for (let c = r; c < n; c++) {
+    const s = e.charCodeAt(c);
+    i[c] = a, o[c] = f++, (s === or || s === ar || s === yi) && (s === ar && c + 1 < n && e.charCodeAt(c + 1) === or && (c++, i[c] = a, o[c] = f), a++, f = 1);
+  }
+  i[n] = a, o[n] = f, t.lines = i, t.columns = o, t.computed = !0;
+}
+class Si {
+  constructor(e, n, r, i) {
+    this.setSource(e, n, r, i), this.lines = null, this.columns = null;
+  }
+  setSource(e = "", n = 0, r = 1, i = 1) {
+    this.source = e, this.startOffset = n, this.startLine = r, this.startColumn = i, this.computed = !1;
+  }
+  getLocation(e, n) {
+    return this.computed || lr(this), {
+      source: n,
+      offset: this.startOffset + e,
+      line: this.lines[e],
+      column: this.columns[e]
+    };
+  }
+  getLocationRange(e, n, r) {
+    return this.computed || lr(this), {
+      source: r,
+      start: {
+        offset: this.startOffset + e,
+        line: this.lines[e],
+        column: this.columns[e]
+      },
+      end: {
+        offset: this.startOffset + n,
+        line: this.lines[n],
+        column: this.columns[n]
+      }
+    };
+  }
+}
+const ce = 16777215, ue = 24, Te = new Uint8Array(32);
+Te[N] = O;
+Te[te] = O;
+Te[bt] = mt;
+Te[dn] = mn;
+function cr(t) {
+  return Te[t] !== 0;
+}
+class xi {
+  constructor(e, n) {
+    this.setSource(e, n);
+  }
+  reset() {
+    this.eof = !1, this.tokenIndex = -1, this.tokenType = 0, this.tokenStart = this.firstCharOffset, this.tokenEnd = this.firstCharOffset;
+  }
+  setSource(e = "", n = () => {
+  }) {
+    e = String(e || "");
+    const r = e.length, i = St(this.offsetAndType, e.length + 1), o = St(this.balance, e.length + 1);
+    let a = 0, f = -1, c = 0, s = e.length;
+    this.offsetAndType = null, this.balance = null, o.fill(0), n(e, (l, m, y) => {
+      const C = a++;
+      if (i[C] = l << ue | y, f === -1 && (f = m), o[C] = s, l === c) {
+        const _ = o[s];
+        o[s] = C, s = _, c = Te[i[_] >> ue];
+      } else cr(l) && (s = C, c = Te[l]);
+    }), i[a] = He << ue | r, o[a] = a;
+    for (let l = 0; l < a; l++) {
+      const m = o[l];
+      if (m <= l) {
+        const y = o[m];
+        y !== l && (o[l] = y);
+      } else m > a && (o[l] = a);
+    }
+    this.source = e, this.firstCharOffset = f === -1 ? 0 : f, this.tokenCount = a, this.offsetAndType = i, this.balance = o, this.reset(), this.next();
+  }
+  lookupType(e) {
+    return e += this.tokenIndex, e < this.tokenCount ? this.offsetAndType[e] >> ue : He;
+  }
+  lookupTypeNonSC(e) {
+    for (let n = this.tokenIndex; n < this.tokenCount; n++) {
+      const r = this.offsetAndType[n] >> ue;
+      if (r !== J && r !== fe && e-- === 0)
+        return r;
+    }
+    return He;
+  }
+  lookupOffset(e) {
+    return e += this.tokenIndex, e < this.tokenCount ? this.offsetAndType[e - 1] & ce : this.source.length;
+  }
+  lookupOffsetNonSC(e) {
+    for (let n = this.tokenIndex; n < this.tokenCount; n++) {
+      const r = this.offsetAndType[n] >> ue;
+      if (r !== J && r !== fe && e-- === 0)
+        return n - this.tokenIndex;
+    }
+    return He;
+  }
+  lookupValue(e, n) {
+    return e += this.tokenIndex, e < this.tokenCount ? yt(
+      this.source,
+      this.offsetAndType[e - 1] & ce,
+      this.offsetAndType[e] & ce,
+      n
+    ) : !1;
+  }
+  getTokenStart(e) {
+    return e === this.tokenIndex ? this.tokenStart : e > 0 ? e < this.tokenCount ? this.offsetAndType[e - 1] & ce : this.offsetAndType[this.tokenCount] & ce : this.firstCharOffset;
+  }
+  substrToCursor(e) {
+    return this.source.substring(e, this.tokenStart);
+  }
+  isBalanceEdge(e) {
+    return this.balance[this.tokenIndex] < e;
+  }
+  isDelim(e, n) {
+    return n ? this.lookupType(n) === $ && this.source.charCodeAt(this.lookupOffset(n)) === e : this.tokenType === $ && this.source.charCodeAt(this.tokenStart) === e;
+  }
+  skip(e) {
+    let n = this.tokenIndex + e;
+    n < this.tokenCount ? (this.tokenIndex = n, this.tokenStart = this.offsetAndType[n - 1] & ce, n = this.offsetAndType[n], this.tokenType = n >> ue, this.tokenEnd = n & ce) : (this.tokenIndex = this.tokenCount, this.next());
+  }
+  next() {
+    let e = this.tokenIndex + 1;
+    e < this.tokenCount ? (this.tokenIndex = e, this.tokenStart = this.tokenEnd, e = this.offsetAndType[e], this.tokenType = e >> ue, this.tokenEnd = e & ce) : (this.eof = !0, this.tokenIndex = this.tokenCount, this.tokenType = He, this.tokenStart = this.tokenEnd = this.source.length);
+  }
+  skipSC() {
+    for (; this.tokenType === J || this.tokenType === fe; )
+      this.next();
+  }
+  skipUntilBalanced(e, n) {
+    let r = e, i = 0, o = 0;
+    e:
+      for (; r < this.tokenCount; r++) {
+        if (i = this.balance[r], i < e)
+          break e;
+        switch (o = r > 0 ? this.offsetAndType[r - 1] & ce : this.firstCharOffset, n(this.source.charCodeAt(o))) {
+          case 1:
+            break e;
+          case 2:
+            r++;
+            break e;
+          default:
+            cr(this.offsetAndType[r] >> ue) && (r = i);
+        }
+      }
+    this.skip(r - this.tokenIndex);
+  }
+  forEachToken(e) {
+    for (let n = 0, r = this.firstCharOffset; n < this.tokenCount; n++) {
+      const i = r, o = this.offsetAndType[n], a = o & ce, f = o >> ue;
+      r = a, e(f, i, a, n);
+    }
+  }
+  dump() {
+    const e = new Array(this.tokenCount);
+    return this.forEachToken((n, r, i, o) => {
+      e[o] = {
+        idx: o,
+        type: Dr[n],
+        chunk: this.source.substring(r, i),
+        balance: this.balance[o]
+      };
+    }), e;
+  }
+}
+function Pr(t, e) {
+  function n(m) {
+    return m < f ? t.charCodeAt(m) : 0;
+  }
+  function r() {
+    if (s = Nr(t, s), Ht(n(s), n(s + 1), n(s + 2))) {
+      l = I, s = lt(t, s);
+      return;
+    }
+    if (n(s) === 37) {
+      l = M, s++;
+      return;
+    }
+    l = E;
+  }
+  function i() {
+    const m = s;
+    if (s = lt(t, s), yt(t, m, s, "url") && n(s) === 40) {
+      if (s = at(t, s + 1), n(s) === 34 || n(s) === 39) {
+        l = N, s = m + 4;
+        return;
+      }
+      a();
+      return;
+    }
+    if (n(s) === 40) {
+      l = N, s++;
+      return;
+    }
+    l = k;
+  }
+  function o(m) {
+    for (m || (m = n(s++)), l = Re; s < t.length; s++) {
+      const y = t.charCodeAt(s);
+      switch (Kt(y)) {
+        case m:
+          s++;
+          return;
+        case ht:
+          if (kt(y)) {
+            s += ln(t, s, y), l = li;
+            return;
+          }
+          break;
+        case 92:
+          if (s === t.length - 1)
+            break;
+          const C = n(s + 1);
+          kt(C) ? s += ln(t, s + 1, C) : ye(y, C) && (s = Qe(t, s) - 1);
+          break;
+      }
+    }
+  }
+  function a() {
+    for (l = se, s = at(t, s); s < t.length; s++) {
+      const m = t.charCodeAt(s);
+      switch (Kt(m)) {
+        case 41:
+          s++;
+          return;
+        case ht:
+          if (s = at(t, s), n(s) === 41 || s >= t.length) {
+            s < t.length && s++;
+            return;
+          }
+          s = Jt(t, s), l = oe;
+          return;
+        case 34:
+        case 39:
+        case 40:
+        case Ir:
+          s = Jt(t, s), l = oe;
+          return;
+        case 92:
+          if (ye(m, n(s + 1))) {
+            s = Qe(t, s) - 1;
+            break;
+          }
+          s = Jt(t, s), l = oe;
+          return;
+      }
+    }
+  }
+  t = String(t || "");
+  const f = t.length;
+  let c = Tr(n(0)), s = c, l;
+  for (; s < f; ) {
+    const m = t.charCodeAt(s);
+    switch (Kt(m)) {
+      case ht:
+        l = J, s = at(t, s + 1);
+        break;
+      case 34:
+        o();
+        break;
+      case 35:
+        _r(n(s + 1)) || ye(n(s + 1), n(s + 2)) ? (l = z, s = lt(t, s + 1)) : (l = $, s++);
+        break;
+      case 39:
+        o();
+        break;
+      case 40:
+        l = te, s++;
+        break;
+      case 41:
+        l = O, s++;
+        break;
+      case 43:
+        Wt(m, n(s + 1), n(s + 2)) ? r() : (l = $, s++);
+        break;
+      case 44:
+        l = qe, s++;
+        break;
+      case 45:
+        Wt(m, n(s + 1), n(s + 2)) ? r() : n(s + 1) === 45 && n(s + 2) === 62 ? (l = ae, s = s + 3) : Ht(m, n(s + 1), n(s + 2)) ? i() : (l = $, s++);
+        break;
+      case 46:
+        Wt(m, n(s + 1), n(s + 2)) ? r() : (l = $, s++);
+        break;
+      case 47:
+        n(s + 1) === 42 ? (l = fe, s = t.indexOf("*/", s + 2), s = s === -1 ? t.length : s + 2) : (l = $, s++);
+        break;
+      case 58:
+        l = ee, s++;
+        break;
+      case 59:
+        l = Ct, s++;
+        break;
+      case 60:
+        n(s + 1) === 33 && n(s + 2) === 45 && n(s + 3) === 45 ? (l = Er, s = s + 4) : (l = $, s++);
+        break;
+      case 64:
+        Ht(n(s + 1), n(s + 2), n(s + 3)) ? (l = U, s = lt(t, s + 1)) : (l = $, s++);
+        break;
+      case 91:
+        l = bt, s++;
+        break;
+      case 92:
+        ye(m, n(s + 1)) ? i() : (l = $, s++);
+        break;
+      case 93:
+        l = mt, s++;
+        break;
+      case 123:
+        l = dn, s++;
+        break;
+      case 125:
+        l = mn, s++;
+        break;
+      case Or:
+        r();
+        break;
+      case kn:
+        i();
+        break;
+      default:
+        l = $, s++;
+    }
+    e(l, c, c = s);
+  }
+}
+function Ci(t) {
+  const e = this.createList();
+  let n = !1;
+  const r = {
+    recognizer: t
+  };
+  for (; !this.eof; ) {
+    switch (this.tokenType) {
+      case fe:
+        this.next();
+        continue;
+      case J:
+        n = !0, this.next();
+        continue;
+    }
+    let i = t.getNode.call(this, r);
+    if (i === void 0)
+      break;
+    n && (t.onWhiteSpace && t.onWhiteSpace.call(this, i, e, r), n = !1), e.push(i);
+  }
+  return n && t.onWhiteSpace && t.onWhiteSpace.call(this, null, e, r), e;
+}
+const ur = () => {
+}, bi = 33, wi = 35, Yt = 59, hr = 123, fr = 0;
+function vi(t) {
+  return function() {
+    return this[t]();
+  };
+}
+function Xt(t) {
+  const e = /* @__PURE__ */ Object.create(null);
+  for (const n of Object.keys(t)) {
+    const r = t[n], i = r.parse || r;
+    i && (e[n] = i);
+  }
+  return e;
+}
+function Ai(t) {
+  const e = {
+    context: /* @__PURE__ */ Object.create(null),
+    features: Object.assign(/* @__PURE__ */ Object.create(null), t.features),
+    scope: Object.assign(/* @__PURE__ */ Object.create(null), t.scope),
+    atrule: Xt(t.atrule),
+    pseudo: Xt(t.pseudo),
+    node: Xt(t.node)
+  };
+  for (const [n, r] of Object.entries(t.parseContext))
+    switch (typeof r) {
+      case "function":
+        e.context[n] = r;
+        break;
+      case "string":
+        e.context[n] = vi(r);
+        break;
+    }
+  return {
+    config: e,
+    ...e,
+    ...e.node
+  };
+}
+function Li(t) {
+  let e = "", n = "<unknown>", r = !1, i = ur, o = !1;
+  const a = new Si(), f = Object.assign(new xi(), Ai(t || {}), {
+    parseAtrulePrelude: !0,
+    parseRulePrelude: !0,
+    parseValue: !0,
+    parseCustomProperty: !1,
+    readSequence: Ci,
+    consumeUntilBalanceEnd: () => 0,
+    consumeUntilLeftCurlyBracket(s) {
+      return s === hr ? 1 : 0;
+    },
+    consumeUntilLeftCurlyBracketOrSemicolon(s) {
+      return s === hr || s === Yt ? 1 : 0;
+    },
+    consumeUntilExclamationMarkOrSemicolon(s) {
+      return s === bi || s === Yt ? 1 : 0;
+    },
+    consumeUntilSemicolonIncluded(s) {
+      return s === Yt ? 2 : 0;
+    },
+    createList() {
+      return new H();
+    },
+    createSingleNodeList(s) {
+      return new H().appendData(s);
+    },
+    getFirstListNode(s) {
+      return s && s.first;
+    },
+    getLastListNode(s) {
+      return s && s.last;
+    },
+    parseWithFallback(s, l) {
+      const m = this.tokenIndex;
+      try {
+        return s.call(this);
+      } catch (y) {
+        if (o)
+          throw y;
+        this.skip(m - this.tokenIndex);
+        const C = l.call(this);
+        return o = !0, i(y, C), o = !1, C;
+      }
+    },
+    lookupNonWSType(s) {
+      let l;
+      do
+        if (l = this.lookupType(s++), l !== J && l !== fe)
+          return l;
+      while (l !== fr);
+      return fr;
+    },
+    charCodeAt(s) {
+      return s >= 0 && s < e.length ? e.charCodeAt(s) : 0;
+    },
+    substring(s, l) {
+      return e.substring(s, l);
+    },
+    substrToCursor(s) {
+      return this.source.substring(s, this.tokenStart);
+    },
+    cmpChar(s, l) {
+      return $r(e, s, l);
+    },
+    cmpStr(s, l, m) {
+      return yt(e, s, l, m);
+    },
+    consume(s) {
+      const l = this.tokenStart;
+      return this.eat(s), this.substrToCursor(l);
+    },
+    consumeFunctionName() {
+      const s = e.substring(this.tokenStart, this.tokenEnd - 1);
+      return this.eat(N), s;
+    },
+    consumeNumber(s) {
+      const l = e.substring(this.tokenStart, Nr(e, this.tokenStart));
+      return this.eat(s), l;
+    },
+    eat(s) {
+      if (this.tokenType !== s) {
+        const l = Dr[s].slice(0, -6).replace(/-/g, " ").replace(/^./, (C) => C.toUpperCase());
+        let m = `${/[[\](){}]/.test(l) ? `"${l}"` : l} is expected`, y = this.tokenStart;
+        switch (s) {
+          case k:
+            this.tokenType === N || this.tokenType === se ? (y = this.tokenEnd - 1, m = "Identifier is expected but function found") : m = "Identifier is expected";
+            break;
+          case z:
+            this.isDelim(wi) && (this.next(), y++, m = "Name is expected");
+            break;
+          case M:
+            this.tokenType === E && (y = this.tokenEnd, m = "Percent sign is expected");
+            break;
+        }
+        this.error(m, y);
+      }
+      this.next();
+    },
+    eatIdent(s) {
+      (this.tokenType !== k || this.lookupValue(0, s) === !1) && this.error(`Identifier "${s}" is expected`), this.next();
+    },
+    eatDelim(s) {
+      this.isDelim(s) || this.error(`Delim "${String.fromCharCode(s)}" is expected`), this.next();
+    },
+    getLocation(s, l) {
+      return r ? a.getLocationRange(
+        s,
+        l,
+        n
+      ) : null;
+    },
+    getLocationFromList(s) {
+      if (r) {
+        const l = this.getFirstListNode(s), m = this.getLastListNode(s);
+        return a.getLocationRange(
+          l !== null ? l.loc.start.offset - a.startOffset : this.tokenStart,
+          m !== null ? m.loc.end.offset - a.startOffset : this.tokenStart,
+          n
+        );
+      }
+      return null;
+    },
+    error(s, l) {
+      const m = typeof l < "u" && l < e.length ? a.getLocation(l) : this.eof ? a.getLocation(mi(e, e.length - 1)) : a.getLocation(this.tokenStart);
+      throw new sr(
+        s || "Unexpected input",
+        e,
+        m.offset,
+        m.line,
+        m.column,
+        a.startLine,
+        a.startColumn
+      );
+    }
+  });
+  return Object.assign(function(s, l) {
+    e = s, l = l || {}, f.setSource(e, Pr), a.setSource(
+      e,
+      l.offset,
+      l.line,
+      l.column
+    ), n = l.filename || "<unknown>", r = !!l.positions, i = typeof l.onParseError == "function" ? l.onParseError : ur, o = !1, f.parseAtrulePrelude = "parseAtrulePrelude" in l ? !!l.parseAtrulePrelude : !0, f.parseRulePrelude = "parseRulePrelude" in l ? !!l.parseRulePrelude : !0, f.parseValue = "parseValue" in l ? !!l.parseValue : !0, f.parseCustomProperty = "parseCustomProperty" in l ? !!l.parseCustomProperty : !1;
+    const { context: m = "default", onComment: y } = l;
+    if (!(m in f.context))
+      throw new Error("Unknown context `" + m + "`");
+    typeof y == "function" && f.forEachToken((_, q, V) => {
+      if (_ === fe) {
+        const me = f.getLocation(q, V), Oe = yt(e, V - 2, V, "*/") ? e.slice(q + 2, V - 2) : e.slice(q + 2, V);
+        y(Oe, me);
+      }
+    });
+    const C = f.context[m].call(f, l);
+    return f.eof || f.error(), C;
+  }, {
+    SyntaxError: sr,
+    config: f.config
+  });
+}
+const Ei = 35, _i = 38, Ti = 42, Oi = 43, Ii = 47, pr = 46, $i = 62, Ni = 124, Di = 126;
+function Pi(t, e) {
+  e.last !== null && e.last.type !== "Combinator" && t !== null && t.type !== "Combinator" && e.push({
+    // FIXME: this.Combinator() should be used instead
+    type: "Combinator",
+    loc: null,
+    name: " "
+  });
+}
+function Mi() {
+  switch (this.tokenType) {
+    case bt:
+      return this.AttributeSelector();
+    case z:
+      return this.IdSelector();
+    case ee:
+      return this.lookupType(1) === ee ? this.PseudoElementSelector() : this.PseudoClassSelector();
+    case k:
+      return this.TypeSelector();
+    case E:
+    case M:
+      return this.Percentage();
+    case I:
+      this.charCodeAt(this.tokenStart) === pr && this.error("Identifier is expected", this.tokenStart + 1);
+      break;
+    case $: {
+      switch (this.charCodeAt(this.tokenStart)) {
+        case Oi:
+        case $i:
+        case Di:
+        case Ii:
+          return this.Combinator();
+        case pr:
+          return this.ClassSelector();
+        case Ti:
+        case Ni:
+          return this.TypeSelector();
+        case Ei:
+          return this.IdSelector();
+        case _i:
+          return this.NestingSelector();
+      }
+      break;
+    }
+  }
+}
+const Fi = {
+  onWhiteSpace: Pi,
+  getNode: Mi
+};
+function zi() {
+  const t = this.createList();
+  this.skipSC();
+  e: for (; !this.eof; ) {
+    switch (this.tokenType) {
+      case k:
+        t.push(this.Identifier());
+        break;
+      case Re:
+        t.push(this.String());
+        break;
+      case qe:
+        t.push(this.Operator());
+        break;
+      case O:
+        break e;
+      default:
+        this.error("Identifier, string or comma is expected");
+    }
+    this.skipSC();
+  }
+  return t;
+}
+const Le = {
+  parse() {
+    return this.createSingleNodeList(
+      this.SelectorList()
+    );
+  }
+}, Zt = {
+  parse() {
+    return this.createSingleNodeList(
+      this.Selector()
+    );
+  }
+}, Ri = {
+  parse() {
+    return this.createSingleNodeList(
+      this.Identifier()
+    );
+  }
+}, qi = {
+  parse: zi
+}, ct = {
+  parse() {
+    return this.createSingleNodeList(
+      this.Nth()
+    );
+  }
+}, Bi = {
+  dir: Ri,
+  has: Le,
+  lang: qi,
+  matches: Le,
+  is: Le,
+  "-moz-any": Le,
+  "-webkit-any": Le,
+  where: Le,
+  not: Le,
+  "nth-child": ct,
+  "nth-last-child": ct,
+  "nth-last-of-type": ct,
+  "nth-of-type": ct,
+  slotted: Zt,
+  host: Zt,
+  "host-context": Zt
+}, he = 43, K = 45, ft = 110, Ee = !0, ji = !1;
+function pt(t, e) {
+  let n = this.tokenStart + t;
+  const r = this.charCodeAt(n);
+  for ((r === he || r === K) && (e && this.error("Number sign is not allowed"), n++); n < this.tokenEnd; n++)
+    Q(this.charCodeAt(n)) || this.error("Integer is expected", n);
+}
+function Pe(t) {
+  return pt.call(this, 0, t);
+}
+function be(t, e) {
+  if (!this.cmpChar(this.tokenStart + t, e)) {
+    let n = "";
+    switch (e) {
+      case ft:
+        n = "N is expected";
+        break;
+      case K:
+        n = "HyphenMinus is expected";
+        break;
+    }
+    this.error(n, this.tokenStart + t);
+  }
+}
+function en() {
+  let t = 0, e = 0, n = this.tokenType;
+  for (; n === J || n === fe; )
+    n = this.lookupType(++t);
+  if (n !== E)
+    if (this.isDelim(he, t) || this.isDelim(K, t)) {
+      e = this.isDelim(he, t) ? he : K;
+      do
+        n = this.lookupType(++t);
+      while (n === J || n === fe);
+      n !== E && (this.skip(t), Pe.call(this, Ee));
+    } else
+      return null;
+  return t > 0 && this.skip(t), e === 0 && (n = this.charCodeAt(this.tokenStart), n !== he && n !== K && this.error("Number sign is expected")), Pe.call(this, e !== 0), e === K ? "-" + this.consume(E) : this.consume(E);
+}
+function Ui() {
+  const t = this.tokenStart;
+  let e = null, n = null;
+  if (this.tokenType === E)
+    Pe.call(this, ji), n = this.consume(E);
+  else if (this.tokenType === k && this.cmpChar(this.tokenStart, K))
+    switch (e = "-1", be.call(this, 1, ft), this.tokenEnd - this.tokenStart) {
+      case 2:
+        this.next(), n = en.call(this);
+        break;
+      case 3:
+        be.call(this, 2, K), this.next(), this.skipSC(), Pe.call(this, Ee), n = "-" + this.consume(E);
+        break;
+      default:
+        be.call(this, 2, K), pt.call(this, 3, Ee), this.next(), n = this.substrToCursor(t + 2);
+    }
+  else if (this.tokenType === k || this.isDelim(he) && this.lookupType(1) === k) {
+    let r = 0;
+    switch (e = "1", this.isDelim(he) && (r = 1, this.next()), be.call(this, 0, ft), this.tokenEnd - this.tokenStart) {
+      case 1:
+        this.next(), n = en.call(this);
+        break;
+      case 2:
+        be.call(this, 1, K), this.next(), this.skipSC(), Pe.call(this, Ee), n = "-" + this.consume(E);
+        break;
+      default:
+        be.call(this, 1, K), pt.call(this, 2, Ee), this.next(), n = this.substrToCursor(t + r + 1);
+    }
+  } else if (this.tokenType === I) {
+    const r = this.charCodeAt(this.tokenStart), i = r === he || r === K;
+    let o = this.tokenStart + i;
+    for (; o < this.tokenEnd && Q(this.charCodeAt(o)); o++)
+      ;
+    o === this.tokenStart + i && this.error("Integer is expected", this.tokenStart + i), be.call(this, o - this.tokenStart, ft), e = this.substring(t, o), o + 1 === this.tokenEnd ? (this.next(), n = en.call(this)) : (be.call(this, o - this.tokenStart + 1, K), o + 2 === this.tokenEnd ? (this.next(), this.skipSC(), Pe.call(this, Ee), n = "-" + this.consume(E)) : (pt.call(this, o - this.tokenStart + 2, Ee), this.next(), n = this.substrToCursor(o + 1)));
+  } else
+    this.error();
+  return e !== null && e.charCodeAt(0) === he && (e = e.substr(1)), n !== null && n.charCodeAt(0) === he && (n = n.substr(1)), {
+    type: "AnPlusB",
+    loc: this.getLocation(t, this.tokenStart),
+    a: e,
+    b: n
+  };
+}
+function Vi(t) {
+  if (t.a) {
+    const e = t.a === "+1" && "n" || t.a === "1" && "n" || t.a === "-1" && "-n" || t.a + "n";
+    if (t.b) {
+      const n = t.b[0] === "-" || t.b[0] === "+" ? t.b : "+" + t.b;
+      this.tokenize(e + n);
+    } else
+      this.tokenize(e);
+  } else
+    this.tokenize(t.b);
+}
+const Gi = 36, Mr = 42, dt = 61, Hi = 94, cn = 124, Wi = 126;
+function Ki() {
+  this.eof && this.error("Unexpected end of input");
+  const t = this.tokenStart;
+  let e = !1;
+  return this.isDelim(Mr) ? (e = !0, this.next()) : this.isDelim(cn) || this.eat(k), this.isDelim(cn) ? this.charCodeAt(this.tokenStart + 1) !== dt ? (this.next(), this.eat(k)) : e && this.error("Identifier is expected", this.tokenEnd) : e && this.error("Vertical line is expected"), {
+    type: "Identifier",
+    loc: this.getLocation(t, this.tokenStart),
+    name: this.substrToCursor(t)
+  };
+}
+function Qi() {
+  const t = this.tokenStart, e = this.charCodeAt(t);
+  return e !== dt && // =
+  e !== Wi && // ~=
+  e !== Hi && // ^=
+  e !== Gi && // $=
+  e !== Mr && // *=
+  e !== cn && this.error("Attribute selector (=, ~=, ^=, $=, *=, |=) is expected"), this.next(), e !== dt && (this.isDelim(dt) || this.error("Equal sign is expected"), this.next()), this.substrToCursor(t);
+}
+function Ji() {
+  const t = this.tokenStart;
+  let e, n = null, r = null, i = null;
+  return this.eat(bt), this.skipSC(), e = Ki.call(this), this.skipSC(), this.tokenType !== mt && (this.tokenType !== k && (n = Qi.call(this), this.skipSC(), r = this.tokenType === Re ? this.String() : this.Identifier(), this.skipSC()), this.tokenType === k && (i = this.consume(k), this.skipSC())), this.eat(mt), {
+    type: "AttributeSelector",
+    loc: this.getLocation(t, this.tokenStart),
+    name: e,
+    matcher: n,
+    value: r,
+    flags: i
+  };
+}
+function Yi(t) {
+  this.token($, "["), this.node(t.name), t.matcher !== null && (this.tokenize(t.matcher), this.node(t.value)), t.flags !== null && this.token(k, t.flags), this.token($, "]");
+}
+const Xi = 46;
+function Zi() {
+  return this.eatDelim(Xi), {
+    type: "ClassSelector",
+    loc: this.getLocation(this.tokenStart - 1, this.tokenEnd),
+    name: this.consume(k)
+  };
+}
+function es(t) {
+  this.token($, "."), this.token(k, t.name);
+}
+const ts = 43, dr = 47, ns = 62, rs = 126;
+function is() {
+  const t = this.tokenStart;
+  let e;
+  switch (this.tokenType) {
+    case J:
+      e = " ";
+      break;
+    case $:
+      switch (this.charCodeAt(this.tokenStart)) {
+        case ns:
+        case ts:
+        case rs:
+          this.next();
+          break;
+        case dr:
+          this.next(), this.eatIdent("deep"), this.eatDelim(dr);
+          break;
+        default:
+          this.error("Combinator is expected");
+      }
+      e = this.substrToCursor(t);
+      break;
+  }
+  return {
+    type: "Combinator",
+    loc: this.getLocation(t, this.tokenStart),
+    name: e
+  };
+}
+function ss(t) {
+  this.tokenize(t.name);
+}
+function os() {
+  return {
+    type: "Identifier",
+    loc: this.getLocation(this.tokenStart, this.tokenEnd),
+    name: this.consume(k)
+  };
+}
+function as(t) {
+  this.token(k, t.name);
+}
+function ls() {
+  const t = this.tokenStart;
+  return this.eat(z), {
+    type: "IdSelector",
+    loc: this.getLocation(t, this.tokenStart),
+    name: this.substrToCursor(t + 1)
+  };
+}
+function cs(t) {
+  this.token($, "#" + t.name);
+}
+const us = 38;
+function hs() {
+  const t = this.tokenStart;
+  return this.eatDelim(us), {
+    type: "NestingSelector",
+    loc: this.getLocation(t, this.tokenStart)
+  };
+}
+function fs() {
+  this.token($, "&");
+}
+function ps() {
+  this.skipSC();
+  const t = this.tokenStart;
+  let e = t, n = null, r;
+  return this.lookupValue(0, "odd") || this.lookupValue(0, "even") ? r = this.Identifier() : r = this.AnPlusB(), e = this.tokenStart, this.skipSC(), this.lookupValue(0, "of") && (this.next(), n = this.SelectorList(), e = this.tokenStart), {
+    type: "Nth",
+    loc: this.getLocation(t, e),
+    nth: r,
+    selector: n
+  };
+}
+function ds(t) {
+  this.node(t.nth), t.selector !== null && (this.token(k, "of"), this.node(t.selector));
+}
+function ms() {
+  const t = this.tokenStart;
+  return this.next(), {
+    type: "Operator",
+    loc: this.getLocation(t, this.tokenStart),
+    value: this.substrToCursor(t)
+  };
+}
+function gs(t) {
+  this.tokenize(t.value);
+}
+function ks() {
+  return {
+    type: "Percentage",
+    loc: this.getLocation(this.tokenStart, this.tokenEnd),
+    value: this.consumeNumber(M)
+  };
+}
+function ys(t) {
+  this.token(M, t.value + "%");
+}
+function Ss() {
+  const t = this.tokenStart;
+  let e = null, n, r;
+  return this.eat(ee), this.tokenType === N ? (n = this.consumeFunctionName(), r = n.toLowerCase(), this.lookupNonWSType(0) == O ? e = this.createList() : hasOwnProperty.call(this.pseudo, r) ? (this.skipSC(), e = this.pseudo[r].call(this), this.skipSC()) : (e = this.createList(), e.push(
+    this.Raw(null, !1)
+  )), this.eat(O)) : n = this.consume(k), {
+    type: "PseudoClassSelector",
+    loc: this.getLocation(t, this.tokenStart),
+    name: n,
+    children: e
+  };
+}
+function xs(t) {
+  this.token(ee, ":"), t.children === null ? this.token(k, t.name) : (this.token(N, t.name + "("), this.children(t), this.token(O, ")"));
+}
+function Cs() {
+  const t = this.tokenStart;
+  let e = null, n, r;
+  return this.eat(ee), this.eat(ee), this.tokenType === N ? (n = this.consumeFunctionName(), r = n.toLowerCase(), this.lookupNonWSType(0) == O ? e = this.createList() : hasOwnProperty.call(this.pseudo, r) ? (this.skipSC(), e = this.pseudo[r].call(this), this.skipSC()) : (e = this.createList(), e.push(
+    this.Raw(null, !1)
+  )), this.eat(O)) : n = this.consume(k), {
+    type: "PseudoElementSelector",
+    loc: this.getLocation(t, this.tokenStart),
+    name: n,
+    children: e
+  };
+}
+function bs(t) {
+  this.token(ee, ":"), this.token(ee, ":"), t.children === null ? this.token(k, t.name) : (this.token(N, t.name + "("), this.children(t), this.token(O, ")"));
+}
+function ws() {
+  return this.tokenIndex > 0 && this.lookupType(-1) === J ? this.tokenIndex > 1 ? this.getTokenStart(this.tokenIndex - 1) : this.firstCharOffset : this.tokenStart;
+}
+function vs(t, e) {
+  const n = this.getTokenStart(this.tokenIndex);
+  let r;
+  return this.skipUntilBalanced(this.tokenIndex, t || this.consumeUntilBalanceEnd), e && this.tokenStart > n ? r = ws.call(this) : r = this.tokenStart, {
+    type: "Raw",
+    loc: this.getLocation(n, r),
+    value: this.substring(n, r)
+  };
+}
+function As(t) {
+  this.tokenize(t.value);
+}
+function Ls() {
+  const t = this.readSequence(this.scope.Selector);
+  return this.getFirstListNode(t) === null && this.error("Selector is expected"), {
+    type: "Selector",
+    loc: this.getLocationFromList(t),
+    children: t
+  };
+}
+function Es(t) {
+  this.children(t);
+}
+function _s() {
+  const t = this.createList();
+  for (; !this.eof; ) {
+    if (t.push(this.Selector()), this.tokenType === qe) {
+      this.next();
+      continue;
+    }
+    break;
+  }
+  return {
+    type: "SelectorList",
+    loc: this.getLocationFromList(t),
+    children: t
+  };
+}
+function Ts(t) {
+  this.children(t, () => this.token(qe, ","));
+}
+const un = 92, Fr = 34, Os = 39;
+function Is(t) {
+  const e = t.length, n = t.charCodeAt(0), r = n === Fr || n === Os ? 1 : 0, i = r === 1 && e > 1 && t.charCodeAt(e - 1) === n ? e - 2 : e - 1;
+  let o = "";
+  for (let a = r; a <= i; a++) {
+    let f = t.charCodeAt(a);
+    if (f === un) {
+      if (a === i) {
+        a !== e - 1 && (o = t.substr(a + 1));
+        break;
+      }
+      if (f = t.charCodeAt(++a), ye(un, f)) {
+        const c = a - 1, s = Qe(t, c);
+        a = s - 1, o += gi(t.substring(c + 1, s));
+      } else
+        f === 13 && t.charCodeAt(a + 1) === 10 && a++;
+    } else
+      o += t[a];
+  }
+  return o;
+}
+function $s(t, e) {
+  const n = '"', r = Fr;
+  let i = "", o = !1;
+  for (let a = 0; a < t.length; a++) {
+    const f = t.charCodeAt(a);
+    if (f === 0) {
+      i += "�";
+      continue;
+    }
+    if (f <= 31 || f === 127) {
+      i += "\\" + f.toString(16), o = !0;
+      continue;
+    }
+    f === r || f === un ? (i += "\\" + t.charAt(a), o = !1) : (o && (Ke(f) || Ye(f)) && (i += " "), i += t.charAt(a), o = !1);
+  }
+  return n + i + n;
+}
+function Ns() {
+  return {
+    type: "String",
+    loc: this.getLocation(this.tokenStart, this.tokenEnd),
+    value: Is(this.consume(Re))
+  };
+}
+function Ds(t) {
+  this.token(Re, $s(t.value));
+}
+const Ps = 42, mr = 124;
+function tn() {
+  this.tokenType !== k && this.isDelim(Ps) === !1 && this.error("Identifier or asterisk is expected"), this.next();
+}
+function Ms() {
+  const t = this.tokenStart;
+  return this.isDelim(mr) ? (this.next(), tn.call(this)) : (tn.call(this), this.isDelim(mr) && (this.next(), tn.call(this))), {
+    type: "TypeSelector",
+    loc: this.getLocation(t, this.tokenStart),
+    name: this.substrToCursor(t)
+  };
+}
+function Fs(t) {
+  this.tokenize(t.name);
+}
+const zs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AnPlusB: Ui,
+  AttributeSelector: Ji,
+  ClassSelector: Zi,
+  Combinator: is,
+  IdSelector: ls,
+  Identifier: os,
+  NestingSelector: hs,
+  Nth: ps,
+  Operator: ms,
+  Percentage: ks,
+  PseudoClassSelector: Ss,
+  PseudoElementSelector: Cs,
+  Raw: vs,
+  Selector: Ls,
+  SelectorList: _s,
+  String: Ns,
+  TypeSelector: Ms
+}, Symbol.toStringTag, { value: "Module" })), Rs = {
+  parseContext: {
+    default: "SelectorList",
+    selectorList: "SelectorList",
+    selector: "Selector"
+  },
+  scope: { Selector: Fi },
+  atrule: {},
+  pseudo: Bi,
+  node: zs
+}, gr = Li(Rs);
+var yn = {}, Sn = {}, kr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+Sn.encode = function(t) {
+  if (0 <= t && t < kr.length)
+    return kr[t];
+  throw new TypeError("Must be between 0 and 63: " + t);
+};
+Sn.decode = function(t) {
+  var e = 65, n = 90, r = 97, i = 122, o = 48, a = 57, f = 43, c = 47, s = 26, l = 52;
+  return e <= t && t <= n ? t - e : r <= t && t <= i ? t - r + s : o <= t && t <= a ? t - o + l : t == f ? 62 : t == c ? 63 : -1;
+};
+var zr = Sn, xn = 5, Rr = 1 << xn, qr = Rr - 1, Br = Rr;
+function qs(t) {
+  return t < 0 ? (-t << 1) + 1 : (t << 1) + 0;
+}
+function Bs(t) {
+  var e = (t & 1) === 1, n = t >> 1;
+  return e ? -n : n;
+}
+yn.encode = function(e) {
+  var n = "", r, i = qs(e);
+  do
+    r = i & qr, i >>>= xn, i > 0 && (r |= Br), n += zr.encode(r);
+  while (i > 0);
+  return n;
+};
+yn.decode = function(e, n, r) {
+  var i = e.length, o = 0, a = 0, f, c;
+  do {
+    if (n >= i)
+      throw new Error("Expected more digits in base 64 VLQ value.");
+    if (c = zr.decode(e.charCodeAt(n++)), c === -1)
+      throw new Error("Invalid base64 digit: " + e.charAt(n - 1));
+    f = !!(c & Br), c &= qr, o = o + (c << a), a += xn;
+  } while (f);
+  r.value = Bs(o), r.rest = n;
+};
+var wt = {};
+(function(t) {
+  function e(u, h, g) {
+    if (h in u)
+      return u[h];
+    if (arguments.length === 3)
+      return g;
+    throw new Error('"' + h + '" is a required argument.');
+  }
+  t.getArg = e;
+  var n = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/, r = /^data:.+\,.+$/;
+  function i(u) {
+    var h = u.match(n);
+    return h ? {
+      scheme: h[1],
+      auth: h[2],
+      host: h[3],
+      port: h[4],
+      path: h[5]
+    } : null;
+  }
+  t.urlParse = i;
+  function o(u) {
+    var h = "";
+    return u.scheme && (h += u.scheme + ":"), h += "//", u.auth && (h += u.auth + "@"), u.host && (h += u.host), u.port && (h += ":" + u.port), u.path && (h += u.path), h;
+  }
+  t.urlGenerate = o;
+  var a = 32;
+  function f(u) {
+    var h = [];
+    return function(g) {
+      for (var p = 0; p < h.length; p++)
+        if (h[p].input === g) {
+          var X = h[0];
+          return h[0] = h[p], h[p] = X, h[0].result;
+        }
+      var j = u(g);
+      return h.unshift({
+        input: g,
+        result: j
+      }), h.length > a && h.pop(), j;
+    };
+  }
+  var c = f(function(h) {
+    var g = h, p = i(h);
+    if (p) {
+      if (!p.path)
+        return h;
+      g = p.path;
+    }
+    for (var X = t.isAbsolute(g), j = [], xe = 0, R = 0; ; )
+      if (xe = R, R = g.indexOf("/", xe), R === -1) {
+        j.push(g.slice(xe));
+        break;
+      } else
+        for (j.push(g.slice(xe, R)); R < g.length && g[R] === "/"; )
+          R++;
+    for (var Ce, ge = 0, R = j.length - 1; R >= 0; R--)
+      Ce = j[R], Ce === "." ? j.splice(R, 1) : Ce === ".." ? ge++ : ge > 0 && (Ce === "" ? (j.splice(R + 1, ge), ge = 0) : (j.splice(R, 2), ge--));
+    return g = j.join("/"), g === "" && (g = X ? "/" : "."), p ? (p.path = g, o(p)) : g;
+  });
+  t.normalize = c;
+  function s(u, h) {
+    u === "" && (u = "."), h === "" && (h = ".");
+    var g = i(h), p = i(u);
+    if (p && (u = p.path || "/"), g && !g.scheme)
+      return p && (g.scheme = p.scheme), o(g);
+    if (g || h.match(r))
+      return h;
+    if (p && !p.host && !p.path)
+      return p.host = h, o(p);
+    var X = h.charAt(0) === "/" ? h : c(u.replace(/\/+$/, "") + "/" + h);
+    return p ? (p.path = X, o(p)) : X;
+  }
+  t.join = s, t.isAbsolute = function(u) {
+    return u.charAt(0) === "/" || n.test(u);
+  };
+  function l(u, h) {
+    u === "" && (u = "."), u = u.replace(/\/$/, "");
+    for (var g = 0; h.indexOf(u + "/") !== 0; ) {
+      var p = u.lastIndexOf("/");
+      if (p < 0 || (u = u.slice(0, p), u.match(/^([^\/]+:\/)?\/*$/)))
+        return h;
+      ++g;
+    }
+    return Array(g + 1).join("../") + h.substr(u.length + 1);
+  }
+  t.relative = l;
+  var m = function() {
+    var u = /* @__PURE__ */ Object.create(null);
+    return !("__proto__" in u);
+  }();
+  function y(u) {
+    return u;
+  }
+  function C(u) {
+    return q(u) ? "$" + u : u;
+  }
+  t.toSetString = m ? y : C;
+  function _(u) {
+    return q(u) ? u.slice(1) : u;
+  }
+  t.fromSetString = m ? y : _;
+  function q(u) {
+    if (!u)
+      return !1;
+    var h = u.length;
+    if (h < 9 || u.charCodeAt(h - 1) !== 95 || u.charCodeAt(h - 2) !== 95 || u.charCodeAt(h - 3) !== 111 || u.charCodeAt(h - 4) !== 116 || u.charCodeAt(h - 5) !== 111 || u.charCodeAt(h - 6) !== 114 || u.charCodeAt(h - 7) !== 112 || u.charCodeAt(h - 8) !== 95 || u.charCodeAt(h - 9) !== 95)
+      return !1;
+    for (var g = h - 10; g >= 0; g--)
+      if (u.charCodeAt(g) !== 36)
+        return !1;
+    return !0;
+  }
+  function V(u, h, g) {
+    var p = Y(u.source, h.source);
+    return p !== 0 || (p = u.originalLine - h.originalLine, p !== 0) || (p = u.originalColumn - h.originalColumn, p !== 0 || g) || (p = u.generatedColumn - h.generatedColumn, p !== 0) || (p = u.generatedLine - h.generatedLine, p !== 0) ? p : Y(u.name, h.name);
+  }
+  t.compareByOriginalPositions = V;
+  function me(u, h, g) {
+    var p;
+    return p = u.originalLine - h.originalLine, p !== 0 || (p = u.originalColumn - h.originalColumn, p !== 0 || g) || (p = u.generatedColumn - h.generatedColumn, p !== 0) || (p = u.generatedLine - h.generatedLine, p !== 0) ? p : Y(u.name, h.name);
+  }
+  t.compareByOriginalPositionsNoSource = me;
+  function Oe(u, h, g) {
+    var p = u.generatedLine - h.generatedLine;
+    return p !== 0 || (p = u.generatedColumn - h.generatedColumn, p !== 0 || g) || (p = Y(u.source, h.source), p !== 0) || (p = u.originalLine - h.originalLine, p !== 0) || (p = u.originalColumn - h.originalColumn, p !== 0) ? p : Y(u.name, h.name);
+  }
+  t.compareByGeneratedPositionsDeflated = Oe;
+  function Be(u, h, g) {
+    var p = u.generatedColumn - h.generatedColumn;
+    return p !== 0 || g || (p = Y(u.source, h.source), p !== 0) || (p = u.originalLine - h.originalLine, p !== 0) || (p = u.originalColumn - h.originalColumn, p !== 0) ? p : Y(u.name, h.name);
+  }
+  t.compareByGeneratedPositionsDeflatedNoLine = Be;
+  function Y(u, h) {
+    return u === h ? 0 : u === null ? 1 : h === null ? -1 : u > h ? 1 : -1;
+  }
+  function Ze(u, h) {
+    var g = u.generatedLine - h.generatedLine;
+    return g !== 0 || (g = u.generatedColumn - h.generatedColumn, g !== 0) || (g = Y(u.source, h.source), g !== 0) || (g = u.originalLine - h.originalLine, g !== 0) || (g = u.originalColumn - h.originalColumn, g !== 0) ? g : Y(u.name, h.name);
+  }
+  t.compareByGeneratedPositionsInflated = Ze;
+  function et(u) {
+    return JSON.parse(u.replace(/^\)]}'[^\n]*\n/, ""));
+  }
+  t.parseSourceMapInput = et;
+  function tt(u, h, g) {
+    if (h = h || "", u && (u[u.length - 1] !== "/" && h[0] !== "/" && (u += "/"), h = u + h), g) {
+      var p = i(g);
+      if (!p)
+        throw new Error("sourceMapURL could not be parsed");
+      if (p.path) {
+        var X = p.path.lastIndexOf("/");
+        X >= 0 && (p.path = p.path.substring(0, X + 1));
+      }
+      h = s(o(p), h);
+    }
+    return c(h);
+  }
+  t.computeSourceURL = tt;
+})(wt);
+var jr = {}, Cn = wt, bn = Object.prototype.hasOwnProperty, _e = typeof Map < "u";
+function Se() {
+  this._array = [], this._set = _e ? /* @__PURE__ */ new Map() : /* @__PURE__ */ Object.create(null);
+}
+Se.fromArray = function(e, n) {
+  for (var r = new Se(), i = 0, o = e.length; i < o; i++)
+    r.add(e[i], n);
+  return r;
+};
+Se.prototype.size = function() {
+  return _e ? this._set.size : Object.getOwnPropertyNames(this._set).length;
+};
+Se.prototype.add = function(e, n) {
+  var r = _e ? e : Cn.toSetString(e), i = _e ? this.has(e) : bn.call(this._set, r), o = this._array.length;
+  (!i || n) && this._array.push(e), i || (_e ? this._set.set(e, o) : this._set[r] = o);
+};
+Se.prototype.has = function(e) {
+  if (_e)
+    return this._set.has(e);
+  var n = Cn.toSetString(e);
+  return bn.call(this._set, n);
+};
+Se.prototype.indexOf = function(e) {
+  if (_e) {
+    var n = this._set.get(e);
+    if (n >= 0)
+      return n;
+  } else {
+    var r = Cn.toSetString(e);
+    if (bn.call(this._set, r))
+      return this._set[r];
+  }
+  throw new Error('"' + e + '" is not in the set.');
+};
+Se.prototype.at = function(e) {
+  if (e >= 0 && e < this._array.length)
+    return this._array[e];
+  throw new Error("No element indexed by " + e);
+};
+Se.prototype.toArray = function() {
+  return this._array.slice();
+};
+jr.ArraySet = Se;
+var Ur = {}, Vr = wt;
+function js(t, e) {
+  var n = t.generatedLine, r = e.generatedLine, i = t.generatedColumn, o = e.generatedColumn;
+  return r > n || r == n && o >= i || Vr.compareByGeneratedPositionsInflated(t, e) <= 0;
+}
+function vt() {
+  this._array = [], this._sorted = !0, this._last = { generatedLine: -1, generatedColumn: 0 };
+}
+vt.prototype.unsortedForEach = function(e, n) {
+  this._array.forEach(e, n);
+};
+vt.prototype.add = function(e) {
+  js(this._last, e) ? (this._last = e, this._array.push(e)) : (this._sorted = !1, this._array.push(e));
+};
+vt.prototype.toArray = function() {
+  return this._sorted || (this._array.sort(Vr.compareByGeneratedPositionsInflated), this._sorted = !0), this._array;
+};
+Ur.MappingList = vt;
+var We = yn, P = wt, xt = jr.ArraySet, Us = Ur.MappingList;
+function ne(t) {
+  t || (t = {}), this._file = P.getArg(t, "file", null), this._sourceRoot = P.getArg(t, "sourceRoot", null), this._skipValidation = P.getArg(t, "skipValidation", !1), this._ignoreInvalidMapping = P.getArg(t, "ignoreInvalidMapping", !1), this._sources = new xt(), this._names = new xt(), this._mappings = new Us(), this._sourcesContents = null;
+}
+ne.prototype._version = 3;
+ne.fromSourceMap = function(e, n) {
+  var r = e.sourceRoot, i = new ne(Object.assign(n || {}, {
+    file: e.file,
+    sourceRoot: r
+  }));
+  return e.eachMapping(function(o) {
+    var a = {
+      generated: {
+        line: o.generatedLine,
+        column: o.generatedColumn
+      }
+    };
+    o.source != null && (a.source = o.source, r != null && (a.source = P.relative(r, a.source)), a.original = {
+      line: o.originalLine,
+      column: o.originalColumn
+    }, o.name != null && (a.name = o.name)), i.addMapping(a);
+  }), e.sources.forEach(function(o) {
+    var a = o;
+    r !== null && (a = P.relative(r, o)), i._sources.has(a) || i._sources.add(a);
+    var f = e.sourceContentFor(o);
+    f != null && i.setSourceContent(o, f);
+  }), i;
+};
+ne.prototype.addMapping = function(e) {
+  var n = P.getArg(e, "generated"), r = P.getArg(e, "original", null), i = P.getArg(e, "source", null), o = P.getArg(e, "name", null);
+  !this._skipValidation && this._validateMapping(n, r, i, o) === !1 || (i != null && (i = String(i), this._sources.has(i) || this._sources.add(i)), o != null && (o = String(o), this._names.has(o) || this._names.add(o)), this._mappings.add({
+    generatedLine: n.line,
+    generatedColumn: n.column,
+    originalLine: r != null && r.line,
+    originalColumn: r != null && r.column,
+    source: i,
+    name: o
+  }));
+};
+ne.prototype.setSourceContent = function(e, n) {
+  var r = e;
+  this._sourceRoot != null && (r = P.relative(this._sourceRoot, r)), n != null ? (this._sourcesContents || (this._sourcesContents = /* @__PURE__ */ Object.create(null)), this._sourcesContents[P.toSetString(r)] = n) : this._sourcesContents && (delete this._sourcesContents[P.toSetString(r)], Object.keys(this._sourcesContents).length === 0 && (this._sourcesContents = null));
+};
+ne.prototype.applySourceMap = function(e, n, r) {
+  var i = n;
+  if (n == null) {
+    if (e.file == null)
+      throw new Error(
+        `SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map's "file" property. Both were omitted.`
+      );
+    i = e.file;
+  }
+  var o = this._sourceRoot;
+  o != null && (i = P.relative(o, i));
+  var a = new xt(), f = new xt();
+  this._mappings.unsortedForEach(function(c) {
+    if (c.source === i && c.originalLine != null) {
+      var s = e.originalPositionFor({
+        line: c.originalLine,
+        column: c.originalColumn
+      });
+      s.source != null && (c.source = s.source, r != null && (c.source = P.join(r, c.source)), o != null && (c.source = P.relative(o, c.source)), c.originalLine = s.line, c.originalColumn = s.column, s.name != null && (c.name = s.name));
+    }
+    var l = c.source;
+    l != null && !a.has(l) && a.add(l);
+    var m = c.name;
+    m != null && !f.has(m) && f.add(m);
+  }, this), this._sources = a, this._names = f, e.sources.forEach(function(c) {
+    var s = e.sourceContentFor(c);
+    s != null && (r != null && (c = P.join(r, c)), o != null && (c = P.relative(o, c)), this.setSourceContent(c, s));
+  }, this);
+};
+ne.prototype._validateMapping = function(e, n, r, i) {
+  if (n && typeof n.line != "number" && typeof n.column != "number") {
+    var o = "original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values.";
+    if (this._ignoreInvalidMapping)
+      return typeof console < "u" && console.warn && console.warn(o), !1;
+    throw new Error(o);
+  }
+  if (!(e && "line" in e && "column" in e && e.line > 0 && e.column >= 0 && !n && !r && !i)) {
+    if (e && "line" in e && "column" in e && n && "line" in n && "column" in n && e.line > 0 && e.column >= 0 && n.line > 0 && n.column >= 0 && r)
+      return;
+    var o = "Invalid mapping: " + JSON.stringify({
+      generated: e,
+      source: r,
+      original: n,
+      name: i
+    });
+    if (this._ignoreInvalidMapping)
+      return typeof console < "u" && console.warn && console.warn(o), !1;
+    throw new Error(o);
+  }
+};
+ne.prototype._serializeMappings = function() {
+  for (var e = 0, n = 1, r = 0, i = 0, o = 0, a = 0, f = "", c, s, l, m, y = this._mappings.toArray(), C = 0, _ = y.length; C < _; C++) {
+    if (s = y[C], c = "", s.generatedLine !== n)
+      for (e = 0; s.generatedLine !== n; )
+        c += ";", n++;
+    else if (C > 0) {
+      if (!P.compareByGeneratedPositionsInflated(s, y[C - 1]))
+        continue;
+      c += ",";
+    }
+    c += We.encode(s.generatedColumn - e), e = s.generatedColumn, s.source != null && (m = this._sources.indexOf(s.source), c += We.encode(m - a), a = m, c += We.encode(s.originalLine - 1 - i), i = s.originalLine - 1, c += We.encode(s.originalColumn - r), r = s.originalColumn, s.name != null && (l = this._names.indexOf(s.name), c += We.encode(l - o), o = l)), f += c;
+  }
+  return f;
+};
+ne.prototype._generateSourcesContent = function(e, n) {
+  return e.map(function(r) {
+    if (!this._sourcesContents)
+      return null;
+    n != null && (r = P.relative(n, r));
+    var i = P.toSetString(r);
+    return Object.prototype.hasOwnProperty.call(this._sourcesContents, i) ? this._sourcesContents[i] : null;
+  }, this);
+};
+ne.prototype.toJSON = function() {
+  var e = {
+    version: this._version,
+    sources: this._sources.toArray(),
+    names: this._names.toArray(),
+    mappings: this._serializeMappings()
+  };
+  return this._file != null && (e.file = this._file), this._sourceRoot != null && (e.sourceRoot = this._sourceRoot), this._sourcesContents && (e.sourcesContent = this._generateSourcesContent(e.sources, e.sourceRoot)), e;
+};
+ne.prototype.toString = function() {
+  return JSON.stringify(this.toJSON());
+};
+var Vs = ne;
+const yr = /* @__PURE__ */ new Set(["Atrule", "Selector", "Declaration"]);
+function Gs(t) {
+  const e = new Vs(), n = {
+    line: 1,
+    column: 0
+  }, r = {
+    line: 0,
+    // should be zero to add first mapping
+    column: 0
+  }, i = {
+    line: 1,
+    column: 0
+  }, o = {
+    generated: i
+  };
+  let a = 1, f = 0, c = !1;
+  const s = t.node;
+  t.node = function(y) {
+    if (y.loc && y.loc.start && yr.has(y.type)) {
+      const C = y.loc.start.line, _ = y.loc.start.column - 1;
+      (r.line !== C || r.column !== _) && (r.line = C, r.column = _, n.line = a, n.column = f, c && (c = !1, (n.line !== i.line || n.column !== i.column) && e.addMapping(o)), c = !0, e.addMapping({
+        source: y.loc.source,
+        original: r,
+        generated: n
+      }));
+    }
+    s.call(this, y), c && yr.has(y.type) && (i.line = a, i.column = f);
+  };
+  const l = t.emit;
+  t.emit = function(y, C, _) {
+    for (let q = 0; q < y.length; q++)
+      y.charCodeAt(q) === 10 ? (a++, f = 0) : f++;
+    l(y, C, _);
+  };
+  const m = t.result;
+  return t.result = function() {
+    return c && e.addMapping(o), {
+      css: m(),
+      map: e
+    };
+  }, t;
+}
+const Hs = 43, Ws = 45, nn = (t, e) => {
+  if (t === $ && (t = e), typeof t == "string") {
+    const n = t.charCodeAt(0);
+    return n > 127 ? 32768 : n << 8;
+  }
+  return t;
+}, Gr = [
+  [k, k],
+  [k, N],
+  [k, se],
+  [k, oe],
+  [k, "-"],
+  [k, E],
+  [k, M],
+  [k, I],
+  [k, ae],
+  [k, te],
+  [U, k],
+  [U, N],
+  [U, se],
+  [U, oe],
+  [U, "-"],
+  [U, E],
+  [U, M],
+  [U, I],
+  [U, ae],
+  [z, k],
+  [z, N],
+  [z, se],
+  [z, oe],
+  [z, "-"],
+  [z, E],
+  [z, M],
+  [z, I],
+  [z, ae],
+  [I, k],
+  [I, N],
+  [I, se],
+  [I, oe],
+  [I, "-"],
+  [I, E],
+  [I, M],
+  [I, I],
+  [I, ae],
+  ["#", k],
+  ["#", N],
+  ["#", se],
+  ["#", oe],
+  ["#", "-"],
+  ["#", E],
+  ["#", M],
+  ["#", I],
+  ["#", ae],
+  // https://github.com/w3c/csswg-drafts/pull/6874
+  ["-", k],
+  ["-", N],
+  ["-", se],
+  ["-", oe],
+  ["-", "-"],
+  ["-", E],
+  ["-", M],
+  ["-", I],
+  ["-", ae],
+  // https://github.com/w3c/csswg-drafts/pull/6874
+  [E, k],
+  [E, N],
+  [E, se],
+  [E, oe],
+  [E, E],
+  [E, M],
+  [E, I],
+  [E, "%"],
+  [E, ae],
+  // https://github.com/w3c/csswg-drafts/pull/6874
+  ["@", k],
+  ["@", N],
+  ["@", se],
+  ["@", oe],
+  ["@", "-"],
+  ["@", ae],
+  // https://github.com/w3c/csswg-drafts/pull/6874
+  [".", E],
+  [".", M],
+  [".", I],
+  ["+", E],
+  ["+", M],
+  ["+", I],
+  ["/", "*"]
+], Ks = Gr.concat([
+  [k, z],
+  [I, z],
+  [z, z],
+  [U, te],
+  [U, Re],
+  [U, ee],
+  [M, M],
+  [M, I],
+  [M, N],
+  [M, "-"],
+  [O, k],
+  [O, N],
+  [O, M],
+  [O, I],
+  [O, z],
+  [O, "-"]
+]);
+function Hr(t) {
+  const e = new Set(
+    t.map(([n, r]) => nn(n) << 16 | nn(r))
+  );
+  return function(n, r, i) {
+    const o = nn(r, i), a = i.charCodeAt(0);
+    return (a === Ws && r !== k && r !== N && r !== ae || a === Hs ? e.has(n << 16 | a << 8) : e.has(n << 16 | o)) && this.emit(" ", J, !0), o;
+  };
+}
+const Qs = Hr(Gr), Wr = Hr(Ks), Sr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  safe: Wr,
+  spec: Qs
+}, Symbol.toStringTag, { value: "Module" })), Js = 92;
+function Ys(t, e) {
+  if (typeof e == "function") {
+    let n = null;
+    t.children.forEach((r) => {
+      n !== null && e.call(this, n), this.node(r), n = r;
+    });
+    return;
+  }
+  t.children.forEach(this.node, this);
+}
+function Xs(t) {
+  Pr(t, (e, n, r) => {
+    this.token(e, t.slice(n, r));
+  });
+}
+function Zs(t) {
+  const e = /* @__PURE__ */ new Map();
+  for (let [n, r] of Object.entries(t.node))
+    typeof (r.generate || r) == "function" && e.set(n, r.generate || r);
+  return function(n, r) {
+    let i = "", o = 0, a = {
+      node(c) {
+        if (e.has(c.type))
+          e.get(c.type).call(f, c);
+        else
+          throw new Error("Unknown node type: " + c.type);
+      },
+      tokenBefore: Wr,
+      token(c, s) {
+        o = this.tokenBefore(o, c, s), this.emit(s, c, !1), c === $ && s.charCodeAt(0) === Js && this.emit(`
+`, J, !0);
+      },
+      emit(c) {
+        i += c;
+      },
+      result() {
+        return i;
+      }
+    };
+    r && (typeof r.decorator == "function" && (a = r.decorator(a)), r.sourceMap && (a = Gs(a)), r.mode in Sr && (a.tokenBefore = Sr[r.mode]));
+    const f = {
+      node: (c) => a.node(c),
+      children: Ys,
+      token: (c, s) => a.token(c, s),
+      tokenize: Xs
+    };
+    return a.node(n), a.result();
+  };
+}
+function eo(t) {
+  this.token(U, "@" + t.name), t.prelude !== null && this.node(t.prelude), t.block ? this.node(t.block) : this.token(Ct, ";");
+}
+function to(t) {
+  this.children(t);
+}
+function no(t) {
+  this.token(dn, "{"), this.children(t, (e) => {
+    e.type === "Declaration" && this.token(Ct, ";");
+  }), this.token(mn, "}");
+}
+function ro(t) {
+  this.token($, "["), this.children(t), this.token($, "]");
+}
+function io() {
+  this.token(ae, "-->");
+}
+function so() {
+  this.token(Er, "<!--");
+}
+function oo(t) {
+  this.token(fe, "/*" + t.value + "*/");
+}
+function ao(t) {
+  t.children.forEach((e) => {
+    e.type === "Condition" ? (this.token(te, "("), this.node(e), this.token(O, ")")) : this.node(e);
+  });
+}
+function lo(t) {
+  this.token(k, t.property), this.token(ee, ":"), this.node(t.value), t.important && (this.token($, "!"), this.token(k, t.important === !0 ? "important" : t.important));
+}
+function co(t) {
+  this.children(t, (e) => {
+    e.type === "Declaration" && this.token(Ct, ";");
+  });
+}
+function uo(t) {
+  this.token(I, t.value + t.unit);
+}
+function ho(t) {
+  this.token(te, "("), this.token(k, t.name), t.value !== null && (this.token(ee, ":"), this.node(t.value)), this.token(O, ")");
+}
+function fo(t) {
+  this.token(N, t.feature + "("), this.node(t.value), this.token(O, ")");
+}
+function po(t) {
+  this.token(te, "("), this.node(t.left), this.tokenize(t.leftComparison), this.node(t.middle), t.right && (this.tokenize(t.rightComparison), this.node(t.right)), this.token(O, ")");
+}
+function mo(t) {
+  this.token(N, t.name + "("), this.children(t), this.token(O, ")");
+}
+function go(t) {
+  t.function ? this.token(N, t.function + "(") : this.token(te, "("), this.children(t), this.token(O, ")");
+}
+function ko(t) {
+  this.token(z, "#" + t.value);
+}
+function yo(t) {
+  this.tokenize(t.name);
+}
+function So(t) {
+  this.children(t, () => this.token(qe, ","));
+}
+function xo(t) {
+  t.mediaType ? (t.modifier && this.token(k, t.modifier), this.token(k, t.mediaType), t.condition && (this.token(k, "and"), this.node(t.condition))) : t.condition && this.node(t.condition);
+}
+function Co(t) {
+  this.children(t, () => this.token(qe, ","));
+}
+function bo(t) {
+  this.token(E, t.value);
+}
+function wo(t) {
+  this.token(te, "("), this.children(t), this.token(O, ")");
+}
+function vo(t) {
+  this.node(t.left), this.token($, "/"), t.right ? this.node(t.right) : this.node(E, 1);
+}
+function Ao(t) {
+  this.node(t.prelude), this.node(t.block);
+}
+function Lo(t) {
+  t.root && (this.token(te, "("), this.node(t.root), this.token(O, ")")), t.limit && (this.token(k, "to"), this.token(te, "("), this.node(t.limit), this.token(O, ")"));
+}
+function Eo(t) {
+  this.children(t);
+}
+function _o(t) {
+  this.token(te, "("), this.node(t.declaration), this.token(O, ")");
+}
+function To(t) {
+  this.tokenize(t.value);
+}
+const Oo = 32, Io = 92, $o = 34, No = 39, Do = 40, Po = 41;
+function Mo(t) {
+  let e = "", n = !1;
+  for (let r = 0; r < t.length; r++) {
+    const i = t.charCodeAt(r);
+    if (i === 0) {
+      e += "�";
+      continue;
+    }
+    if (i <= 31 || i === 127) {
+      e += "\\" + i.toString(16), n = !0;
+      continue;
+    }
+    i === Oo || i === Io || i === $o || i === No || i === Do || i === Po ? (e += "\\" + t.charAt(r), n = !1) : (n && Ke(i) && (e += " "), e += t.charAt(r), n = !1);
+  }
+  return "url(" + e + ")";
+}
+function Fo(t) {
+  this.token(se, Mo(t.value));
+}
+function zo(t) {
+  this.children(t);
+}
+function Ro(t) {
+  this.token(J, t.value);
+}
+const qo = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  AnPlusB: Vi,
+  Atrule: eo,
+  AtrulePrelude: to,
+  AttributeSelector: Yi,
+  Block: no,
+  Brackets: ro,
+  CDC: io,
+  CDO: so,
+  ClassSelector: es,
+  Combinator: ss,
+  Comment: oo,
+  Condition: ao,
+  Declaration: lo,
+  DeclarationList: co,
+  Dimension: uo,
+  Feature: ho,
+  FeatureFunction: fo,
+  FeatureRange: po,
+  Function: mo,
+  GeneralEnclosed: go,
+  Hash: ko,
+  IdSelector: cs,
+  Identifier: as,
+  Layer: yo,
+  LayerList: So,
+  MediaQuery: xo,
+  MediaQueryList: Co,
+  NestingSelector: fs,
+  Nth: ds,
+  Number: bo,
+  Operator: gs,
+  Parentheses: wo,
+  Percentage: ys,
+  PseudoClassSelector: xs,
+  PseudoElementSelector: bs,
+  Ratio: vo,
+  Raw: As,
+  Rule: Ao,
+  Scope: Lo,
+  Selector: Es,
+  SelectorList: Ts,
+  String: Ds,
+  StyleSheet: Eo,
+  SupportsDeclaration: _o,
+  TypeSelector: Fs,
+  UnicodeRange: To,
+  Url: Fo,
+  Value: zo,
+  WhiteSpace: Ro
+}, Symbol.toStringTag, { value: "Module" })), Bo = {
+  node: qo
+}, jo = Zs(Bo), Xe = (t, e) => t.a === e.a ? t.b === e.b ? t.c - e.c : t.b - e.b : t.a - e.a, xr = (t, e) => Xe(t, e) === 0, Cr = (t, e) => Xe(t, e) > 0, br = (t, e) => Xe(t, e) < 0, Kr = (t, e = "ASC") => {
+  const n = t.sort(Xe);
+  return e === "DESC" ? n.reverse() : n;
+}, Qr = (...t) => Kr(t, "ASC"), Jr = (...t) => Kr(t, "DESC"), hn = (...t) => Jr(...t)[0], Uo = (...t) => Qr(...t)[0];
+class rn extends Error {
+  constructor() {
+    super("Manipulating a Specificity instance is not allowed. Instead, create a new Specificity()");
+  }
+}
+class Vo {
+  constructor(e, n = null) {
+    this.value = e, this.selector = n;
+  }
+  get a() {
+    return this.value.a;
+  }
+  set a(e) {
+    throw new rn();
+  }
+  get b() {
+    return this.value.b;
+  }
+  set b(e) {
+    throw new rn();
+  }
+  get c() {
+    return this.value.c;
+  }
+  set c(e) {
+    throw new rn();
+  }
+  selectorString() {
+    return typeof this.selector == "string" || this.selector instanceof String ? this.selector : this.selector instanceof Object && this.selector.type === "Selector" ? jo(this.selector) : "";
+  }
+  toObject() {
+    return this.value;
+  }
+  toArray() {
+    return [this.value.a, this.value.b, this.value.c];
+  }
+  toString() {
+    return `(${this.value.a},${this.value.b},${this.value.c})`;
+  }
+  toJSON() {
+    return {
+      selector: this.selectorString(),
+      asObject: this.toObject(),
+      asArray: this.toArray(),
+      asString: this.toString()
+    };
+  }
+  isEqualTo(e) {
+    return xr(this, e);
+  }
+  isGreaterThan(e) {
+    return Cr(this, e);
+  }
+  isLessThan(e) {
+    return br(this, e);
+  }
+  static calculate(e) {
+    return Me(e);
+  }
+  static calculateForAST(e) {
+    return fn(e);
+  }
+  static compare(e, n) {
+    return Xe(e, n);
+  }
+  static equals(e, n) {
+    return xr(e, n);
+  }
+  static lessThan(e, n) {
+    return br(e, n);
+  }
+  static greaterThan(e, n) {
+    return Cr(e, n);
+  }
+  static min(...e) {
+    return Uo(...e);
+  }
+  static max(...e) {
+    return hn(...e);
+  }
+  static sortAsc(...e) {
+    return Qr(...e);
+  }
+  static sortDesc(...e) {
+    return Jr(...e);
+  }
+}
+const fn = (t) => {
+  if (!t || t.type !== "Selector")
+    throw new TypeError("Passed in source is not a Selector AST");
+  let e = 0, n = 0, r = 0;
+  return t.children.forEach((i) => {
+    switch (i.type) {
+      case "IdSelector":
+        e += 1;
+        break;
+      case "AttributeSelector":
+      case "ClassSelector":
+        n += 1;
+        break;
+      case "PseudoClassSelector":
+        switch (i.name.toLowerCase()) {
+          case "where":
+            break;
+          case "-webkit-any":
+          case "any":
+            i.children && (n += 1);
+            break;
+          case "-moz-any":
+          case "is":
+          case "matches":
+          case "not":
+          case "has":
+            if (i.children) {
+              const a = hn(...Me(i.children.first));
+              e += a.a, n += a.b, r += a.c;
+            }
+            break;
+          case "nth-child":
+          case "nth-last-child":
+            if (n += 1, i.children && i.children.first.selector) {
+              const a = hn(...Me(i.children.first.selector));
+              e += a.a, n += a.b, r += a.c;
+            }
+            break;
+          case "host-context":
+          case "host":
+            if (n += 1, i.children) {
+              const a = { type: "Selector", children: [] };
+              let f = !1;
+              i.children.first.children.forEach((s) => {
+                if (f) return !1;
+                if (s.type === "Combinator")
+                  return f = !0, !1;
+                a.children.push(s);
+              });
+              const c = Me(a)[0];
+              e += c.a, n += c.b, r += c.c;
+            }
+            break;
+          case "after":
+          case "before":
+          case "first-letter":
+          case "first-line":
+            r += 1;
+            break;
+          default:
+            n += 1;
+            break;
+        }
+        break;
+      case "PseudoElementSelector":
+        switch (i.name) {
+          case "slotted":
+            if (r += 1, i.children) {
+              const a = { type: "Selector", children: [] };
+              let f = !1;
+              i.children.first.children.forEach((s) => {
+                if (f) return !1;
+                if (s.type === "Combinator")
+                  return f = !0, !1;
+                a.children.push(s);
+              });
+              const c = Me(a)[0];
+              e += c.a, n += c.b, r += c.c;
+            }
+            break;
+          case "view-transition-group":
+          case "view-transition-image-pair":
+          case "view-transition-old":
+          case "view-transition-new":
+            if (i.children && i.children.first.value === "*")
+              break;
+            r += 1;
+            break;
+          default:
+            r += 1;
+            break;
+        }
+        break;
+      case "TypeSelector":
+        let o = i.name;
+        o.includes("|") && (o = o.split("|")[1]), o !== "*" && (r += 1);
+        break;
+    }
+  }), new Vo({ a: e, b: n, c: r }, t);
+}, Go = (t) => {
+  if (typeof t == "string" || t instanceof String)
+    try {
+      return gr(t, {
+        context: "selectorList"
+      });
+    } catch (e) {
+      throw new TypeError(`Could not convert passed in source '${t}' to SelectorList: ${e.message}`);
+    }
+  if (t instanceof Object) {
+    if (t.type && ["Selector", "SelectorList"].includes(t.type))
+      return t;
+    if (t.type && t.type === "Raw")
+      try {
+        return gr(t.value, {
+          context: "selectorList"
+        });
+      } catch (e) {
+        throw new TypeError(`Could not convert passed in source to SelectorList: ${e.message}`);
+      }
+    throw new TypeError("Passed in source is an Object but no AST / AST of the type Selector or SelectorList");
+  }
+  throw new TypeError("Passed in source is not a String nor an Object. I don't know what to do with it.");
+}, Me = (t) => {
+  if (!t)
+    return [];
+  const e = Go(t);
+  if (e.type === "Selector")
+    return [fn(t)];
+  if (e.type === "SelectorList") {
+    const n = [];
+    return e.children.forEach((r) => {
+      const i = fn(r);
+      n.push(i);
+    }), n;
+  }
+};
+function wn(t, e) {
+  return e >= 65 && e <= 90 && (e = e | 32), t === e;
+}
+function W(t, e) {
+  if (t === e) return !0;
+  let n = t.length;
+  if (n !== e.length) return !1;
+  for (let r = 0; r < n; r++)
+    if (wn(t.charCodeAt(r), e.charCodeAt(r)) === !1)
+      return !1;
+  return !0;
+}
+function ke(t, e) {
+  if (t === e) return !0;
+  let n = e.length, r = n - t.length;
+  if (r < 0)
+    return !1;
+  for (let i = n - 1; i >= r; i--)
+    if (wn(t.charCodeAt(i - r), e.charCodeAt(i)) === !1)
+      return !1;
+  return !0;
+}
+function vn(t, e) {
+  if (t === e) return !0;
+  let n = t.length;
+  if (e.length < n) return !1;
+  for (let r = 0; r < n; r++)
+    if (wn(t.charCodeAt(r), e.charCodeAt(r)) === !1)
+      return !1;
+  return !0;
+}
+const Ho = "Atrule", Wo = "MediaQuery", Ko = "MediaFeature", Qo = "Rule", An = "Selector", Yr = "TypeSelector", Je = "PseudoClassSelector", Xr = "AttributeSelector", Zr = "PseudoElementSelector", pn = "Declaration", Jo = "Value", de = "Identifier", Yo = "Nth", Xo = "Combinator", Zo = "Number", ei = "Dimension", ze = "Operator", ea = "Hash", ta = "Url", Ln = "Function";
+function wr(t, e, n) {
+  let r = t.value.children.first;
+  return W(e, t.property) && r.type === de && W(n, r.name);
+}
+function na(t) {
+  let e = !1;
+  return pe(t, function(n) {
+    if (n.type === pn && (wr(n, "-webkit-appearance", "none") || wr(n, "-moz-appearance", "meterbar")))
+      return e = !0, this.break;
+  }), e;
+}
+function ra(t) {
+  let e = !1;
+  return pe(t, function(n) {
+    let r = n.children, i = n.name, o = n.value;
+    if (n.type === Wo && r.size === 1 && r.first.type === de) {
+      let a = r.first.name;
+      if (vn("\\0", a) || ke("\\9 ", a))
+        return e = !0, this.break;
+    } else if (n.type === Ko) {
+      if (o && o.unit && o.unit === "\\0")
+        return e = !0, this.break;
+      if (W("-moz-images-in-menus", i) || W("min--moz-device-pixel-ratio", i) || W("-ms-high-contrast", i))
+        return e = !0, this.break;
+      if (W("min-resolution", i) && o && W(".001", o.value) && W("dpcm", o.unit))
+        return e = !0, this.break;
+      if (W("-webkit-min-device-pixel-ratio", i) && o && o.value && (W("0", o.value) || W("10000", o.value)))
+        return e = !0, this.break;
+    }
+  }), e;
+}
+const vr = 45;
+function we(t) {
+  return t.charCodeAt(0) === vr && t.charCodeAt(1) !== vr && t.indexOf("-", 2) !== -1;
+}
+class le {
+  /** @param {string[]} items */
+  constructor(e) {
+    this.set = new Set(e);
+  }
+  /** @param {string} item */
+  has(e) {
+    return this.set.has(e.toLowerCase());
+  }
+}
+function ti(t, e) {
+  let n = [];
+  return pe(t, {
+    visit: An,
+    enter: function(r) {
+      n.push(e(r));
+    }
+  }), n;
+}
+const ni = new le([
+  "nth-child",
+  "where",
+  "not",
+  "is",
+  "has",
+  "nth-last-child",
+  "matches",
+  "-webkit-any",
+  "-moz-any"
+]);
+function ri(t) {
+  let e = !1;
+  return pe(t, function(n) {
+    if (n.type === Xr) {
+      let r = n.name.name;
+      if (W("role", r) || vn("aria-", r))
+        return e = !0, this.break;
+    } else if (n.type === Je && ni.has(n.name)) {
+      let r = ti(n, ri);
+      for (let i of r)
+        if (i === !0) {
+          e = !0;
+          break;
+        }
+      return this.skip;
+    }
+  }), e;
+}
+function ia(t) {
+  let e = !1;
+  return pe(t, function(n) {
+    let r = n.type;
+    if ((r === Zr || r === Yr || r === Je) && we(n.name))
+      return e = !0, this.break;
+  }), e;
+}
+function sa(t) {
+  let e = [];
+  return pe(t, function(n) {
+    n.type === Je && e.push(n.name);
+  }), e.length === 0 ? !1 : e;
+}
+function ii(t) {
+  let e = 0;
+  return pe(t, function(n) {
+    let r = n.type;
+    if (!(r === An || r === Yo)) {
+      if (e++, (r === Zr || r === Yr || r === Je) && we(n.name) && e++, r === Xr)
+        return n.value && e++, this.skip;
+      if (r === Je && ni.has(n.name)) {
+        let i = ti(n, ii);
+        if (i.length === 0) return;
+        for (let o of i)
+          e += o;
+        return this.skip;
+      }
+    }
+  }), e;
+}
+function oa(t, e) {
+  pe(t, function(n, r) {
+    if (n.type === Xo) {
+      let i = n.loc, o = n.name;
+      if (i === null) {
+        let a = r.prev.data.loc.end, f = {
+          offset: a.offset,
+          line: a.line,
+          column: a.column
+        };
+        e({
+          name: o,
+          loc: {
+            start: f,
+            end: {
+              offset: f.offset + 1,
+              line: f.line,
+              column: f.column + 1
+            }
+          }
+        });
+      } else
+        e({
+          name: o,
+          loc: i
+        });
+    }
+  });
+}
+const aa = new le([
+  // CSS Named Colors
+  // Spec: https://drafts.csswg.org/css-color/#named-colors
+  // Heuristic: popular names first for quick finding in set.has()
+  // See: https://docs.google.com/spreadsheets/d/1OU8ahxC5oYU8VRryQs9BzHToaXcOntVlh6KUHjm15G4/edit#gid=2096495459
+  "white",
+  "black",
+  "red",
+  "gray",
+  "silver",
+  "grey",
+  "green",
+  "orange",
+  "blue",
+  "dimgray",
+  "whitesmoke",
+  "lightgray",
+  "lightgrey",
+  "yellow",
+  "gold",
+  "pink",
+  "gainsboro",
+  "magenta",
+  "purple",
+  "darkgray",
+  "navy",
+  "darkred",
+  "teal",
+  "maroon",
+  "darkgrey",
+  "tomato",
+  "darkorange",
+  "brown",
+  "crimson",
+  "lightyellow",
+  "slategray",
+  "salmon",
+  "lightgreen",
+  "lightblue",
+  "orangered",
+  "aliceblue",
+  "dodgerblue",
+  "lime",
+  "darkblue",
+  "darkgoldenrod",
+  "skyblue",
+  "royalblue",
+  "darkgreen",
+  "ivory",
+  "olive",
+  "aqua",
+  "turquoise",
+  "cyan",
+  "khaki",
+  "beige",
+  "snow",
+  "ghostwhite",
+  "limegreen",
+  "coral",
+  "dimgrey",
+  "hotpink",
+  "midnightblue",
+  "firebrick",
+  "indigo",
+  "wheat",
+  "mediumblue",
+  "lightpink",
+  "plum",
+  "azure",
+  "violet",
+  "lavender",
+  "deepskyblue",
+  "darkslategrey",
+  "goldenrod",
+  "cornflowerblue",
+  "lightskyblue",
+  "indianred",
+  "yellowgreen",
+  "saddlebrown",
+  "palegreen",
+  "bisque",
+  "tan",
+  "antiquewhite",
+  "steelblue",
+  "forestgreen",
+  "fuchsia",
+  "mediumaquamarine",
+  "seagreen",
+  "sienna",
+  "deeppink",
+  "mediumseagreen",
+  "peru",
+  "greenyellow",
+  "lightgoldenrodyellow",
+  "orchid",
+  "cadetblue",
+  "navajowhite",
+  "lightsteelblue",
+  "slategrey",
+  "linen",
+  "lightseagreen",
+  "darkcyan",
+  "lightcoral",
+  "aquamarine",
+  "blueviolet",
+  "cornsilk",
+  "lightsalmon",
+  "chocolate",
+  "lightslategray",
+  "floralwhite",
+  "darkturquoise",
+  "darkslategray",
+  "rebeccapurple",
+  "burlywood",
+  "chartreuse",
+  "lightcyan",
+  "lemonchiffon",
+  "palevioletred",
+  "darkslateblue",
+  "mediumpurple",
+  "lawngreen",
+  "slateblue",
+  "darkseagreen",
+  "blanchedalmond",
+  "mistyrose",
+  "darkolivegreen",
+  "seashell",
+  "olivedrab",
+  "peachpuff",
+  "darkviolet",
+  "powderblue",
+  "darkmagenta",
+  "lightslategrey",
+  "honeydew",
+  "palegoldenrod",
+  "darkkhaki",
+  "oldlace",
+  "mintcream",
+  "sandybrown",
+  "mediumturquoise",
+  "papayawhip",
+  "paleturquoise",
+  "mediumvioletred",
+  "thistle",
+  "springgreen",
+  "moccasin",
+  "rosybrown",
+  "lavenderblush",
+  "mediumslateblue",
+  "darkorchid",
+  "mediumorchid",
+  "darksalmon",
+  "mediumspringgreen"
+]), la = new le([
+  // CSS System Colors
+  // Spec: https://drafts.csswg.org/css-color/#css-system-colors
+  "accentcolor",
+  "accentcolortext",
+  "activetext",
+  "buttonborder",
+  "buttonface",
+  "buttontext",
+  "canvas",
+  "canvastext",
+  "field",
+  "fieldtext",
+  "graytext",
+  "highlight",
+  "highlighttext",
+  "linktext",
+  "mark",
+  "marktext",
+  "selecteditem",
+  "selecteditemtext",
+  "visitedtext"
+]), ca = new le([
+  "rgba",
+  "rgb",
+  "hsla",
+  "hsl",
+  "oklch",
+  "color",
+  "hwb",
+  "lch",
+  "lab",
+  "oklab"
+]), ua = new le([
+  "transparent",
+  "currentcolor"
+]), At = new le([
+  "auto",
+  "none",
+  // for `text-shadow`, `box-shadow` and `background`
+  "inherit",
+  "initial",
+  "unset",
+  "revert",
+  "revert-layer"
+]);
+function ut(t) {
+  let e = t.children, n = e.size;
+  if (!e || n > 1 || n === 0) return !1;
+  let r = e.first;
+  return r.type === de && At.has(r.name);
+}
+const ha = new le([
+  "caption",
+  "icon",
+  "menu",
+  "message-box",
+  "small-caption",
+  "status-bar"
+]), fa = new le([
+  /* <absolute-size> values */
+  "xx-small",
+  "x-small",
+  "small",
+  "medium",
+  "large",
+  "x-large",
+  "xx-large",
+  "xxx-large",
+  /* <relative-size> values */
+  "smaller",
+  "larger"
+]), pa = 44, Ar = 47;
+function sn(t) {
+  let e = t.children.first;
+  return e === null ? !1 : e.type === de && ha.has(e.name);
+}
+function da(t, e, n) {
+  let r = Array.from({ length: 2 }), i, o;
+  t.children.forEach(function(f, c) {
+    let s = c.prev ? c.prev.data : void 0, l = c.next ? c.next.data : void 0;
+    if (f.type === de && At.has(f.name) && n({
+      type: "keyword",
+      value: f.name
+    }), l && l.type === ze && l.value.charCodeAt(0) === Ar) {
+      i = e(f);
+      return;
+    }
+    if (s && s.type === ze && s.value.charCodeAt(0) === Ar) {
+      o = e(f);
+      return;
+    }
+    if (l && l.type === ze && l.value.charCodeAt(0) === pa && !r[0]) {
+      r[0] = f, !i && s && (i = e(s));
+      return;
+    }
+    if (f.type !== Zo) {
+      if (c.next === null) {
+        r[1] = f, !i && !r[0] && s && (i = e(s));
+        return;
+      }
+      if (f.type === de) {
+        let m = f.name;
+        if (fa.has(m)) {
+          i = m;
+          return;
+        }
+      }
+    }
+  });
+  let a = r[0] || r[1] ? e({
+    loc: {
+      start: {
+        offset: (r[0] || r[1]).loc.start.offset
+      },
+      end: {
+        offset: r[1].loc.end.offset
+      }
+    }
+  }) : null;
+  return {
+    font_size: i,
+    line_height: o,
+    font_family: a
+  };
+}
+const ma = new le([
+  "linear",
+  "ease",
+  "ease-in",
+  "ease-out",
+  "ease-in-out",
+  "step-start",
+  "step-end"
+]), ga = new le([
+  "cubic-bezier",
+  "steps"
+]);
+function ka(t, e) {
+  let n = !1;
+  for (let r of t) {
+    let i = r.type, o = r.name;
+    i === ze ? n = !1 : i === ei && n === !1 ? (n = !0, e({
+      type: "duration",
+      value: r
+    })) : i === de ? ma.has(o) ? e({
+      type: "fn",
+      value: r
+    }) : At.has(o) && e({
+      type: "keyword",
+      value: r
+    }) : i === Ln && ga.has(o) && e({
+      type: "fn",
+      value: r
+    });
+  }
+}
+function si(t) {
+  let e = t.children;
+  if (!e)
+    return !1;
+  for (let n of e) {
+    let { type: r, name: i } = n;
+    if (r === de && we(i) || r === Ln && (we(i) || si(n)))
+      return !0;
+  }
+  return !1;
+}
+class x {
+  /** @param {boolean} useLocations */
+  constructor(e = !1) {
+    this._items = /* @__PURE__ */ new Map(), this._total = 0, e && (this._nodes = []), this._useLocations = e;
+  }
+  /**
+   * @param {string} item
+   * @param {import('css-tree').CssLocation} node_location
+   */
+  p(e, n) {
+    let r = this._total;
+    if (this._useLocations) {
+      let i = n.start, o = i.offset, a = r * 4;
+      this._nodes[a] = i.line, this._nodes[a + 1] = i.column, this._nodes[a + 2] = o, this._nodes[a + 3] = n.end.offset - o;
+    }
+    if (this._items.has(e)) {
+      this._items.get(e).push(r), this._total++;
+      return;
+    }
+    this._items.set(e, [r]), this._total++;
+  }
+  size() {
+    return this._total;
+  }
+  /**
+   * @typedef CssLocation
+   * @property {number} line
+   * @property {number} column
+   * @property {number} offset
+   * @property {number} length
+   *
+   * @returns {{
+   * 	total: number;
+   * 	totalUnique: number;
+   * 	uniquenessRatio: number;
+   * 	unique: Record<string, number>;
+   * } & ({
+   * 	uniqueWithLocations: Record<string, CssLocation[]>
+   * } | {
+   * 	uniqueWithLocations?: undefined
+   * })}
+   */
+  c() {
+    let e = /* @__PURE__ */ new Map(), n = {}, r = this._useLocations, i = this._items, o = this._nodes, a = i.size;
+    i.forEach((s, l) => {
+      if (r) {
+        let m = s.map(function(y) {
+          let C = y * 4;
+          return {
+            line: o[C],
+            column: o[C + 1],
+            offset: o[C + 2],
+            length: o[C + 3]
+          };
+        });
+        e.set(l, m);
+      } else
+        n[l] = s.length;
+    });
+    let f = this._total, c = {
+      total: f,
+      totalUnique: a,
+      unique: n,
+      uniquenessRatio: f === 0 ? 0 : a / f
+    };
+    return r && (c.uniqueWithLocations = Object.fromEntries(e)), c;
+  }
+}
+class on {
+  /** @param {boolean} useLocations */
+  constructor(e) {
+    this._list = new x(e), this._contexts = /* @__PURE__ */ new Map(), this._useLocations = e;
+  }
+  /**
+   * Add an item to this _list's context
+   * @param {string} item Item to push
+   * @param {string} context Context to push Item to
+   * @param {import('css-tree').CssLocation} node_location
+   */
+  push(e, n, r) {
+    this._list.p(e, r), this._contexts.has(n) || this._contexts.set(n, new x(this._useLocations)), this._contexts.get(n).p(e, r);
+  }
+  count() {
+    let e = /* @__PURE__ */ new Map();
+    for (let [n, r] of this._contexts.entries())
+      e.set(n, r.c());
+    return Object.assign(this._list.c(), {
+      itemsPerContext: Object.fromEntries(e)
+    });
+  }
+}
+function ya(t) {
+  let e = /* @__PURE__ */ new Map(), n = -1, r = 0, i = 0, o = t.length;
+  for (let a = 0; a < o; a++) {
+    let f = t[a], c = (e.get(f) || 0) + 1;
+    e.set(f, c), c > n && (n = c, r = 0, i = 0), c >= n && (r++, i += f);
+  }
+  return i / r;
+}
+class ie {
+  constructor() {
+    this._items = [], this._sum = 0;
+  }
+  /**
+   * Add a new Integer at the end of this AggregateCollection
+   * @param {number} item - The item to add
+   */
+  push(e) {
+    this._items.push(e), this._sum += e;
+  }
+  size() {
+    return this._items.length;
+  }
+  aggregate() {
+    let e = this._items.length;
+    if (e === 0)
+      return {
+        min: 0,
+        max: 0,
+        mean: 0,
+        mode: 0,
+        range: 0,
+        sum: 0
+      };
+    let n = this._items.slice().sort((f, c) => f - c), r = n[0], i = n[e - 1], o = ya(n), a = this._sum;
+    return {
+      min: r,
+      max: i,
+      mean: a / e,
+      mode: o,
+      range: i - r,
+      sum: a
+    };
+  }
+  /**
+   * @returns {number[]} All _items in this collection
+   */
+  toArray() {
+    return this._items;
+  }
+}
+function Sa(t) {
+  if (En(t) || we(t)) return !1;
+  let e = t.charCodeAt(0);
+  return e === 47 || e === 42 || e === 95 || e === 43 || e === 38 || e === 36 || e === 35;
+}
+function En(t) {
+  return t.length < 3 ? !1 : t.charCodeAt(0) === 45 && t.charCodeAt(1) === 45;
+}
+function G(t, e) {
+  return En(e) ? !1 : ke(t, e);
+}
+function xa(t) {
+  return we(t) ? t.slice(t.indexOf("-", 2) + 1) : t;
+}
+function Ca(t) {
+  let e = 5, n = t.indexOf(";"), r = t.indexOf(",");
+  return n === -1 || r !== -1 && r < n ? t.substring(e, r) : t.substring(e, n);
+}
+function ba(t) {
+  let e = t.children;
+  if (e) {
+    let n = e.last;
+    return n && n.type === de && ke("\\9", n.name);
+  }
+  return !1;
+}
+let wa = new le([
+  "border-radius",
+  "border-top-left-radius",
+  "border-top-right-radius",
+  "border-bottom-right-radius",
+  "border-bottom-left-radius",
+  "border-start-start-radius",
+  "border-start-end-radius",
+  "border-end-end-radius",
+  "border-end-start-radius"
+]);
+function B(t, e) {
+  return e === 0 ? 0 : t / e;
+}
+let va = {
+  useLocations: !1
+};
+function Ea(t, e = {}) {
+  let r = Object.assign({}, va, e).useLocations === !0, i = Date.now();
+  function o(d) {
+    return a(d).trim();
+  }
+  function a(d) {
+    let w = d.loc;
+    return t.substring(w.start.offset, w.end.offset);
+  }
+  let f = 0, c = 0, s = 0, l = {
+    total: 0,
+    /** @type {Map<string, { size: number, count: number } & ({ uniqueWithLocations?: undefined } | ({ uniqueWithLocations: { offset: number, line: number, column: number, length: number }[] })) }>} */
+    unique: /* @__PURE__ */ new Map()
+  }, m = Date.now(), y = oi(t, {
+    parseCustomProperty: !0,
+    // To find font-families, colors, etc.
+    positions: !0,
+    // So we can use stringifyNode()
+    /** @param {string} comment */
+    onComment: function(d) {
+      f++, c += d.length;
+    }
+  }), C = Date.now(), _ = y.loc.end.line - y.loc.start.line + 1, q = 0, V = new ie(), me = [], Oe = new x(r), Be = new x(r), Y = new x(r), Ze = new x(r), et = new x(r), tt = new x(r), u = new x(r), h = new x(r), g = new x(r), p = new x(r), X = new x(r), j = new x(r), xe = 0, R = 0, Ce = new ie(), ge = new ie(), Lt = new ie(), _n = new x(r), Tn = new x(r), On = new x(r), Et = new x(r), In = /* @__PURE__ */ new Set(), _t = new x(r), ve, Ae, $n = new ie(), Nn = new ie(), Dn = new ie(), Pn = new x(r), nt = new ie(), Mn = new x(r), Fn = [], Tt = new x(r), Ot = new x(r), zn = new x(r), Rn = new x(r), qn = /* @__PURE__ */ new Set(), je = 0, Bn = new ie(), rt = 0, It = 0, $t = new x(r), Ue = new x(r), Nt = new x(r), Dt = new x(r), it = new x(r), Ve = new ie(), Pt = new ie(), jn = new x(r), Mt = new x(r), Un = new x(r), Vn = new x(r), Gn = new x(r), Ft = new x(r), zt = new x(r), Rt = new x(r), st = new x(r), ot = new x(r), Ie = new on(r), $e = new x(r), qt = new on(r), Hn = new x(r), Ge = new x(r), Wn = new on(r);
+  pe(y, function(d) {
+    switch (d.type) {
+      case Ho: {
+        q++;
+        let w = d.name;
+        if (w === "font-face") {
+          let T = {};
+          r && Oe.p(d.loc.start.offset, d.loc), d.block.children.forEach((A) => {
+            A.type === pn && (T[A.property] = o(A.value));
+          }), me.push(T), V.push(1);
+          break;
+        }
+        let S = 1;
+        if (d.prelude !== null) {
+          let T = d.prelude, A = T && o(d.prelude), v = T.loc;
+          if (w === "media")
+            Ze.p(A, v), ra(T) && (et.p(A, v), S++);
+          else if (w === "supports")
+            u.p(A, v), na(T) && (h.p(A, v), S++);
+          else if (ke("keyframes", w)) {
+            let b = "@" + w + " " + A;
+            we(w) && (p.p(b, v), S++), g.p(b, v);
+          } else w === "import" ? Y.p(A, v) : w === "charset" ? tt.p(A, v) : w === "container" ? X.p(A, v) : w === "layer" ? A.split(",").forEach((b) => Be.p(b.trim(), v)) : w === "property" && j.p(A, v);
+        } else
+          w === "layer" && (Be.p("<anonymous>", d.loc), S++);
+        V.push(S);
+        break;
+      }
+      case Qo: {
+        let w = d.prelude, S = d.block, T = w.children, A = S.children, v = T ? T.size : 0, b = A ? A.size : 0;
+        Ce.push(v + b), _n.p(v + b, d.loc), ge.push(v), Tn.p(v, w.loc), Lt.push(b), On.p(b, S.loc), xe++, b === 0 && R++;
+        break;
+      }
+      case An: {
+        let w = o(d);
+        if (this.atrule && ke("keyframes", this.atrule.name))
+          return Et.p(w, d.loc), this.skip;
+        ri(d) && Ot.p(w, d.loc);
+        let S = sa(d);
+        if (S !== !1)
+          for (let Z of S)
+            zn.p(Z, d.loc);
+        let T = ii(d);
+        ia(d) && _t.p(w, d.loc), In.add(w), nt.push(T), Mn.p(T, d.loc);
+        let [{ value: A }] = Me(d), v = A.a, b = A.b, L = A.c, D = [v, b, L];
+        return Pn.p(v + "," + b + "," + L, d.loc), $n.push(v), Nn.push(b), Dn.push(L), ve === void 0 && (ve = D), Ae === void 0 && (Ae = D), Ae !== void 0 && Lr(Ae, D) < 0 && (Ae = D), ve !== void 0 && Lr(ve, D) > 0 && (ve = D), Fn.push(D), v > 0 && Tt.p(w, d.loc), oa(d, function(re) {
+          Rn.p(re.name, re.loc);
+        }), this.skip;
+      }
+      case ei: {
+        if (!this.declaration)
+          break;
+        let w = d.unit;
+        return ke("\\9", w) ? qt.push(w.substring(0, w.length - 2), this.declaration.property, d.loc) : qt.push(w, this.declaration.property, d.loc), this.skip;
+      }
+      case ta: {
+        if (vn("data:", d.value)) {
+          let w = d.value, S = w.length, T = Ca(w);
+          l.total++, s += S;
+          let A = {
+            /** @type {number} */
+            line: d.loc.start.line,
+            /** @type {number} */
+            column: d.loc.start.column,
+            /** @type {number} */
+            offset: d.loc.start.offset,
+            /** @type {number} */
+            length: d.loc.end.offset - d.loc.start.offset
+          };
+          if (l.unique.has(T)) {
+            let v = l.unique.get(T);
+            v.count++, v.size += S, l.unique.set(T, v), r && v.uniqueWithLocations.push(A);
+          } else {
+            let v = {
+              count: 1,
+              size: S
+            };
+            r && (v.uniqueWithLocations = [A]), l.unique.set(T, v);
+          }
+        }
+        break;
+      }
+      case Jo: {
+        if (ut(d)) {
+          Pt.push(1), Ge.p(o(d), d.loc);
+          break;
+        }
+        let w = this.declaration, { property: S, important: T } = w, A = 1;
+        si(d) && (jn.p(o(d), d.loc), A++), typeof T == "string" && (Mt.p(a(d) + "!" + T, d.loc), A++), ba(d) && (Mt.p(o(d), d.loc), A++);
+        let v = d.children, b = d.loc;
+        if (Pt.push(A), G("z-index", S))
+          return Un.p(o(d), b), this.skip;
+        if (G("font", S)) {
+          if (sn(d)) return;
+          let { font_size: L, line_height: D, font_family: Z } = da(d, o, function(re) {
+            re.type === "keyword" && Ge.p(re.value, b);
+          });
+          Z && Ft.p(Z, b), L && zt.p(L, b), D && Rt.p(D, b);
+          break;
+        } else if (G("font-size", S)) {
+          sn(d) || zt.p(o(d), b);
+          break;
+        } else if (G("font-family", S)) {
+          sn(d) || Ft.p(o(d), b);
+          break;
+        } else if (G("line-height", S))
+          Rt.p(o(d), b);
+        else if (G("transition", S) || G("animation", S)) {
+          ka(v, function(L) {
+            L.type === "fn" ? st.p(o(L.value), b) : L.type === "duration" ? ot.p(o(L.value), b) : L.type === "keyword" && Ge.p(o(L.value), b);
+          });
+          break;
+        } else if (G("animation-duration", S) || G("transition-duration", S)) {
+          v && v.size > 1 ? v.forEach((L) => {
+            L.type !== ze && ot.p(o(L), b);
+          }) : ot.p(o(d), b);
+          break;
+        } else if (G("transition-timing-function", S) || G("animation-timing-function", S)) {
+          v && v.size > 1 ? v.forEach((L) => {
+            L.type !== ze && st.p(o(L), b);
+          }) : st.p(o(d), b);
+          break;
+        } else if (wa.has(xa(S))) {
+          ut(d) || Wn.push(o(d), S, b);
+          break;
+        } else G("text-shadow", S) ? ut(d) || Vn.p(o(d), b) : G("box-shadow", S) && (ut(d) || Gn.p(o(d), b));
+        pe(d, function(L) {
+          let D = L.name;
+          switch (L.type) {
+            case ea: {
+              let Z = L.value.length;
+              return ke("\\9", L.value) && (Z = Z - 2), Ie.push("#" + L.value, S, b), $e.p("hex" + Z, b), this.skip;
+            }
+            case de: {
+              At.has(D) && Ge.p(D, b);
+              let Z = D.length;
+              if (Z > 20 || Z < 3)
+                return this.skip;
+              if (ua.has(D)) {
+                let re = o(L);
+                Ie.push(re, S, b), $e.p(D.toLowerCase(), b);
+                return;
+              }
+              if (aa.has(D)) {
+                let re = o(L);
+                Ie.push(re, S, b), $e.p("named", b);
+                return;
+              }
+              if (la.has(D)) {
+                let re = o(L);
+                Ie.push(re, S, b), $e.p("system", b);
+                return;
+              }
+              return this.skip;
+            }
+            case Ln: {
+              if (W("var", D))
+                return this.skip;
+              if (ca.has(D)) {
+                Ie.push(o(L), S, L.loc), $e.p(D.toLowerCase(), L.loc);
+                return;
+              }
+              if (ke("gradient", D)) {
+                Hn.p(o(L), L.loc);
+                return;
+              }
+            }
+          }
+        });
+        break;
+      }
+      case pn: {
+        if (this.atrulePrelude !== null)
+          return this.skip;
+        je++;
+        let w = 1;
+        qn.add(o(d)), d.important === !0 && (rt++, w++, this.atrule && ke("keyframes", this.atrule.name) && (It++, w++)), Bn.push(w);
+        let { property: S, loc: { start: T } } = d, A = {
+          start: {
+            line: T.line,
+            column: T.column,
+            offset: T.offset
+          },
+          end: {
+            offset: T.offset + S.length
+          }
+        };
+        Ue.p(S, A), we(S) ? (Dt.p(S, A), Ve.push(2)) : Sa(S) ? (Nt.p(S, A), Ve.push(2)) : En(S) ? (it.p(S, A), Ve.push(d.important ? 3 : 2), d.important === !0 && $t.p(S, A)) : Ve.push(1);
+        break;
+      }
+    }
+  });
+  let Kn = qn.size, Ne = nt.size(), Bt = $n.aggregate(), jt = Nn.aggregate(), Ut = Dn.aggregate(), Qn = In.size, F = Object.assign, Jn = t.length, Vt = me.length, Yn = V.aggregate(), Xn = nt.aggregate(), Zn = Bn.aggregate(), er = Ve.aggregate(), tr = Pt.aggregate();
+  return {
+    stylesheet: {
+      sourceLinesOfCode: q + Ne + je + Et.size(),
+      linesOfCode: _,
+      size: Jn,
+      complexity: Yn.sum + Xn.sum + Zn.sum + er.sum + tr.sum,
+      comments: {
+        total: f,
+        size: c
+      },
+      embeddedContent: {
+        size: {
+          total: s,
+          ratio: B(s, Jn)
+        },
+        types: {
+          total: l.total,
+          totalUnique: l.unique.size,
+          uniquenessRatio: B(l.unique.size, l.total),
+          unique: Object.fromEntries(l.unique)
+        }
+      }
+    },
+    atrules: {
+      fontface: F({
+        total: Vt,
+        totalUnique: Vt,
+        unique: me,
+        uniquenessRatio: Vt === 0 ? 0 : 1
+      }, r ? {
+        uniqueWithLocations: Oe.c().uniqueWithLocations
+      } : {}),
+      import: Y.c(),
+      media: F(
+        Ze.c(),
+        {
+          browserhacks: et.c()
+        }
+      ),
+      charset: tt.c(),
+      supports: F(
+        u.c(),
+        {
+          browserhacks: h.c()
+        }
+      ),
+      keyframes: F(
+        g.c(),
+        {
+          prefixed: F(
+            p.c(),
+            {
+              ratio: B(p.size(), g.size())
+            }
+          )
+        }
+      ),
+      container: X.c(),
+      layer: Be.c(),
+      property: j.c(),
+      total: q,
+      complexity: Yn
+    },
+    rules: {
+      total: xe,
+      empty: {
+        total: R,
+        ratio: B(R, xe)
+      },
+      sizes: F(
+        Ce.aggregate(),
+        {
+          items: Ce.toArray()
+        },
+        _n.c()
+      ),
+      selectors: F(
+        ge.aggregate(),
+        {
+          items: ge.toArray()
+        },
+        Tn.c()
+      ),
+      declarations: F(
+        Lt.aggregate(),
+        {
+          items: Lt.toArray()
+        },
+        On.c()
+      )
+    },
+    selectors: {
+      total: Ne,
+      totalUnique: Qn,
+      uniquenessRatio: B(Qn, Ne),
+      specificity: F(
+        {
+          /** @type Specificity */
+          min: Ae === void 0 ? [0, 0, 0] : Ae,
+          /** @type Specificity */
+          max: ve === void 0 ? [0, 0, 0] : ve,
+          /** @type Specificity */
+          sum: [Bt.sum, jt.sum, Ut.sum],
+          /** @type Specificity */
+          mean: [Bt.mean, jt.mean, Ut.mean],
+          /** @type Specificity */
+          mode: [Bt.mode, jt.mode, Ut.mode],
+          /** @type Specificity */
+          items: Fn
+        },
+        Pn.c()
+      ),
+      complexity: F(
+        Xn,
+        Mn.c(),
+        {
+          items: nt.toArray()
+        }
+      ),
+      id: F(
+        Tt.c(),
+        {
+          ratio: B(Tt.size(), Ne)
+        }
+      ),
+      pseudoClasses: zn.c(),
+      accessibility: F(
+        Ot.c(),
+        {
+          ratio: B(Ot.size(), Ne)
+        }
+      ),
+      keyframes: Et.c(),
+      prefixed: F(
+        _t.c(),
+        {
+          ratio: B(_t.size(), Ne)
+        }
+      ),
+      combinators: Rn.c()
+    },
+    declarations: {
+      total: je,
+      totalUnique: Kn,
+      uniquenessRatio: B(Kn, je),
+      importants: {
+        total: rt,
+        ratio: B(rt, je),
+        inKeyframes: {
+          total: It,
+          ratio: B(It, rt)
+        }
+      },
+      complexity: Zn
+    },
+    properties: F(
+      Ue.c(),
+      {
+        prefixed: F(
+          Dt.c(),
+          {
+            ratio: B(Dt.size(), Ue.size())
+          }
+        ),
+        custom: F(
+          it.c(),
+          {
+            ratio: B(it.size(), Ue.size()),
+            importants: F(
+              $t.c(),
+              {
+                ratio: B($t.size(), it.size())
+              }
+            )
+          }
+        ),
+        browserhacks: F(
+          Nt.c(),
+          {
+            ratio: B(Nt.size(), Ue.size())
+          }
+        ),
+        complexity: er
+      }
+    ),
+    values: {
+      colors: F(
+        Ie.count(),
+        {
+          formats: $e.c()
+        }
+      ),
+      gradients: Hn.c(),
+      fontFamilies: Ft.c(),
+      fontSizes: zt.c(),
+      lineHeights: Rt.c(),
+      zindexes: Un.c(),
+      textShadows: Vn.c(),
+      boxShadows: Gn.c(),
+      borderRadiuses: Wn.count(),
+      animations: {
+        durations: ot.c(),
+        timingFunctions: st.c()
+      },
+      prefixes: jn.c(),
+      browserhacks: Mt.c(),
+      units: qt.count(),
+      complexity: tr,
+      keywords: Ge.c()
+    },
+    __meta__: {
+      parseTime: C - m,
+      analyzeTime: Date.now() - C,
+      total: Date.now() - i
+    }
+  };
+}
+function Lr(t, e) {
+  return t[0] === e[0] ? t[1] === e[1] ? e[2] - t[2] : e[1] - t[1] : e[0] - t[0];
+}
+export {
+  Ea as analyze,
+  Lr as compareSpecificity,
+  we as hasVendorPrefix,
+  ri as isAccessibilitySelector,
+  ra as isMediaBrowserhack,
+  Sa as isPropertyHack,
+  ia as isSelectorPrefixed,
+  na as isSupportsBrowserhack,
+  si as isValuePrefixed,
+  ii as selectorComplexity
+};