npm - @projectwallace/css-analyzer - Versions diffs - 7.6.3 → 8.0.1 - Mend

@projectwallace/css-analyzer 7.6.3 → 8.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/css-analyzer.js CHANGED Viewed

@@ -1,188 +1,1812 @@
-var pi = Object.defineProperty;
-var Zt = (i) => {
-  throw TypeError(i);
+var ar = Object.defineProperty;
+var pi = (r) => {
+  throw TypeError(r);
 };
-var hi = (i, e, t) => e in i ? pi(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
-var $t = (i, e, t) => hi(i, typeof e != "symbol" ? e + "" : e, t), Jt = (i, e, t) => e.has(i) || Zt("Cannot " + t);
-var m = (i, e, t) => (Jt(i, e, "read from private field"), t ? t.call(i) : e.get(i)), I = (i, e, t) => e.has(i) ? Zt("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(i) : e.set(i, t), R = (i, e, t, r) => (Jt(i, e, "write to private field"), r ? r.call(i, t) : e.set(i, t), t);
-var Ye = (i, e, t, r) => ({
-  set _(n) {
-    R(i, e, n, t);
+var hr = (r, e, t) => e in r ? ar(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var g = (r, e, t) => hr(r, typeof e != "symbol" ? e + "" : e, t), di = (r, e, t) => e.has(r) || pi("Cannot " + t);
+var w = (r, e, t) => (di(r, e, "read from private field"), t ? t.call(r) : e.get(r)), G = (r, e, t) => e.has(r) ? pi("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(r) : e.set(r, t), M = (r, e, t, s) => (di(r, e, "write to private field"), s ? s.call(r, t) : e.set(r, t), t);
+var Vt = (r, e, t, s) => ({
+  set _(i) {
+    M(r, e, i, t);
   },
   get _() {
-    return m(i, e, r);
+    return w(r, e, s);
   }
 });
-import mi from "css-tree/parser";
-import C from "css-tree/walker";
-import { calculateForAST as gi } from "@bramus/specificity/core";
-import { walk as li } from "css-tree";
-function Je(i, e) {
-  return e >= 65 && e <= 90 && (e = e | 32), i === e;
-}
-function q(i, e) {
-  if (i === e) return !0;
-  let t = i.length;
-  if (t !== e.length) return !1;
-  for (let r = 0; r < t; r++)
-    if (Je(i.charCodeAt(r), e.charCodeAt(r)) === !1)
-      return !1;
-  return !0;
-}
-function M(i, e) {
-  if (i === e) return !0;
-  let t = e.length, r = t - i.length;
-  if (r < 0)
-    return !1;
-  for (let n = t - 1; n >= r; n--)
-    if (Je(i.charCodeAt(n - r), e.charCodeAt(n)) === !1)
-      return !1;
-  return !0;
-}
-function Xe(i, e) {
-  if (i === e) return !0;
-  let t = i.length;
-  if (e.length < t) return !1;
-  for (let r = 0; r < t; r++)
-    if (Je(i.charCodeAt(r), e.charCodeAt(r)) === !1)
-      return !1;
-  return !0;
-}
-const Ge = "Atrule", di = "MediaQuery", Qe = "Rule", yi = "Selector", wi = "Value", W = "Identifier", ki = "Nth", bi = "Combinator", ni = "Number", Le = "Dimension", Z = "Operator", xi = "Hash", Ci = "Url", et = "Function";
-function Xt(i, e, t) {
-  let r = i.value.children.first;
-  return q(e, i.property) && r.type === W && q(t, r.name);
-}
-function vi(i) {
+import { walk as B, SUPPORTS_QUERY as Hi, BREAK as Q, MEDIA_TYPE as cr, MEDIA_FEATURE as Ii, str_equals as P, DIMENSION as ft, NUMBER as _s, IDENTIFIER as he, SELECTOR as ce, NTH_SELECTOR as _r, PSEUDO_ELEMENT_SELECTOR as us, TYPE_SELECTOR as fs, PSEUDO_CLASS_SELECTOR as Oe, ATTRIBUTE_SELECTOR as ps, SKIP as I, COMBINATOR as is, SELECTOR_LIST as ds, NTH_OF_SELECTOR as ur, CLASS_SELECTOR as fr, ID_SELECTOR as pr, FUNCTION as gs, OPERATOR as Ee, is_custom as xs, is_vendor_prefixed as ms, parse as dr, AT_RULE as gr, BLOCK as xr, DECLARATION as jt, LAYER_NAME as mr, CONTAINER_QUERY as kr, STYLE_RULE as wr, HASH as Ar, URL as yr, str_starts_with as Er } from "@projectwallace/css-parser";
+function Cr(r) {
   let e = !1;
-  return li(i, function(t) {
-    if (t.type === "Declaration" && (Xt(t, "-webkit-appearance", "none") || Xt(t, "-moz-appearance", "meterbar")))
-      return e = !0, this.break;
+  return B(r, function(t) {
+    if (t.type === Hi) {
+      const i = (t.prelude || t.value || "").toString().toLowerCase().replaceAll(/\s+/g, "");
+      if (i.includes("-webkit-appearance:none") || i.includes("-moz-appearance:meterbar"))
+        return e = !0, Q;
+    }
   }), e;
 }
-function Si(i) {
+function br(r) {
   let e = !1;
-  return li(i, function(t) {
-    let { mediaType: r, name: n, value: c, type: d, kind: w } = t;
-    if (d === di && r !== null) {
-      if (Xe("\\0", r) || M("\\9 ", r))
-        return e = !0, this.break;
-    } else if (d === "Feature" && w === "media") {
-      if (c && c.unit && c.unit === "\\0")
-        return e = !0, this.break;
-      if (q("-moz-images-in-menus", n) || q("min--moz-device-pixel-ratio", n) || q("-ms-high-contrast", n))
-        return e = !0, this.break;
-      if (q("min-resolution", n) && c && q(".001", c.value) && q("dpcm", c.unit))
-        return e = !0, this.break;
-      if (q("-webkit-min-device-pixel-ratio", n) && c && c.value && (q("0", c.value) || q("10000", c.value)))
-        return e = !0, this.break;
+  return B(r, function(t) {
+    if (t.type === cr) {
+      const s = t.text || "";
+      if (s.startsWith("\\0") || s.includes("\\9"))
+        return e = !0, Q;
+    }
+    if (t.type === Ii) {
+      const s = t.name || "";
+      if (P("-moz-images-in-menus", s) || P("min--moz-device-pixel-ratio", s) || P("-ms-high-contrast", s))
+        return e = !0, Q;
+      if (P("min-resolution", s) && t.has_children) {
+        for (const i of t)
+          if (i.type === ft && i.value === 1e-3 && P("dpcm", i.unit || ""))
+            return e = !0, Q;
+      }
+      if (P("-webkit-min-device-pixel-ratio", s) && t.has_children) {
+        for (const i of t)
+          if (i.type === _s && (i.value === 0 || i.value === 1e4))
+            return e = !0, Q;
+      }
+      if (t.has_children) {
+        for (const i of t)
+          if (i.type === he && i.text === "\\0")
+            return e = !0, Q;
+      }
     }
   }), e;
 }
-const Lt = 45;
-function N(i) {
-  return i.charCodeAt(0) === Lt && i.charCodeAt(1) !== Lt && i.indexOf("-", 2) !== -1;
-}
-class F {
+class $ {
   constructor(e) {
-    $t(this, "set");
+    g(this, "set");
     this.set = new Set(e);
   }
   has(e) {
     return this.set.has(e.toLowerCase());
   }
 }
-function si(i, e) {
-  let t = [];
-  return C(i, {
-    visit: "Selector",
-    enter: function(r) {
-      t.push(e(r));
-    }
-  }), t;
-}
-const ai = new F(["nth-child", "where", "not", "is", "has", "nth-last-child", "matches", "-webkit-any", "-moz-any"]);
-function oi(i) {
+const Pi = new $(["nth-child", "where", "not", "is", "has", "nth-last-child", "matches", "-webkit-any", "-moz-any"]);
+function Rr(r) {
   let e = !1;
-  return C(i, function(t) {
-    if (t.type === "AttributeSelector") {
-      let r = t.name.name;
-      if (q("role", r) || Xe("aria-", r))
-        return e = !0, C.break;
-    } else if (t.type === "PseudoClassSelector" && ai.has(t.name)) {
-      let r = si(t, oi);
-      for (let n of r)
-        if (n === !0) {
-          e = !0;
-          break;
-        }
-      return C.skip;
-    }
+  return B(r, function(t) {
+    if ((t.type === us || t.type === Oe || t.type === fs) && t.is_vendor_prefixed)
+      return e = !0, Q;
   }), e;
 }
-function zi(i) {
+function Di(r) {
   let e = !1;
-  return C(i, function(t) {
-    let r = t.type;
-    if ((r === "PseudoElementSelector" || r === "TypeSelector" || r === "PseudoClassSelector") && N(t.name))
-      return e = !0, C.break;
+  return B(r, function(t) {
+    if (t.type === ps) {
+      const s = t.name || "";
+      if (s === "role" || s.startsWith("aria-"))
+        return e = !0, Q;
+    } else if (t.type === Oe && Pi.has(t.name || "") && t.has_children) {
+      for (const s of t)
+        if (s.type === ce && Di(s))
+          return e = !0, Q;
+    }
   }), e;
 }
-function qi(i) {
+function vr(r) {
   let e = [];
-  return C(i, function(t) {
-    t.type === "PseudoClassSelector" && e.push(t.name);
+  return B(r, function(t) {
+    t.type === Oe && e.push(t.name);
   }), e.length === 0 ? !1 : e;
 }
-function ui(i) {
+function rs(r) {
   let e = 0;
-  return C(i, function(t) {
-    let r = t.type;
-    if (!(r === "Selector" || r === ki)) {
-      if (e++, (r === "PseudoElementSelector" || r === "TypeSelector" || r === "PseudoClassSelector") && N(t.name) && e++, r === "AttributeSelector")
-        return t.value && e++, C.skip;
-      if (r === "PseudoClassSelector" && ai.has(t.name)) {
-        let n = si(t, ui);
-        if (n.length === 0) return;
-        for (let c of n)
-          e += c;
-        return C.skip;
+  function t(s, i) {
+    B(s, function(n) {
+      n.type === ce && i.push(rs(n));
+    });
+  }
+  return B(r, function(s) {
+    const i = s.type;
+    if (i !== ce) {
+      if (i === _r) {
+        s.text && s.text.trim() && e++;
+        return;
+      }
+      if (e++, (i === us || i === fs || i === Oe) && s.is_vendor_prefixed && e++, i === ps)
+        return s.value && e++, I;
+      if (i === Oe) {
+        const n = s.name || "";
+        if (Pi.has(n.toLowerCase())) {
+          const l = [];
+          if (s.has_children)
+            for (const o of s)
+              o.type === ce ? l.push(rs(o)) : t(o, l);
+          if (l.length > 0) {
+            for (const o of l)
+              e += o;
+            return I;
+          }
+        }
       }
     }
   }), e;
 }
-function Ai(i, e) {
-  C(i, function(t, r) {
-    if (t.type === bi) {
-      let n = t.loc, c = t.name;
-      if (n === null) {
-        let d = r.prev.data.loc.end, w = {
-          offset: d.offset,
-          line: d.line,
-          column: d.column
-        };
-        e({
-          name: c,
-          // @ts-expect-error TODO: fix this
-          loc: {
-            start: w,
-            end: {
-              offset: w.offset + 1,
-              line: w.line,
-              column: w.column + 1
-            }
+function Tr(r, e) {
+  B(r, function(t) {
+    t.type === is && e({
+      name: t.name.trim() === "" ? " " : t.name,
+      loc: {
+        offset: t.start,
+        line: t.line,
+        column: t.column,
+        length: 1
+      }
+    });
+  });
+}
+let ks = 1, q = 2, pt = 4, Ce = 8, ge = 16, y = new Uint8Array(128);
+for (let r = 48; r <= 57; r++)
+  y[r] = q;
+for (let r = 48; r <= 57; r++)
+  y[r] |= pt;
+for (let r = 65; r <= 70; r++)
+  y[r] = pt;
+for (let r = 97; r <= 102; r++)
+  y[r] = pt;
+for (let r = 65; r <= 90; r++)
+  y[r] |= ks;
+for (let r = 97; r <= 122; r++)
+  y[r] |= ks;
+y[32] = Ce;
+y[9] = Ce;
+y[10] = ge;
+y[13] = ge;
+y[12] = ge;
+function Or(r) {
+  return r < 128 && (y[r] & q) !== 0;
+}
+function et(r) {
+  return r < 128 && (y[r] & pt) !== 0;
+}
+function Sr(r) {
+  return r < 128 && (y[r] & ks) !== 0;
+}
+function gi(r) {
+  return r < 128 && (y[r] & Ce) !== 0;
+}
+function ie(r) {
+  return r < 128 && (y[r] & ge) !== 0;
+}
+function Me(r) {
+  return r >= 128 || r === 95 ? !0 : Sr(r);
+}
+function tt(r) {
+  return r === 45 ? !0 : Me(r) || Or(r);
+}
+const le = 1, rt = 2, Nr = 3, Fi = 4, Mi = 5, xi = 6, de = 9, nt = 10, qi = 11, zi = 12, ns = 13, Ur = 14, Lr = 15, Ki = 16, Hr = 17, qe = 18, ls = 19, Bi = 20, $i = 21, Gi = 22, Ir = 23, Pr = 24, os = 26, Dr = 123, Fr = 125, Mr = 58, qr = 59, zr = 44, Kr = 91, Br = 93, mi = 40, $r = 41, ki = 47, wi = 42, Gr = 34, Yr = 39, Xt = 46, Wr = 60, Qr = 33, K = 45, Vr = 62, jr = 64, Xr = 35, Zt = 92, st = 43, Zr = 37, Jr = 101, en = 69, Ai = 13, yi = 10;
+class Yi {
+  constructor(e, t) {
+    g(this, "source");
+    g(this, "pos");
+    g(this, "line");
+    g(this, "column");
+    g(this, "on_comment");
+    // Current token properties (avoiding object allocation)
+    g(this, "token_type");
+    g(this, "token_start");
+    g(this, "token_end");
+    g(this, "token_line");
+    g(this, "token_column");
+    this.source = e, this.pos = 0, this.line = 1, this.column = 1, this.on_comment = t, this.token_type = os, this.token_start = 0, this.token_end = 0, this.token_line = 1, this.token_column = 1;
+  }
+  // Fast token advancing without object allocation (for internal parser use)
+  next_token_fast(e = !1) {
+    if (e)
+      for (; this.pos < this.source.length; ) {
+        let l = this.source.charCodeAt(this.pos);
+        if (l >= 128 || (y[l] & (Ce | ge)) === 0) break;
+        this.advance();
+      }
+    if (this.pos >= this.source.length)
+      return this.make_token(os, this.pos, this.pos);
+    let t = this.source.charCodeAt(this.pos), s = this.pos, i = this.line, n = this.column;
+    switch (t) {
+      case Dr:
+        return this.advance(), this.make_token(Ir, s, this.pos, i, n);
+      case Fr:
+        return this.advance(), this.make_token(Pr, s, this.pos, i, n);
+      case Mr:
+        return this.advance(), this.make_token(Ki, s, this.pos, i, n);
+      case qr:
+        return this.advance(), this.make_token(Hr, s, this.pos, i, n);
+      case zr:
+        return this.advance(), this.make_token(qe, s, this.pos, i, n);
+      case Kr:
+        return this.advance(), this.make_token(ls, s, this.pos, i, n);
+      case Br:
+        return this.advance(), this.make_token(Bi, s, this.pos, i, n);
+      case mi:
+        return this.advance(), this.make_token($i, s, this.pos, i, n);
+      case $r:
+        return this.advance(), this.make_token(Gi, s, this.pos, i, n);
+    }
+    if (t < 128 && (y[t] & (Ce | ge)) !== 0)
+      return this.consume_whitespace(i, n);
+    if (t === ki && this.peek() === wi) {
+      let l = s, o = i, h = n;
+      for (this.advance(2); this.pos < this.source.length - 1; ) {
+        if (this.source.charCodeAt(this.pos) === wi && this.peek() === ki) {
+          this.advance(2);
+          break;
+        }
+        this.advance();
+      }
+      let c = this.pos;
+      return this.on_comment && this.on_comment({
+        start: l,
+        end: c,
+        length: c - l,
+        line: o,
+        column: h
+      }), this.next_token_fast(e);
+    }
+    if (t === Gr || t === Yr)
+      return this.consume_string(t, i, n);
+    if (t < 128 && (y[t] & q) !== 0)
+      return this.consume_number(i, n);
+    if (t === Xt) {
+      let l = this.peek();
+      if (l < 128 && (y[l] & q) !== 0)
+        return this.consume_number(i, n);
+    }
+    if (t === Wr && this.pos + 3 < this.source.length && this.peek() === Qr && this.peek(2) === K && this.peek(3) === K)
+      return this.advance(4), this.make_token(Ur, s, this.pos, i, n);
+    if (t === K && this.pos + 2 < this.source.length && this.peek() === K && this.peek(2) === Vr)
+      return this.advance(3), this.make_token(Lr, s, this.pos, i, n);
+    if (t === jr)
+      return this.consume_at_keyword(i, n);
+    if (t === Xr)
+      return this.consume_hash(i, n);
+    if (Me(t))
+      return this.consume_ident_or_function(i, n);
+    if (t === K) {
+      let l = this.peek();
+      if (Me(l) || l === K)
+        return this.consume_ident_or_function(i, n);
+    }
+    if (t === Zt) {
+      let l = this.peek();
+      if (l !== 0 && !ie(l))
+        return this.consume_ident_or_function(i, n);
+    }
+    if (t === K || t === st) {
+      let l = this.peek();
+      if (l < 128 && (y[l] & q) !== 0)
+        return this.consume_number(i, n);
+      if (l === Xt) {
+        let h = this.peek(2);
+        if (h < 128 && (y[h] & q) !== 0)
+          return this.consume_number(i, n);
+      }
+    }
+    return this.advance(), this.make_token(de, s, this.pos, i, n);
+  }
+  consume_whitespace(e, t) {
+    let s = this.pos;
+    for (; this.pos < this.source.length; ) {
+      let i = this.source.charCodeAt(this.pos);
+      if (i >= 128 || (y[i] & (Ce | ge)) === 0) break;
+      this.advance();
+    }
+    return this.make_token(ns, s, this.pos, e, t);
+  }
+  consume_string(e, t, s) {
+    let i = this.pos;
+    for (this.advance(); this.pos < this.source.length; ) {
+      let n = this.source.charCodeAt(this.pos);
+      if (n === e)
+        return this.advance(), this.make_token(Mi, i, this.pos, t, s);
+      if (ie(n))
+        return this.make_token(xi, i, this.pos, t, s);
+      if (n === Zt) {
+        if (this.advance(), this.pos < this.source.length) {
+          let l = this.source.charCodeAt(this.pos);
+          et(l) ? this.consume_hex_escape() : ie(l) ? this.advance() : this.advance();
+        }
+        continue;
+      }
+      this.advance();
+    }
+    return this.make_token(xi, i, this.pos, t, s);
+  }
+  consume_hex_escape() {
+    let e = 0;
+    for (; e < 6 && this.pos < this.source.length; ) {
+      let t = this.source.charCodeAt(this.pos);
+      if (!et(t)) break;
+      this.advance(), e++;
+    }
+    if (this.pos < this.source.length) {
+      let t = this.source.charCodeAt(this.pos);
+      (gi(t) || ie(t)) && this.advance();
+    }
+  }
+  consume_number(e, t) {
+    let s = this.pos, i = this.source.charCodeAt(this.pos);
+    for ((i === st || i === K) && this.advance(); this.pos < this.source.length; ) {
+      let n = this.source.charCodeAt(this.pos);
+      if (n >= 128 || (y[n] & q) === 0) break;
+      this.advance();
+    }
+    if (this.pos < this.source.length && this.source.charCodeAt(this.pos) === Xt && this.pos + 1 < this.source.length) {
+      let n = this.peek();
+      if (n < 128 && (y[n] & q) !== 0)
+        for (this.advance(); this.pos < this.source.length; ) {
+          let l = this.source.charCodeAt(this.pos);
+          if (l >= 128 || (y[l] & q) === 0) break;
+          this.advance();
+        }
+    }
+    if (this.pos < this.source.length) {
+      let n = this.source.charCodeAt(this.pos);
+      if (n === Jr || n === en) {
+        let l = this.peek(), o = l < 128 && (y[l] & q) !== 0, h = this.peek(2), c = h < 128 && (y[h] & q) !== 0;
+        if (o || (l === st || l === K) && c) {
+          if (this.advance(), this.pos < this.source.length) {
+            let u = this.source.charCodeAt(this.pos);
+            (u === st || u === K) && this.advance();
           }
-        });
+          for (; this.pos < this.source.length; ) {
+            let u = this.source.charCodeAt(this.pos);
+            if (u >= 128 || (y[u] & q) === 0) break;
+            this.advance();
+          }
+        }
+      }
+    }
+    if (this.pos < this.source.length) {
+      let n = this.source.charCodeAt(this.pos);
+      if (n === Zr)
+        return this.advance(), this.make_token(qi, s, this.pos, e, t);
+      if (Me(n) || n === K && Me(this.peek())) {
+        for (; this.pos < this.source.length && tt(this.source.charCodeAt(this.pos)); )
+          this.advance();
+        return this.make_token(zi, s, this.pos, e, t);
+      }
+    }
+    return this.make_token(nt, s, this.pos, e, t);
+  }
+  consume_ident_or_function(e, t) {
+    let s = this.pos;
+    for (; this.pos < this.source.length; ) {
+      let i = this.source.charCodeAt(this.pos);
+      if (i === Zt) {
+        if (this.pos + 1 >= this.source.length) break;
+        let n = this.peek();
+        if (ie(n)) break;
+        if (this.advance(), et(n)) {
+          this.advance();
+          for (let l = 0; l < 5 && this.pos < this.source.length && et(this.source.charCodeAt(this.pos)); l++)
+            this.advance();
+          if (this.pos < this.source.length) {
+            let l = this.source.charCodeAt(this.pos);
+            (gi(l) || ie(l)) && this.advance();
+          }
+        } else
+          this.advance();
+      } else if (tt(i))
+        this.advance();
+      else
+        break;
+    }
+    return this.pos < this.source.length && this.source.charCodeAt(this.pos) === mi ? (this.advance(), this.make_token(rt, s, this.pos, e, t)) : this.make_token(le, s, this.pos, e, t);
+  }
+  consume_at_keyword(e, t) {
+    let s = this.pos;
+    for (this.advance(); this.pos < this.source.length && tt(this.source.charCodeAt(this.pos)); )
+      this.advance();
+    return this.make_token(Nr, s, this.pos, e, t);
+  }
+  consume_hash(e, t) {
+    let s = this.pos;
+    for (this.advance(); this.pos < this.source.length && tt(this.source.charCodeAt(this.pos)); )
+      this.advance();
+    return this.make_token(Fi, s, this.pos, e, t);
+  }
+  advance(e = 1) {
+    if (e === 1) {
+      if (this.pos >= this.source.length) return;
+      let t = this.source.charCodeAt(this.pos);
+      this.pos++, ie(t) ? (t === Ai && this.pos < this.source.length && this.source.charCodeAt(this.pos) === yi && this.pos++, this.line++, this.column = 1) : this.column++;
+      return;
+    }
+    for (let t = 0; t < e && !(this.pos >= this.source.length); t++) {
+      let s = this.source.charCodeAt(this.pos);
+      this.pos++, ie(s) ? (s === Ai && this.pos < this.source.length && this.source.charCodeAt(this.pos) === yi && (this.pos++, t++), this.line++, this.column = 1) : this.column++;
+    }
+  }
+  peek(e = 1) {
+    let t = this.pos + e;
+    return t >= this.source.length ? 0 : this.source.charCodeAt(t);
+  }
+  make_token(e, t, s, i = this.line, n = this.column) {
+    return this.token_type = e, this.token_start = t, this.token_end = s, this.token_line = i, this.token_column = n, e;
+  }
+  // Public API: returns Token object for backwards compatibility
+  next_token(e = !1) {
+    return this.next_token_fast(e), {
+      type: this.token_type,
+      start: this.token_start,
+      end: this.token_end,
+      line: this.token_line,
+      column: this.token_column
+    };
+  }
+  /**
+   * Save complete lexer state for backtracking
+   * @returns Object containing all lexer state
+   */
+  save_position() {
+    return {
+      pos: this.pos,
+      line: this.line,
+      column: this.column,
+      token_type: this.token_type,
+      token_start: this.token_start,
+      token_end: this.token_end,
+      token_line: this.token_line,
+      token_column: this.token_column
+    };
+  }
+  /**
+   * Restore lexer state from saved position
+   * @param saved The saved position to restore
+   */
+  restore_position(e) {
+    this.pos = e.pos, this.line = e.line, this.column = e.column, this.token_type = e.token_type, this.token_start = e.token_start, this.token_end = e.token_end, this.token_line = e.token_line, this.token_column = e.token_column;
+  }
+}
+let it = 36;
+const tn = 1, lt = 2, ze = 3, pe = 4, Wi = 5, Qi = 6, ot = 7, Vi = 10, as = 11, Ke = 12, ji = 13, sn = 14, Xi = 15, rn = 16, nn = 17, Zi = 18, ln = 19, dt = 20, hs = 21, Ji = 22, er = 23, Be = 24, be = 25, Ye = 26, at = 27, cs = 28, tr = 29, $e = 30, re = 31, sr = 56, on = 32, an = 33, hn = 34, cn = 35, _n = 36, un = 37, fn = 38, pn = 39, ir = 40, dn = 1, gn = 2, Ei = 4, xn = 8, mn = 32, rr = 64, kn = 128, Ci = 0, wn = 1, An = 2, yn = 3, En = 4, Cn = 5, bn = 6, Pe = 0, Rn = 1, vn = 2, ne = class ne {
+  constructor(e = 1024) {
+    g(this, "buffer");
+    g(this, "view");
+    g(this, "capacity");
+    // Number of nodes that can fit
+    g(this, "count");
+    // Number of nodes currently allocated
+    g(this, "growth_count");
+    // Number of times the arena has grown
+    g(this, "overflow_lengths");
+    this.capacity = e, this.count = 1, this.growth_count = 0, this.buffer = new ArrayBuffer(e * it), this.view = new DataView(this.buffer), this.overflow_lengths = /* @__PURE__ */ new Map();
+  }
+  // Calculate recommended initial capacity based on CSS source size
+  static capacity_for_source(e) {
+    let t = e / 1024, s = Math.ceil(t * ne.NODES_PER_KB), i = Math.ceil(s * ne.CAPACITY_BUFFER);
+    return Math.max(16, i);
+  }
+  // Get the number of nodes currently in the arena
+  get_count() {
+    return this.count;
+  }
+  // Get the capacity (max nodes without reallocation)
+  get_capacity() {
+    return this.capacity;
+  }
+  // Get the number of times the arena has grown
+  get_growth_count() {
+    return this.growth_count;
+  }
+  // Calculate byte offset for a node
+  node_offset(e) {
+    return e * it;
+  }
+  // Read node type
+  get_type(e) {
+    return this.view.getUint8(this.node_offset(e));
+  }
+  // Read node flags
+  get_flags(e) {
+    return this.view.getUint8(this.node_offset(e) + 1);
+  }
+  // Read start offset in source
+  get_start_offset(e) {
+    return this.view.getUint32(this.node_offset(e) + 12, !0);
+  }
+  // Read length in source
+  get_length(e) {
+    if (this.has_flag(e, Ei)) {
+      const t = this.overflow_lengths.get(e);
+      if (t !== void 0)
+        return t;
+    }
+    return this.view.getUint16(this.node_offset(e) + 2, !0);
+  }
+  // Read content start offset (stored as delta from startOffset)
+  get_content_start(e) {
+    const t = this.get_start_offset(e), s = this.view.getUint16(this.node_offset(e) + 16, !0);
+    return t + s;
+  }
+  // Read content length
+  get_content_length(e) {
+    return this.view.getUint16(this.node_offset(e) + 20, !0);
+  }
+  // Read attribute operator (for NODE_SELECTOR_ATTRIBUTE)
+  get_attr_operator(e) {
+    return this.view.getUint8(this.node_offset(e) + 32);
+  }
+  // Read attribute flags (for NODE_SELECTOR_ATTRIBUTE)
+  get_attr_flags(e) {
+    return this.view.getUint8(this.node_offset(e) + 33);
+  }
+  // Read first child index (0 = no children)
+  get_first_child(e) {
+    return this.view.getUint32(this.node_offset(e) + 4, !0);
+  }
+  // Read next sibling index (0 = no sibling)
+  get_next_sibling(e) {
+    return this.view.getUint32(this.node_offset(e) + 8, !0);
+  }
+  // Read start line
+  get_start_line(e) {
+    return this.view.getUint32(this.node_offset(e) + 24, !0);
+  }
+  // Read start column
+  get_start_column(e) {
+    return this.view.getUint32(this.node_offset(e) + 28, !0);
+  }
+  // Read value start offset (stored as delta from startOffset, declaration value / at-rule prelude)
+  get_value_start(e) {
+    const t = this.get_start_offset(e), s = this.view.getUint16(this.node_offset(e) + 18, !0);
+    return t + s;
+  }
+  // Read value length
+  get_value_length(e) {
+    return this.view.getUint16(this.node_offset(e) + 22, !0);
+  }
+  // --- Write Methods ---
+  // Write node type
+  set_type(e, t) {
+    this.view.setUint8(this.node_offset(e), t);
+  }
+  // Write node flags
+  set_flags(e, t) {
+    this.view.setUint8(this.node_offset(e) + 1, t);
+  }
+  // Write length in source
+  set_length(e, t) {
+    t > 65535 ? (this.view.setUint16(this.node_offset(e) + 2, 65535, !0), this.set_flag(e, Ei), this.overflow_lengths.set(e, t)) : this.view.setUint16(this.node_offset(e) + 2, t, !0);
+  }
+  // Write content start delta (offset from startOffset)
+  set_content_start_delta(e, t) {
+    this.view.setUint16(this.node_offset(e) + 16, t, !0);
+  }
+  // Write content length
+  set_content_length(e, t) {
+    this.view.setUint16(this.node_offset(e) + 20, t, !0);
+  }
+  // Write attribute operator (for NODE_SELECTOR_ATTRIBUTE)
+  set_attr_operator(e, t) {
+    this.view.setUint8(this.node_offset(e) + 32, t);
+  }
+  // Write attribute flags (for NODE_SELECTOR_ATTRIBUTE)
+  set_attr_flags(e, t) {
+    this.view.setUint8(this.node_offset(e) + 33, t);
+  }
+  // Write first child index
+  set_first_child(e, t) {
+    this.view.setUint32(this.node_offset(e) + 4, t, !0);
+  }
+  // Write next sibling index
+  set_next_sibling(e, t) {
+    this.view.setUint32(this.node_offset(e) + 8, t, !0);
+  }
+  // Write value start delta (offset from startOffset, declaration value / at-rule prelude)
+  set_value_start_delta(e, t) {
+    this.view.setUint16(this.node_offset(e) + 18, t, !0);
+  }
+  // Write value length
+  set_value_length(e, t) {
+    this.view.setUint16(this.node_offset(e) + 22, t, !0);
+  }
+  // --- Node Creation ---
+  // Grow the arena by 1.3x when capacity is exceeded
+  grow() {
+    this.growth_count++;
+    let e = Math.ceil(this.capacity * ne.GROWTH_FACTOR), t = new ArrayBuffer(e * it);
+    new Uint8Array(t).set(new Uint8Array(this.buffer)), this.buffer = t, this.view = new DataView(t), this.capacity = e;
+  }
+  // Allocate and initialize a new node with core properties
+  // Automatically grows the arena if capacity is exceeded
+  create_node(e, t, s, i, n) {
+    this.count >= this.capacity && this.grow();
+    const l = this.count;
+    this.count++;
+    const o = l * it;
+    return this.view.setUint8(o, e), this.view.setUint32(o + 12, t, !0), this.view.setUint32(o + 24, i, !0), this.view.setUint32(o + 28, n, !0), this.set_length(l, s), l;
+  }
+  // --- Tree Building Helpers ---
+  // Link multiple child nodes to a parent
+  // Children are linked as siblings in the order provided
+  append_children(e, t) {
+    if (t.length === 0) return;
+    const s = this.node_offset(e);
+    this.view.setUint32(s + 4, t[0], !0);
+    for (let i = 0; i < t.length - 1; i++)
+      this.set_next_sibling(t[i], t[i + 1]);
+  }
+  // Check if a node has any children
+  has_children(e) {
+    return this.get_first_child(e) !== 0;
+  }
+  // Check if a node has a next sibling
+  has_next_sibling(e) {
+    return this.get_next_sibling(e) !== 0;
+  }
+  // --- Flag Management Helpers ---
+  // Set a specific flag bit (doesn't clear other flags)
+  set_flag(e, t) {
+    let s = this.get_flags(e);
+    this.set_flags(e, s | t);
+  }
+  // Clear a specific flag bit (doesn't affect other flags)
+  clear_flag(e, t) {
+    let s = this.get_flags(e);
+    this.set_flags(e, s & ~t);
+  }
+  // Check if a specific flag is set
+  has_flag(e, t) {
+    return (this.get_flags(e) & t) !== 0;
+  }
+};
+// Stores actual lengths for nodes > 65535 chars
+// Growth multiplier when capacity is exceeded
+g(ne, "GROWTH_FACTOR", 1.3), // Estimated nodes per KB of CSS (based on real-world data)
+// Increased from 270 to 325 to account for VALUE wrapper nodes
+// (~20% of nodes are declarations, +1 VALUE node per declaration = +20% nodes)
+g(ne, "NODES_PER_KB", 325), // Buffer to avoid frequent growth (15%)
+g(ne, "CAPACITY_BUFFER", 1.2);
+let ct = ne;
+const Tn = 32, On = 9, Sn = 10, Nn = 13, Un = 12, Se = 47, W = 42, F = 45, Ln = 39, Hn = 34, te = 43, nr = 46, ht = 126, lr = 62, In = 38, fe = 61, De = 124, bi = 36, Ri = 94, Pn = 58;
+function se(r) {
+  return r === Tn || r === On || r === Sn || r === Nn || r === Un;
+}
+function Dn(r) {
+  return r === lr || r === te || r === ht;
+}
+function Jt(r) {
+  return r >= 48 && r <= 57;
+}
+function Y(r, e) {
+  if (r.length !== e.length)
+    return !1;
+  for (let t = 0; t < r.length; t++) {
+    let s = r.charCodeAt(t), i = e.charCodeAt(t);
+    if (i |= 32, s !== i)
+      return !1;
+  }
+  return !0;
+}
+function Fn(r, e) {
+  if (r.length < e.length)
+    return !1;
+  for (let t = 0; t < e.length; t++) {
+    let s = r.charCodeAt(t), i = e.charCodeAt(t);
+    if (s >= 65 && s <= 90 && (s |= 32), s !== i)
+      return !1;
+  }
+  return !0;
+}
+function Mn(r, e) {
+  if (e.length === 0)
+    return -1;
+  if (e.length === 1) {
+    const t = e.charCodeAt(0);
+    for (let s = 0; s < r.length; s++) {
+      let i = r.charCodeAt(s);
+      if (i >= 65 && i <= 90 && (i |= 32), i === t)
+        return s;
+    }
+    return -1;
+  }
+  for (let t = 0; t <= r.length - e.length; t++) {
+    let s = !0;
+    for (let i = 0; i < e.length; i++) {
+      let n = r.charCodeAt(t + i), l = e.charCodeAt(i);
+      if (n >= 65 && n <= 90 && (n |= 32), n !== l) {
+        s = !1;
+        break;
+      }
+    }
+    if (s)
+      return t;
+  }
+  return -1;
+}
+function Fe(r, e, t) {
+  if ((e === void 0 || t === void 0) && (e = 0, t = r.length), r.charCodeAt(e) !== F || r.charCodeAt(e + 1) === F || t - e < 3)
+    return !1;
+  for (let i = e + 2; i < t; i++)
+    if (r.charCodeAt(i) === F)
+      return !0;
+  return !1;
+}
+function qn(r, e, t) {
+  for (; e < t && se(r.charCodeAt(e)); )
+    e++;
+  return e;
+}
+function ye(r, e, t) {
+  for (; e < t; ) {
+    let s = r.charCodeAt(e);
+    if (se(s)) {
+      e++;
+      continue;
+    }
+    if (s === Se && e + 1 < t && r.charCodeAt(e + 1) === W) {
+      for (e += 2; e < t; ) {
+        if (r.charCodeAt(e) === W && e + 1 < t && r.charCodeAt(e + 1) === Se) {
+          e += 2;
+          break;
+        }
+        e++;
+      }
+      continue;
+    }
+    break;
+  }
+  return e;
+}
+function zn(r, e, t) {
+  for (; e > t; ) {
+    let s = r.charCodeAt(e - 1);
+    if (se(s)) {
+      e--;
+      continue;
+    }
+    if (e >= 2 && s === Se && r.charCodeAt(e - 2) === W) {
+      for (e -= 2; e > t; ) {
+        if (e >= 2 && r.charCodeAt(e - 2) === Se && r.charCodeAt(e - 1) === W) {
+          e -= 2;
+          break;
+        }
+        e--;
+      }
+      continue;
+    }
+    break;
+  }
+  return e;
+}
+function es(r) {
+  let e = 0;
+  for (let n = 0; n < r.length; n++) {
+    let l = r.charCodeAt(n);
+    if (l === 101 || l === 69) {
+      if (n + 1 < r.length) {
+        let o = r.charCodeAt(n + 1);
+        if (Jt(o)) {
+          e = n + 1;
+          continue;
+        }
+        if ((o === 43 || o === 45) && n + 2 < r.length) {
+          let h = r.charCodeAt(n + 2);
+          if (Jt(h)) {
+            e = n + 1;
+            continue;
+          }
+        }
+      }
+      break;
+    }
+    if (Jt(l) || l === nr || l === F || l === te)
+      e = n + 1;
+    else
+      break;
+  }
+  let t = r.substring(0, e), s = r.substring(e);
+  return { value: t ? parseFloat(t) : 0, unit: s };
+}
+const Kn = {
+  [tn]: "StyleSheet",
+  [lt]: "Rule",
+  [ze]: "Atrule",
+  [pe]: "Declaration",
+  [Wi]: "Selector",
+  [Qi]: "Comment",
+  [ot]: "Block",
+  [Vi]: "Identifier",
+  [as]: "Number",
+  [Ke]: "Dimension",
+  [ji]: "String",
+  [sn]: "Hash",
+  [Xi]: "Function",
+  [rn]: "Operator",
+  [nn]: "Parentheses",
+  [Zi]: "Url",
+  [ln]: "Value",
+  [dt]: "SelectorList",
+  [hs]: "TypeSelector",
+  [Ji]: "ClassSelector",
+  [er]: "IdSelector",
+  [Be]: "AttributeSelector",
+  [be]: "PseudoClassSelector",
+  [Ye]: "PseudoElementSelector",
+  [at]: "Combinator",
+  [cs]: "UniversalSelector",
+  [tr]: "NestingSelector",
+  [$e]: "Nth",
+  [re]: "NthOf",
+  [sr]: "Lang",
+  [on]: "MediaQuery",
+  [an]: "Feature",
+  [hn]: "MediaType",
+  [cn]: "ContainerQuery",
+  [_n]: "SupportsQuery",
+  [un]: "Layer",
+  [fn]: "Operator",
+  [pn]: "MediaFeatureRange",
+  [ir]: "AtrulePrelude"
+};
+class We {
+  constructor(e, t, s) {
+    g(this, "arena");
+    g(this, "source");
+    g(this, "index");
+    this.arena = e, this.source = t, this.index = s;
+  }
+  /**
+   * @internal
+   * Get the arena (for internal/advanced use only)
+   */
+  __get_arena() {
+    return this.arena;
+  }
+  /** Get node type as number (for performance) */
+  get type() {
+    return this.arena.get_type(this.index);
+  }
+  /** Get node type as human-readable string */
+  get type_name() {
+    return Kn[this.type] || "unknown";
+  }
+  /** Get the full text of this node from source */
+  get text() {
+    let e = this.arena.get_start_offset(this.index), t = this.arena.get_length(this.index);
+    return this.source.substring(e, e + t);
+  }
+  /** Get the "content" text (property name for declarations, at-rule name for at-rules, layer name for import layers) */
+  get name() {
+    let e = this.arena.get_content_start(this.index), t = this.arena.get_content_length(this.index);
+    return t === 0 ? "" : this.source.substring(e, e + t);
+  }
+  /**
+   * Alias for name (for declarations: "color" in "color: blue")
+   * More semantic than `name` for declaration nodes
+   */
+  get property() {
+    return this.name;
+  }
+  /**
+   * Get the value text (for declarations: "blue" in "color: blue")
+   * For dimension/number nodes: returns the numeric value as a number
+   * For string nodes: returns the string content without quotes
+   * For URL nodes with quoted string: returns the string with quotes (consistent with STRING node)
+   * For URL nodes with unquoted URL: returns the URL content without quotes
+   */
+  get value() {
+    let { type: e, text: t } = this;
+    if (e === pe && this.first_child)
+      return this.first_child;
+    if (e === Ke)
+      return es(t).value;
+    if (e === as)
+      return Number.parseFloat(this.text);
+    if (e === Zi) {
+      let n = this.first_child;
+      if (n && n.type === ji)
+        return n.text;
+      if (Fn(t, "url(")) {
+        let l = t.indexOf("("), o = t.lastIndexOf(")");
+        if (l !== -1 && o !== -1 && o > l)
+          return t.substring(l + 1, o).trim();
+      } else if (t.startsWith('"') || t.startsWith("'"))
+        return t;
+    }
+    let s = this.arena.get_value_start(this.index), i = this.arena.get_value_length(this.index);
+    return i === 0 ? null : this.source.substring(s, s + i);
+  }
+  /** Get the numeric value for NUMBER and DIMENSION nodes, or null for other node types */
+  get value_as_number() {
+    let e = this.text;
+    return this.type === as ? Number.parseFloat(e) : this.type === Ke ? es(e).value : null;
+  }
+  /**
+   * Get the prelude node:
+   * - For at-rules: AT_RULE_PRELUDE wrapper containing structured prelude children (media queries, layer names, etc.)
+   * - For style rules: SELECTOR_LIST or SELECTOR node
+   * Returns null if no prelude exists
+   */
+  get prelude() {
+    if (this.type === ze) {
+      let e = this.first_child;
+      return e && e.type === ir ? e : null;
+    }
+    if (this.type === lt)
+      return this.first_child;
+  }
+  /**
+   * Get the attribute operator (for attribute selectors: =, ~=, |=, ^=, $=, *=)
+   * Returns one of the ATTR_OPERATOR_* constants
+   */
+  get attr_operator() {
+    if (this.type === Be)
+      return this.arena.get_attr_operator(this.index);
+  }
+  /**
+   * Get the attribute flags (for attribute selectors: i, s)
+   * Returns one of the ATTR_FLAG_* constants
+   */
+  get attr_flags() {
+    if (this.type === Be)
+      return this.arena.get_attr_flags(this.index);
+  }
+  /** Get the unit for dimension nodes (e.g., "px" from "100px", "%" from "50%") */
+  get unit() {
+    if (this.type === Ke)
+      return es(this.text).unit;
+  }
+  /** Check if this declaration has !important */
+  get is_important() {
+    if (this.type === pe)
+      return this.arena.has_flag(this.index, dn);
+  }
+  /** Check if this declaration has a browser hack prefix */
+  get is_browserhack() {
+    if (this.type === pe)
+      return this.arena.has_flag(this.index, kn);
+  }
+  /** Check if this has a vendor prefix (computed on-demand) */
+  get is_vendor_prefixed() {
+    switch (this.type) {
+      case pe:
+        return Fe(this.name);
+      case be:
+      case Ye:
+        return Fe(this.name);
+      case ze:
+        return Fe(this.name);
+      case Xi:
+        return Fe(this.name);
+      case Vi:
+        return Fe(this.text);
+      default:
+        return !1;
+    }
+  }
+  /** Check if this node has an error */
+  get has_error() {
+    return this.arena.has_flag(this.index, gn);
+  }
+  /** Check if this node has a prelude (at-rules and style rules) */
+  get has_prelude() {
+    return this.type === ze ? this.arena.get_value_length(this.index) > 0 : this.type === lt ? this.first_child !== null : !1;
+  }
+  /** Check if this rule has a block { } */
+  get has_block() {
+    return this.arena.has_flag(this.index, xn);
+  }
+  /** Check if this style rule has declarations */
+  get has_declarations() {
+    return this.arena.has_flag(this.index, mn);
+  }
+  /** Get the block node (for style rules and at-rules with blocks) */
+  get block() {
+    if (this.type === lt) {
+      let e = this.first_child;
+      if (!e) return null;
+      let t = e.next_sibling;
+      return t && t.type === ot ? t : null;
+    }
+    if (this.type === ze) {
+      let e = this.first_child;
+      for (; e; ) {
+        if (e.type === ot && !e.next_sibling)
+          return e;
+        e = e.next_sibling;
+      }
+      return null;
+    }
+    return null;
+  }
+  /** Check if this block is empty (no declarations or rules, only comments allowed) */
+  get is_empty() {
+    if (this.type !== ot) return;
+    let e = this.first_child;
+    for (; e; ) {
+      if (e.type !== Qi)
+        return !1;
+      e = e.next_sibling;
+    }
+    return !0;
+  }
+  /** Get start line number */
+  get line() {
+    return this.arena.get_start_line(this.index);
+  }
+  /** Get start column number */
+  get column() {
+    return this.arena.get_start_column(this.index);
+  }
+  /** Get start offset in source */
+  get start() {
+    return this.arena.get_start_offset(this.index);
+  }
+  /** Get length in source */
+  get length() {
+    return this.arena.get_length(this.index);
+  }
+  /**
+   * Get end offset in source
+   * End is not stored, must be calculated
+   */
+  get end() {
+    return this.start + this.length;
+  }
+  // --- Tree Traversal ---
+  /** Get first child node */
+  get first_child() {
+    let e = this.arena.get_first_child(this.index);
+    return e === 0 ? null : new We(this.arena, this.source, e);
+  }
+  /** Get next sibling node */
+  get next_sibling() {
+    let e = this.arena.get_next_sibling(this.index);
+    return e === 0 ? null : new We(this.arena, this.source, e);
+  }
+  /** Check if this node has a next sibling */
+  get has_next() {
+    return this.arena.get_next_sibling(this.index) !== 0;
+  }
+  /**
+   * Check if this node has children
+   * For pseudo-class/pseudo-element functions, returns true if FLAG_HAS_PARENS is set
+   * This allows formatters to distinguish :lang() from :hover
+   */
+  get has_children() {
+    return (this.type === be || this.type === Ye) && this.arena.has_flag(this.index, rr) ? !0 : this.arena.has_children(this.index);
+  }
+  /** Get all children as an array */
+  get children() {
+    let e = [], t = this.first_child;
+    for (; t; )
+      e.push(t), t = t.next_sibling;
+    return e;
+  }
+  /** Make CSSNode iterable over its children */
+  *[Symbol.iterator]() {
+    let e = this.first_child;
+    for (; e; )
+      yield e, e = e.next_sibling;
+  }
+  // --- An+B Expression Helpers (for NODE_SELECTOR_NTH) ---
+  /** Get the 'a' coefficient from An+B expression (e.g., "2n" from "2n+1", "odd" from "odd") */
+  get nth_a() {
+    if (this.type !== $e && this.type !== re) return;
+    let e = this.arena.get_content_length(this.index);
+    if (e === 0) return;
+    let t = this.arena.get_content_start(this.index);
+    return this.source.substring(t, t + e);
+  }
+  /** Get the 'b' coefficient from An+B expression (e.g., "+1" from "2n+1") */
+  get nth_b() {
+    if (this.type !== $e && this.type !== re) return;
+    let e = this.arena.get_value_length(this.index);
+    if (e === 0) return;
+    let t = this.arena.get_value_start(this.index), s = this.source.substring(t, t + e), i = t - 1;
+    for (; i >= 0; ) {
+      let n = this.source.charCodeAt(i);
+      if (se(n)) {
+        i--;
+        continue;
+      }
+      n === F ? s = "-" + s : n === te && (s = "+" + s);
+      break;
+    }
+    return s;
+  }
+  // --- Pseudo-Class Nth-Of Helpers (for NODE_SELECTOR_NTH_OF) ---
+  /** Get the An+B formula node from :nth-child(2n+1 of .foo) */
+  get nth() {
+    if (this.type === re)
+      return this.first_child ?? void 0;
+  }
+  /** Get the selector list from :nth-child(2n+1 of .foo) */
+  get selector() {
+    if (this.type !== re) return;
+    let e = this.first_child;
+    return (e == null ? void 0 : e.next_sibling) ?? void 0;
+  }
+  // --- Pseudo-Class Selector List Helper ---
+  /**
+   * Get selector list from pseudo-class functions
+   * Works for :is(.a), :not(.b), :has(.c), :where(.d), :nth-child(2n of .e)
+   */
+  get selector_list() {
+    if (this.type !== be) return;
+    let e = this.first_child;
+    if (e) {
+      if (e.type === dt)
+        return e;
+      if (e.type === re)
+        return e.selector;
+    }
+  }
+  // --- Node Cloning ---
+  /**
+   * Clone this node as a mutable plain JavaScript object with children as arrays.
+   * See API.md for examples.
+   *
+   * @param options - Cloning configuration
+   * @param options.deep - Recursively clone children (default: true)
+   * @param options.locations - Include line/column/start/length (default: false)
+   */
+  clone(e = {}) {
+    const { deep: t = !0, locations: s = !1 } = e;
+    let i = {
+      type: this.type,
+      type_name: this.type_name,
+      text: this.text,
+      children: []
+    };
+    if (this.name && (i.name = this.name), this.type === pe && (i.property = this.name), this.value !== void 0 && this.value !== null && (i.value = this.value, this.unit && (i.unit = this.unit)), this.type === pe && (i.is_important = this.is_important, i.is_browserhack = this.is_browserhack), i.is_vendor_prefixed = this.is_vendor_prefixed, i.has_error = this.has_error, this.type === Be && (i.attr_operator = this.attr_operator, i.attr_flags = this.attr_flags), (this.type === $e || this.type === re) && (i.nth_a = this.nth_a, i.nth_b = this.nth_b), s && (i.line = this.line, i.column = this.column, i.start = this.start, i.length = this.length, i.end = this.end), t)
+      for (let n of this.children)
+        i.children.push(n.clone({ deep: !0, locations: s }));
+    return i;
+  }
+}
+class vi {
+  constructor(e, t) {
+    g(this, "lexer");
+    g(this, "arena");
+    g(this, "source");
+    g(this, "expr_end");
+    this.arena = e, this.source = t, this.lexer = new Yi(t), this.expr_end = 0;
+  }
+  /**
+   * Parse An+B expression
+   * Examples: odd, even, 3, n, -n, 2n, 2n+1, -3n-5
+   */
+  parse_anplusb(e, t, s = 1) {
+    this.expr_end = t, this.lexer.pos = e, this.lexer.line = s;
+    let i = null, n = e, l = e, o = e, h = e;
+    const c = e;
+    if (this.skip_whitespace(), this.lexer.pos >= this.expr_end)
+      return null;
+    if (this.lexer.next_token_fast(!0), this.lexer.token_type === le) {
+      const u = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+      if (Y("odd", u) || Y("even", u))
+        return n = this.lexer.token_start, l = this.lexer.token_end, this.create_anplusb_node(c, n, l, 0, 0);
+      const f = this.source.charCodeAt(this.lexer.token_start), x = this.lexer.token_end > this.lexer.token_start + 1 ? this.source.charCodeAt(this.lexer.token_start + 1) : 0;
+      return f === F && x === 110 ? this.lexer.token_end > this.lexer.token_start + 2 && this.source.charCodeAt(this.lexer.token_start + 2) === F ? (n = this.lexer.token_start, l = this.lexer.token_start + 2, i = this.source.substring(this.lexer.token_start + 2, this.lexer.token_end), o = this.lexer.token_start + 2, h = this.lexer.token_end, this.create_anplusb_node(c, n, l, o, h)) : (n = this.lexer.token_start, l = this.lexer.token_start + 2, i = this.parse_b_part(), i !== null && (o = this.lexer.token_start, h = this.lexer.token_end), this.create_anplusb_node(c, n, l, i !== null ? o : 0, i !== null ? h : 0)) : f === 110 ? this.lexer.token_end > this.lexer.token_start + 1 && this.source.charCodeAt(this.lexer.token_start + 1) === F ? (n = this.lexer.token_start, l = this.lexer.token_start + 1, i = this.source.substring(this.lexer.token_start + 1, this.lexer.token_end), o = this.lexer.token_start + 1, h = this.lexer.token_end, this.create_anplusb_node(c, n, l, o, h)) : (n = this.lexer.token_start, l = this.lexer.token_start + 1, i = this.parse_b_part(), i !== null && (o = this.lexer.token_start, h = this.lexer.token_end), this.create_anplusb_node(c, n, l, i !== null ? o : 0, i !== null ? h : 0)) : null;
+    }
+    if (this.lexer.token_type === de && this.source.charCodeAt(this.lexer.token_start) === te) {
+      const u = this.lexer.save_position();
+      if (this.lexer.next_token_fast(!0), this.lexer.token_type === le && this.source.substring(this.lexer.token_start, this.lexer.token_end).charCodeAt(0) === 110)
+        return n = u.pos - 1, l = this.lexer.token_start + 1, this.lexer.token_end > this.lexer.token_start + 1 && this.source.charCodeAt(this.lexer.token_start + 1) === F ? (i = this.source.substring(this.lexer.token_start + 1, this.lexer.token_end), o = this.lexer.token_start + 1, h = this.lexer.token_end, this.create_anplusb_node(c, n, l, o, h)) : (i = this.parse_b_part(), i !== null && (o = this.lexer.token_start, h = this.lexer.token_end), this.create_anplusb_node(c, n, l, i !== null ? o : 0, i !== null ? h : 0));
+      this.lexer.restore_position(u);
+    }
+    if (this.lexer.token_type === zi) {
+      const u = this.source.substring(this.lexer.token_start, this.lexer.token_end), f = Mn(u, "n");
+      if (f !== -1) {
+        if (n = this.lexer.token_start, l = this.lexer.token_start + f + 1, f + 1 < u.length) {
+          const x = u.substring(f + 1);
+          if (x.charCodeAt(0) === F)
+            return i = x, o = this.lexer.token_start + f + 1, h = this.lexer.token_end, this.create_anplusb_node(c, n, l, o, h);
+        }
+        return i = this.parse_b_part(), i !== null && (o = this.lexer.token_start, h = this.lexer.token_end), this.create_anplusb_node(c, n, l, o, h);
+      }
+    }
+    return this.lexer.token_type === nt ? (i = this.source.substring(this.lexer.token_start, this.lexer.token_end), o = this.lexer.token_start, h = this.lexer.token_end, this.create_anplusb_node(c, 0, 0, o, h)) : null;
+  }
+  /**
+   * Parse the b part after 'n'
+   * Handles: +5, -3, whitespace variations
+   */
+  parse_b_part() {
+    if (this.skip_whitespace(), this.lexer.pos >= this.expr_end)
+      return null;
+    if (this.lexer.next_token_fast(!0), this.lexer.token_type === de) {
+      const e = this.source.charCodeAt(this.lexer.token_start);
+      if (e === te || e === F) {
+        const t = e === F ? "-" : "";
+        if (this.skip_whitespace(), this.lexer.next_token_fast(!0), this.lexer.token_type === nt) {
+          let s = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+          return s.charCodeAt(0) === te && (s = s.substring(1)), t === "-" ? t + s : s;
+        }
+      }
+    }
+    if (this.lexer.token_type === nt) {
+      let e = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+      const t = e.charCodeAt(0);
+      if (t === te || t === F)
+        return t === te && (e = e.substring(1)), e;
+    }
+    return null;
+  }
+  skip_whitespace() {
+    this.lexer.pos = ye(this.source, this.lexer.pos, this.expr_end);
+  }
+  create_anplusb_node(e, t, s, i, n) {
+    const l = this.arena.create_node($e, e, this.lexer.pos - e, this.lexer.line, 1);
+    return s > t && (this.arena.set_content_start_delta(l, t - e), this.arena.set_content_length(l, s - t)), n > i && (this.arena.set_value_start_delta(l, i - e), this.arena.set_value_length(l, n - i)), l;
+  }
+}
+class Bn {
+  constructor(e, t) {
+    g(this, "lexer");
+    g(this, "arena");
+    g(this, "source");
+    g(this, "selector_end");
+    this.arena = e, this.source = t, this.lexer = new Yi(t), this.selector_end = 0;
+  }
+  // Parse a selector range into selector nodes (standalone use)
+  // Always returns a NODE_SELECTOR_LIST with selector components as children
+  parse_selector(e, t, s = 1, i = 1, n = !0) {
+    return this.selector_end = t, this.lexer.pos = e, this.lexer.line = s, this.lexer.column = i, this.parse_selector_list(n);
+  }
+  // Parse comma-separated selectors
+  parse_selector_list(e = !0) {
+    let t = [], s = this.lexer.pos, i = this.lexer.line, n = this.lexer.column;
+    for (; this.lexer.pos < this.selector_end; ) {
+      let l = this.lexer.pos, o = this.lexer.line, h = this.lexer.column, c = this.parse_complex_selector(e);
+      if (c !== null) {
+        let f = this.arena.create_node(
+          Wi,
+          l,
+          this.lexer.pos - l,
+          o,
+          h
+        );
+        this.arena.set_content_start_delta(f, 0), this.arena.set_content_length(f, this.lexer.pos - l);
+        let x = c, k = this.arena.get_next_sibling(x);
+        for (; k !== 0; )
+          x = k, k = this.arena.get_next_sibling(x);
+        this.arena.set_first_child(f, c), t.push(f);
+      }
+      if (this.skip_whitespace(), this.lexer.pos >= this.selector_end) break;
+      if (this.lexer.next_token_fast(!1), this.lexer.token_type === qe) {
+        this.skip_whitespace();
+        continue;
       } else
-        e({
-          name: c,
-          // @ts-expect-error TODO: fix this
-          loc: n
-        });
+        break;
     }
-  });
+    if (t.length >= 1) {
+      let l = this.arena.create_node(dt, s, this.lexer.pos - s, i, n);
+      return this.arena.append_children(l, t), l;
+    }
+    return null;
+  }
+  // Parse a complex selector (with combinators)
+  // e.g., "div.class > p + span"
+  // Also supports CSS Nesting relaxed syntax: "> a", "~ span", etc.
+  parse_complex_selector(e = !0) {
+    let t = [];
+    if (this.skip_whitespace(), e && this.lexer.pos < this.selector_end) {
+      const s = this.lexer.save_position();
+      if (this.lexer.next_token_fast(!1), this.lexer.token_type === de) {
+        let n = this.source.charCodeAt(this.lexer.token_start);
+        if (n === lr || n === te || n === ht) {
+          let l = this.create_node_at(
+            at,
+            this.lexer.token_start,
+            this.lexer.token_end,
+            this.lexer.token_line,
+            this.lexer.token_column
+          );
+          t.push(l), this.skip_whitespace();
+        } else
+          this.lexer.restore_position(s);
+      } else
+        this.lexer.restore_position(s);
+    }
+    for (; this.lexer.pos < this.selector_end; ) {
+      let s = this.parse_compound_selector();
+      if (s !== null)
+        t.push(s);
+      else
+        break;
+      let i = this.try_parse_combinator();
+      if (i !== null) {
+        t.push(i), this.skip_whitespace();
+        continue;
+      }
+      const n = this.lexer.save_position();
+      if (this.skip_whitespace(), this.lexer.pos >= this.selector_end) {
+        this.lexer.restore_position(n);
+        break;
+      }
+      if (this.lexer.next_token_fast(!1), this.lexer.token_type === qe || this.lexer.pos >= this.selector_end) {
+        this.lexer.restore_position(n);
+        break;
+      }
+      this.lexer.restore_position(n);
+      break;
+    }
+    if (t.length === 0) return null;
+    for (let s = 0; s < t.length - 1; s++) {
+      let i = t[s];
+      for (; this.arena.get_next_sibling(i) !== 0; )
+        i = this.arena.get_next_sibling(i);
+      this.arena.set_next_sibling(i, t[s + 1]);
+    }
+    return t[0];
+  }
+  // Parse a compound selector (no combinators)
+  // e.g., "div.class#id[attr]:hover"
+  parse_compound_selector() {
+    let e = [];
+    for (; this.lexer.pos < this.selector_end; ) {
+      const t = this.lexer.save_position();
+      if (this.lexer.next_token_fast(!1), this.lexer.token_start >= this.selector_end || this.lexer.token_type === os) break;
+      let i = this.parse_simple_selector();
+      if (i !== null)
+        e.push(i);
+      else {
+        this.lexer.restore_position(t);
+        break;
+      }
+    }
+    if (e.length === 0) return null;
+    for (let t = 0; t < e.length - 1; t++)
+      this.arena.set_next_sibling(e[t], e[t + 1]);
+    return e[0];
+  }
+  // Parse a simple selector (single component)
+  parse_simple_selector() {
+    let e = this.lexer.token_type, t = this.lexer.token_start, s = this.lexer.token_end;
+    switch (e) {
+      case le:
+        return this.parse_type_or_namespace_selector(t, s);
+      case Fi:
+        return this.create_node(er, t, s);
+      case de:
+        let i = this.source.charCodeAt(t);
+        return i === nr ? this.parse_class_selector(t) : i === W ? this.parse_universal_or_namespace_selector(t, s) : i === In ? this.create_node(tr, t, s) : i === De ? this.parse_empty_namespace_selector(t) : null;
+      case ls:
+        return this.parse_attribute_selector(t);
+      case Ki:
+        return this.parse_pseudo(t);
+      case rt:
+        return this.parse_pseudo_function(t, s);
+      case qi:
+        return this.create_node(Ke, t, s);
+      case ns:
+      case qe:
+        return null;
+      default:
+        return null;
+    }
+  }
+  // Parse the local part after | in a namespace selector (E or *)
+  // Returns the node type (TYPE or UNIVERSAL) or null if invalid
+  parse_namespace_local_part(e, t, s) {
+    const i = this.lexer.save_position();
+    this.lexer.next_token_fast(!1);
+    let n;
+    if (this.lexer.token_type === le)
+      n = hs;
+    else if (this.lexer.token_type === de && this.source.charCodeAt(this.lexer.token_start) === W)
+      n = cs;
+    else
+      return this.lexer.restore_position(i), null;
+    let l = this.create_node(n, e, this.lexer.token_end);
+    return this.arena.set_content_start_delta(l, t - e), this.arena.set_content_length(l, s), l;
+  }
+  // Parse type selector or namespace selector (ns|E or ns|*)
+  // Called when we've seen an IDENT token
+  parse_type_or_namespace_selector(e, t) {
+    const s = this.lexer.save_position();
+    if (this.skip_whitespace(), this.lexer.pos < this.selector_end && this.source.charCodeAt(this.lexer.pos) === De) {
+      this.lexer.pos++;
+      let i = this.parse_namespace_local_part(e, e, t - e);
+      if (i !== null) return i;
+      this.lexer.pos = t;
+    } else
+      this.lexer.restore_position(s);
+    return this.create_node(hs, e, t);
+  }
+  // Parse universal selector or namespace selector (*|E or *|*)
+  // Called when we've seen a * DELIM token
+  parse_universal_or_namespace_selector(e, t) {
+    const s = this.lexer.save_position();
+    if (this.skip_whitespace(), this.lexer.pos < this.selector_end && this.source.charCodeAt(this.lexer.pos) === De) {
+      this.lexer.pos++;
+      let i = this.parse_namespace_local_part(e, e, t - e);
+      if (i !== null) return i;
+      this.lexer.pos = t;
+    } else
+      this.lexer.restore_position(s);
+    return this.create_node(cs, e, t);
+  }
+  // Parse empty namespace selector (|E or |*)
+  // Called when we've seen a | DELIM token at the start
+  parse_empty_namespace_selector(e) {
+    return this.parse_namespace_local_part(e, e, 1);
+  }
+  // Parse combinator (>, +, ~, or descendant space)
+  try_parse_combinator() {
+    let e = this.lexer.pos, t = this.lexer.line, s = this.lexer.column, i = this.lexer.pos < this.selector_end;
+    if (this.skip_whitespace(), i = i && this.lexer.pos > e, this.lexer.pos >= this.selector_end)
+      return this.lexer.pos = e, this.lexer.line = t, this.lexer.column = s, null;
+    if (this.lexer.next_token_fast(!1), this.lexer.token_type === de) {
+      let n = this.source.charCodeAt(this.lexer.token_start);
+      if (Dn(n))
+        return this.create_node_at(at, this.lexer.token_start, this.lexer.token_end, this.lexer.token_line, this.lexer.token_column);
+    }
+    return i ? (this.lexer.pos = e, this.lexer.line = t, this.lexer.column = s, this.skip_whitespace(), this.create_node_at(at, e, this.lexer.pos, t, s)) : (this.lexer.pos = e, this.lexer.line = t, this.lexer.column = s, null);
+  }
+  // Parse class selector (.classname)
+  parse_class_selector(e) {
+    const t = this.lexer.save_position();
+    return this.lexer.next_token_fast(!1), this.lexer.token_type !== le ? (this.lexer.restore_position(t), null) : this.create_node(Ji, e, this.lexer.token_end);
+  }
+  // Parse attribute selector ([attr], [attr=value], etc.)
+  parse_attribute_selector(e) {
+    let t = 1, s = this.lexer.token_end, i = e + 1, n = i;
+    for (; this.lexer.pos < this.selector_end && t > 0; ) {
+      this.lexer.next_token_fast(!1);
+      let o = this.lexer.token_type;
+      if (o === ls)
+        t++;
+      else if (o === Bi && (t--, t === 0)) {
+        n = this.lexer.token_start, s = this.lexer.token_end;
+        break;
+      }
+    }
+    let l = this.create_node(Be, e, s);
+    return this.parse_attribute_content(l, i, n), l;
+  }
+  // Parse attribute content to extract name, operator, and value
+  parse_attribute_content(e, t, s) {
+    if (t = ye(this.source, t, s), s = zn(this.source, s, t), t >= s) return;
+    let i = t, n = t, l = -1, o = -1, h = -1;
+    for (; n < s; ) {
+      let k = this.source.charCodeAt(n);
+      if (se(k) || k === fe || k === ht || k === De || k === Ri || k === bi || k === W)
+        break;
+      n++;
+    }
+    n > i && (this.arena.set_content_start_delta(e, i - this.arena.get_start_offset(e)), this.arena.set_content_length(e, n - i));
+    let c = ye(this.source, n, s);
+    if (c >= s) {
+      this.arena.set_attr_operator(e, Ci), this.arena.set_attr_flags(e, Pe);
+      return;
+    }
+    let u = this.source.charCodeAt(c), f = c + 1 < s ? this.source.charCodeAt(c + 1) : 0;
+    if (u === fe)
+      l = c + 1, this.arena.set_attr_operator(e, wn);
+    else if (u === ht && f === fe)
+      l = c + 2, this.arena.set_attr_operator(e, An);
+    else if (u === De && f === fe)
+      l = c + 2, this.arena.set_attr_operator(e, yn);
+    else if (u === Ri && f === fe)
+      l = c + 2, this.arena.set_attr_operator(e, En);
+    else if (u === bi && f === fe)
+      l = c + 2, this.arena.set_attr_operator(e, Cn);
+    else if (u === W && f === fe)
+      l = c + 2, this.arena.set_attr_operator(e, bn);
+    else {
+      this.arena.set_attr_operator(e, Ci), this.arena.set_attr_flags(e, Pe);
+      return;
+    }
+    if (c = ye(this.source, l, s), c >= s) {
+      this.arena.set_attr_flags(e, Pe);
+      return;
+    }
+    o = c;
+    let x = this.source.charCodeAt(c);
+    if (x === Ln || x === Hn) {
+      let k = x;
+      for (o = c, c++; c < s; ) {
+        let V = this.source.charCodeAt(c);
+        if (V === k) {
+          c++;
+          break;
+        }
+        V === 92 ? c += 2 : c++;
+      }
+      h = c;
+    } else {
+      for (; c < s; ) {
+        let k = this.source.charCodeAt(c);
+        if (se(k))
+          break;
+        c++;
+      }
+      h = c;
+    }
+    if (h > o && (this.arena.set_value_start_delta(e, o - this.arena.get_start_offset(e)), this.arena.set_value_length(e, h - o)), c = ye(this.source, h, s), c < s) {
+      let k = this.source.charCodeAt(c);
+      k === 105 || k === 73 ? this.arena.set_attr_flags(e, Rn) : k === 115 || k === 83 ? this.arena.set_attr_flags(e, vn) : this.arena.set_attr_flags(e, Pe);
+    } else
+      this.arena.set_attr_flags(e, Pe);
+  }
+  // Parse pseudo-class or pseudo-element (:hover, ::before)
+  parse_pseudo(e) {
+    const t = this.lexer.save_position(), s = this.lexer.save_position();
+    this.skip_whitespace();
+    let i = !1;
+    this.lexer.pos < this.selector_end && this.source.charCodeAt(this.lexer.pos) === Pn ? (i = !0, this.lexer.pos++) : this.lexer.restore_position(s), this.lexer.next_token_fast(!1);
+    let n = this.lexer.token_type;
+    if (n === le) {
+      let l = this.create_node(i ? Ye : be, e, this.lexer.token_end);
+      return this.arena.set_content_start_delta(l, this.lexer.token_start - e), this.arena.set_content_length(l, this.lexer.token_end - this.lexer.token_start), l;
+    } else if (n === rt)
+      return this.parse_pseudo_function_after_colon(e, i);
+    return this.lexer.restore_position(t), null;
+  }
+  // Parse pseudo-class function (:nth-child(), :is(), etc.)
+  parse_pseudo_function(e, t) {
+    return null;
+  }
+  // Parse pseudo-class function after we've seen the colon
+  parse_pseudo_function_after_colon(e, t) {
+    let s = this.lexer.token_start, i = this.lexer.token_end - 1, n = this.lexer.pos, l = n, o = 1, h = this.lexer.token_end;
+    for (; this.lexer.pos < this.selector_end && o > 0; ) {
+      this.lexer.next_token_fast(!1);
+      let u = this.lexer.token_type;
+      if (u === $i || u === rt)
+        o++;
+      else if (u === Gi && (o--, o === 0)) {
+        l = this.lexer.token_start, h = this.lexer.token_end;
+        break;
+      }
+    }
+    let c = this.create_node(t ? Ye : be, e, h);
+    if (this.arena.set_content_start_delta(c, s - e), this.arena.set_content_length(c, i - s), this.arena.set_flag(c, rr), l > n) {
+      let u = this.source.substring(s, i);
+      if (this.is_nth_pseudo(u)) {
+        let f = this.parse_nth_expression(n, l);
+        f !== null && this.arena.set_first_child(c, f);
+      } else if (Y("lang", u))
+        this.parse_lang_identifiers(n, l, c);
+      else {
+        let f = this.selector_end;
+        const x = this.lexer.save_position();
+        let k = Y("has", u), V = this.parse_selector(n, l, this.lexer.line, this.lexer.column, k);
+        this.selector_end = f, this.lexer.restore_position(x), V !== null && this.arena.set_first_child(c, V);
+      }
+    }
+    return c;
+  }
+  // Check if pseudo-class name is an nth-* pseudo
+  is_nth_pseudo(e) {
+    return Y("nth-child", e) || Y("nth-last-child", e) || Y("nth-of-type", e) || Y("nth-last-of-type", e) || Y("nth-col", e) || Y("nth-last-col", e);
+  }
+  // Parse :lang() content - comma-separated language identifiers
+  // Accepts both quoted strings: :lang("en", "fr") and unquoted: :lang(en, fr)
+  parse_lang_identifiers(e, t, s) {
+    let i = this.selector_end;
+    const n = this.lexer.save_position();
+    this.lexer.pos = e, this.selector_end = t;
+    let l = null, o = null;
+    for (; this.lexer.pos < t; ) {
+      this.lexer.next_token_fast(!1);
+      let h = this.lexer.token_type, c = this.lexer.token_start, u = this.lexer.token_end;
+      if (h !== ns && h !== qe) {
+        if (h === Mi || h === le) {
+          let f = this.create_node(sr, c, u);
+          l === null && (l = f), o !== null && this.arena.set_next_sibling(o, f), o = f;
+        }
+        if (this.lexer.pos >= t)
+          break;
+      }
+    }
+    l !== null && this.arena.set_first_child(s, l), this.selector_end = i, this.lexer.restore_position(n);
+  }
+  // Parse An+B expression for nth-* pseudo-classes
+  // Handles both simple An+B and "An+B of S" syntax
+  parse_nth_expression(e, t) {
+    let s = this.find_of_keyword(e, t);
+    if (s !== -1) {
+      let n = new vi(this.arena, this.source).parse_anplusb(e, s, this.lexer.line), l = s + 2;
+      l = qn(this.source, l, t);
+      let o = this.selector_end;
+      const h = this.lexer.save_position();
+      this.selector_end = t, this.lexer.pos = l;
+      let c = this.parse_selector_list();
+      this.selector_end = o, this.lexer.restore_position(h);
+      let u = this.arena.create_node(re, e, t - e, this.lexer.line, 1);
+      return n !== null && c !== null ? (this.arena.set_first_child(u, n), this.arena.set_next_sibling(n, c)) : n !== null && this.arena.set_first_child(u, n), u;
+    } else
+      return new vi(this.arena, this.source).parse_anplusb(e, t, this.lexer.line);
+  }
+  // Find the position of standalone "of" keyword (case-insensitive)
+  find_of_keyword(e, t) {
+    let s = e;
+    for (; s < t - 1 && (s = ye(this.source, s, t), !(s >= t - 1)); ) {
+      let i = this.source.charCodeAt(s), n = this.source.charCodeAt(s + 1);
+      if ((i === 111 || i === 79) && (n === 102 || n === 70)) {
+        let l = s === e || se(this.source.charCodeAt(s - 1)), o = s + 2 >= t || se(this.source.charCodeAt(s + 2));
+        if (l && o)
+          return s;
+      }
+      s++;
+    }
+    return -1;
+  }
+  create_node(e, t, s) {
+    let i = this.arena.create_node(e, t, s - t, this.lexer.token_line, this.lexer.token_column);
+    return this.arena.set_content_start_delta(i, 0), this.arena.set_content_length(i, s - t), i;
+  }
+  create_node_at(e, t, s, i, n) {
+    let l = this.arena.create_node(e, t, s - t, i, n);
+    return this.arena.set_content_start_delta(l, 0), this.arena.set_content_length(l, s - t), l;
+  }
+  // Helper to skip whitespace and comments, updating line/column
+  skip_whitespace() {
+    for (; this.lexer.pos < this.selector_end; ) {
+      let e = this.source.charCodeAt(this.lexer.pos);
+      if (se(e)) {
+        this.lexer.advance();
+        continue;
+      }
+      if (e === Se && this.lexer.pos + 1 < this.selector_end && this.source.charCodeAt(this.lexer.pos + 1) === W) {
+        for (this.lexer.advance(2); this.lexer.pos < this.selector_end; ) {
+          if (this.source.charCodeAt(this.lexer.pos) === W && this.lexer.pos + 1 < this.selector_end && this.source.charCodeAt(this.lexer.pos + 1) === Se) {
+            this.lexer.advance(2);
+            break;
+          }
+          this.lexer.advance();
+        }
+        continue;
+      }
+      break;
+    }
+  }
+}
+function $n(r) {
+  const e = new ct(ct.capacity_for_source(r.length)), s = new Bn(e, r).parse_selector(0, r.length);
+  if (s === null) {
+    const i = e.create_node(dt, 0, 0, 1, 1);
+    return new We(e, r, i);
+  }
+  return new We(e, r, s);
+}
+function Gn(r, e) {
+  return r[0] === e[0] ? r[1] === e[1] ? r[2] - e[2] : r[1] - e[1] : r[0] - e[0];
+}
+function Ti(r) {
+  return r.sort(Gn).at(-1);
 }
-const Pi = new F([
+const _t = (r) => {
+  var n, l, o;
+  let e = 0, t = 0, s = 0, i = r.first_child;
+  for (; i; ) {
+    switch (i.type) {
+      case pr:
+        e += 1;
+        break;
+      case ps:
+      case fr:
+        t += 1;
+        break;
+      case Oe:
+        switch (i.name.toLowerCase()) {
+          // "The specificity of a :where() pseudo-class is replaced by zero."
+          case "where":
+            break;
+          case "-webkit-any":
+          case "any":
+            i.first_child && (t += 1);
+            break;
+          // "The specificity of an :is(), :not(), or :has() pseudo-class is replaced by the specificity of the most specific complex selector in its selector list argument."
+          case "-moz-any":
+          case "is":
+          case "matches":
+          case "not":
+          case "has":
+            if (i.has_children) {
+              const f = i.first_child;
+              if ((f == null ? void 0 : f.type) === ds) {
+                const x = Ti(Oi(f));
+                e += x[0], t += x[1], s += x[2];
+              }
+            }
+            break;
+          // "The specificity of an :nth-child() or :nth-last-child() selector is the specificity of the pseudo class itself (counting as one pseudo-class selector) plus the specificity of the most specific complex selector in its selector list argument"
+          case "nth-child":
+          case "nth-last-child":
+            t += 1;
+            const c = i.first_child;
+            if ((c == null ? void 0 : c.type) === ur && c.selector) {
+              const f = Ti(Oi(c.selector));
+              e += f[0], t += f[1], s += f[2];
+            }
+            break;
+          // "The specificity of :host is that of a pseudo-class. The specificity of :host() is that of a pseudo-class, plus the specificity of its argument."
+          // "The specificity of :host-context() is that of a pseudo-class, plus the specificity of its argument."
+          case "host-context":
+          case "host":
+            t += 1;
+            const u = (n = i.first_child) == null ? void 0 : n.first_child;
+            if ((u == null ? void 0 : u.type) === ce) {
+              let f = u.first_child;
+              for (; f && f.type !== is; ) {
+                const x = _t({
+                  first_child: f
+                });
+                e += x[0] ?? 0, t += x[1] ?? 0, s += x[2] ?? 0, f = f.next_sibling;
+              }
+            }
+            break;
+          // Improper use of Pseudo-Class Selectors instead of a Pseudo-Element
+          // @ref https://developer.mozilla.org/en-US/docs/Web/CSS/Pseudo-elements#index
+          case "after":
+          case "before":
+          case "first-letter":
+          case "first-line":
+            s += 1;
+            break;
+          default:
+            t += 1;
+            break;
+        }
+        break;
+      case us:
+        switch (i.name.toLowerCase()) {
+          // "The specificity of ::slotted() is that of a pseudo-element, plus the specificity of its argument."
+          case "slotted":
+            s += 1;
+            const c = (l = i.first_child) == null ? void 0 : l.first_child;
+            if ((c == null ? void 0 : c.type) === ce) {
+              let u = c.first_child;
+              for (; u && u.type !== is; ) {
+                const f = _t({
+                  first_child: u
+                });
+                e += f[0] ?? 0, t += f[1] ?? 0, s += f[2] ?? 0, u = u.next_sibling;
+              }
+            }
+            break;
+          case "view-transition-group":
+          case "view-transition-image-pair":
+          case "view-transition-old":
+          case "view-transition-new":
+            if (((o = i.first_child) == null ? void 0 : o.text) === "*")
+              break;
+            s += 1;
+            break;
+          default:
+            s += 1;
+            break;
+        }
+        break;
+      case fs:
+        let h = i.name ?? "";
+        h.includes("|") && (h = h.split("|")[1] ?? ""), h !== "*" && (s += 1);
+        break;
+    }
+    i = i.next_sibling;
+  }
+  return [e, t, s];
+}, Yn = (r) => {
+  if (typeof r == "string")
+    try {
+      return $n(r);
+    } catch (e) {
+      const t = e instanceof Error ? e.message : String(e);
+      throw new TypeError(`Could not convert passed in source '${r}' to SelectorList: ${t}`);
+    }
+  if (r instanceof Object) {
+    if (r.type === ds)
+      return r;
+    throw new TypeError("Passed in source is an Object but no AST / AST of the type SelectorList");
+  }
+  throw new TypeError("Passed in source is not a String nor an Object. I don't know what to do with it.");
+}, Oi = (r) => {
+  if (!r)
+    return [];
+  const e = Yn(r), t = [];
+  let s = e.first_child;
+  for (; s; )
+    t.push(_t(s)), s = s.next_sibling;
+  return t;
+}, Wn = new $([
   // CSS Named Colors
   // Spec: https://drafts.csswg.org/css-color/#named-colors
   // Heuristic: popular names first for quick finding in set.has()
@@ -335,7 +1959,7 @@ const Pi = new F([
   "mediumorchid",
   "darksalmon",
   "mediumspringgreen"
-]), Ri = new F([
+]), Qn = new $([
   // CSS System Colors
   // Spec: https://drafts.csswg.org/css-color/#css-system-colors
   "accentcolor",
@@ -357,7 +1981,7 @@ const Pi = new F([
   "selecteditem",
   "selecteditemtext",
   "visitedtext"
-]), Oi = new F(["rgba", "rgb", "hsla", "hsl", "oklch", "color", "hwb", "lch", "lab", "oklab"]), Di = new F(["transparent", "currentcolor"]), pe = new F([
+]), Vn = new $(["rgba", "rgb", "hsla", "hsl", "oklch", "color", "hwb", "lch", "lab", "oklab"]), jn = new $(["transparent", "currentcolor"]), ut = new $([
   "auto",
   "none",
   // for `text-shadow`, `box-shadow` and `background`
@@ -367,22 +1991,13 @@ const Pi = new F([
   "revert",
   "revert-layer"
 ]);
-function fe(i) {
-  let e = i.children, t = e.size;
-  if (!e || t > 1 || t === 0) return !1;
-  let r = e.first;
-  return r.type === W && pe.has(r.name);
-}
-function ei(i) {
-  return parseFloat(i) === 0;
-}
-function Fi(i) {
-  for (let e of i.children.toArray())
-    if (!(e.type === ni && ei(e.value)) && !(e.type === Le && ei(e.value)))
+function Xn(r) {
+  for (let e of r.children)
+    if (!(e.type === _s && e.value === 0) && !(e.type === ft && e.value === 0))
       return !1;
   return !0;
 }
-const Ei = new F(["caption", "icon", "menu", "message-box", "small-caption", "status-bar"]), _i = new F([
+const ts = new $(["caption", "icon", "menu", "message-box", "small-caption", "status-bar"]), Zn = new $([
   /* <absolute-size> values */
   "xx-small",
   "x-small",
@@ -395,164 +2010,150 @@ const Ei = new F(["caption", "icon", "menu", "message-box", "small-caption", "st
   /* <relative-size> values */
   "smaller",
   "larger"
-]), Ii = 44, ti = 47;
-function Ze(i) {
-  let e = i.children.first;
-  return e === null ? !1 : e.type === W && Ei.has(e.name);
-}
-function Mi(i, e, t) {
-  var w;
-  let r = [void 0, void 0], n, c;
-  if (i.children.first.type === "Function" && i.children.first.name.toLowerCase() === "var")
+]), Jn = 44, Si = 47;
+function el(r, e) {
+  let t = [void 0, void 0], s, i;
+  if (r.first_child.type === gs && r.first_child.name.toLowerCase() === "var")
     return null;
-  i.children.forEach(function(b, x) {
-    let O = x.prev ? x.prev.data : void 0, A = x.next ? x.next.data : void 0;
-    if (b.type === W && pe.has(b.name) && t({
+  let n;
+  for (let o of r.children) {
+    let h = o.next_sibling;
+    if (o.type === he && ut.has(o.name) && e({
       type: "keyword",
-      value: b.name
-    }), A && A.type === Z && A.value.charCodeAt(0) === ti) {
-      n = e(b);
-      return;
+      value: o.name
+    }), h && h.type === Ee && h.text.charCodeAt(0) === Si) {
+      s = o.text, n = o;
+      continue;
     }
-    if (O && O.type === Z && O.value.charCodeAt(0) === ti) {
-      c = e(b);
-      return;
+    if ((n == null ? void 0 : n.type) === Ee && n.text.charCodeAt(0) === Si) {
+      i = o.text, n = o;
+      continue;
     }
-    if (A && A.type === Z && A.value.charCodeAt(0) === Ii && !r[0]) {
-      r[0] = b, !n && O && (n = e(O));
-      return;
+    if ((h == null ? void 0 : h.type) === Ee && h.text.charCodeAt(0) === Jn && !t[0]) {
+      t[0] = o, !s && n && (s = n.text), n = o;
+      continue;
     }
-    if (b.type !== ni) {
-      if (x.next === null) {
-        r[1] = b, !n && !r[0] && O && (n = e(O));
-        return;
-      }
-      if (b.type === W) {
-        let E = b.name;
-        if (_i.has(E)) {
-          n = E;
-          return;
-        }
-      }
+    if (o.next_sibling === null) {
+      t[1] = o, !s && !t[0] && n && (s = n.text), n = o;
+      continue;
     }
-  });
-  let d = r[0] || r[1] ? e({
-    loc: {
-      // @ts-expect-error TODO: fix this
-      start: {
-        // @ts-expect-error TODO: fix this
-        offset: (r[0] || r[1]).loc.start.offset
-      },
-      // @ts-expect-error TODO: fix this
-      end: {
-        // Either the node we detected as the last node, or the end of the whole value
-        // It's never 0 because the first node is always a font-size or font-style
-        offset: ((w = r[1]) == null ? void 0 : w.loc.end.offset) || i.loc.end.offset
+    if (o.type === _s) {
+      n = o;
+      continue;
+    }
+    if (o.type === he) {
+      let c = o.name;
+      if (Zn.has(c)) {
+        s = c, n = o;
+        continue;
       }
     }
-  }) : null;
+    n = o;
+  }
+  let l = t[0] || t[1] ? r.text.substring(
+    ((t == null ? void 0 : t[0]) || (t == null ? void 0 : t[1]) || { start: r.start }).start - r.start,
+    // Either the node we detected as the last node, or the end of the whole value
+    // It's never 0 because the first node is always a font-size or font-style
+    t[1] ? t[1].end - r.start : r.text.length
+  ) : null;
   return {
-    font_size: n,
-    line_height: c,
-    font_family: d
+    font_size: s,
+    line_height: i,
+    font_family: l
   };
 }
-const Ui = new F(["linear", "ease", "ease-in", "ease-out", "ease-in-out", "step-start", "step-end"]), Ti = new F(["cubic-bezier", "steps"]);
-function Vi(i, e) {
+const tl = new $(["linear", "ease", "ease-in", "ease-out", "ease-in-out", "step-start", "step-end"]), sl = new $(["cubic-bezier", "steps"]);
+function il(r, e) {
   let t = !1;
-  for (let r of i) {
-    let n = r.type, c = r.name;
-    n === Z ? t = !1 : n === Le && t === !1 ? (t = !0, e({
+  for (let s of r) {
+    let i = s.type, n = s.name;
+    i === Ee ? t = !1 : i === ft && t === !1 ? (t = !0, e({
       type: "duration",
-      value: r
-    })) : n === W ? Ui.has(c) ? e({
+      value: s
+    })) : i === he ? tl.has(n) ? e({
       type: "fn",
-      value: r
-    }) : pe.has(c) && e({
+      value: s
+    }) : ut.has(n) && e({
       type: "keyword",
-      value: r
-    }) : n === et && Ti.has(c) && e({
+      value: s
+    }) : i === gs && sl.has(n) && e({
       type: "fn",
-      value: r
+      value: s
     });
   }
 }
-function ci(i) {
-  let e = i.children;
-  if (!e)
-    return !1;
-  for (let t of e) {
-    let { type: r, name: n } = t;
-    if (r === W && N(n) || r === et && (N(n) || ci(t)))
-      return !0;
-  }
-  return !1;
+function rl(r) {
+  let e = !1;
+  return B(r, function(t) {
+    if (t.is_vendor_prefixed)
+      return e = !0, Q;
+  }), e;
 }
-var H, U, T, $;
-class o {
+var oe, Z, J, Re;
+class p {
   constructor(e = !1) {
-    I(this, H);
-    I(this, U);
-    I(this, T, []);
-    I(this, $);
-    R(this, H, /* @__PURE__ */ new Map()), R(this, U, 0), e && R(this, T, []), R(this, $, e);
+    G(this, oe);
+    G(this, Z);
+    G(this, J, []);
+    G(this, Re);
+    M(this, oe, /* @__PURE__ */ new Map()), M(this, Z, 0), e && M(this, J, []), M(this, Re, e);
   }
   p(e, t) {
-    let r = m(this, U);
-    if (m(this, $)) {
-      let n = t.start, c = n.offset, d = r * 4;
-      m(this, T)[d] = n.line, m(this, T)[d + 1] = n.column, m(this, T)[d + 2] = c, m(this, T)[d + 3] = t.end.offset - c;
+    let s = w(this, Z);
+    if (w(this, Re)) {
+      let i = s * 4;
+      w(this, J)[i] = t.line, w(this, J)[i + 1] = t.column, w(this, J)[i + 2] = t.offset, w(this, J)[i + 3] = t.length;
     }
-    if (m(this, H).has(e)) {
-      m(this, H).get(e).push(r), Ye(this, U)._++;
+    if (w(this, oe).has(e)) {
+      w(this, oe).get(e).push(s), Vt(this, Z)._++;
       return;
     }
-    m(this, H).set(e, [r]), Ye(this, U)._++;
+    w(this, oe).set(e, [s]), Vt(this, Z)._++;
   }
   size() {
-    return m(this, U);
+    return w(this, Z);
   }
   c() {
-    let e = /* @__PURE__ */ new Map(), t = {}, r = m(this, $), n = m(this, H), c = m(this, T), d = n.size;
-    n.forEach((b, x) => {
-      if (r) {
-        let O = b.map(function(A) {
-          let E = A * 4;
+    let e = /* @__PURE__ */ new Map(), t = {}, s = w(this, Re), i = w(this, oe), n = w(this, J), l = i.size;
+    i.forEach((h, c) => {
+      if (s) {
+        let u = h.map(function(f) {
+          let x = f * 4;
           return {
-            line: c[E],
-            column: c[E + 1],
-            offset: c[E + 2],
-            length: c[E + 3]
+            line: n[x],
+            column: n[x + 1],
+            offset: n[x + 2],
+            length: n[x + 3]
           };
         });
-        e.set(x, O);
+        e.set(c, u);
       } else
-        t[x] = b.length;
+        t[c] = h.length;
     });
-    let w = m(this, U);
-    return r ? {
-      total: w,
-      totalUnique: d,
+    let o = w(this, Z);
+    return s ? {
+      total: o,
+      totalUnique: l,
       unique: t,
-      uniquenessRatio: w === 0 ? 0 : d / w,
+      uniquenessRatio: o === 0 ? 0 : l / o,
       uniqueWithLocations: Object.fromEntries(e)
     } : {
-      total: w,
-      totalUnique: d,
+      total: o,
+      totalUnique: l,
       unique: t,
-      uniquenessRatio: w === 0 ? 0 : d / w,
+      uniquenessRatio: o === 0 ? 0 : l / o,
       uniqueWithLocations: void 0
     };
   }
 }
-H = new WeakMap(), U = new WeakMap(), T = new WeakMap(), $ = new WeakMap();
-var J, K, le;
-class $e {
+oe = new WeakMap(), Z = new WeakMap(), J = new WeakMap(), Re = new WeakMap();
+var ve, ae, Qe;
+class ss {
   constructor(e) {
-    I(this, J);
-    I(this, K);
-    I(this, le);
-    R(this, J, new o(e)), R(this, K, /* @__PURE__ */ new Map()), R(this, le, e);
+    G(this, ve);
+    G(this, ae);
+    G(this, Qe);
+    M(this, ve, new p(e)), M(this, ae, /* @__PURE__ */ new Map()), M(this, Qe, e);
   }
   /**
    * Add an item to this #list's context
@@ -560,46 +2161,46 @@ class $e {
    * @param context Context to push Item to
    * @param node_location
    */
-  push(e, t, r) {
-    m(this, J).p(e, r), m(this, K).has(t) || m(this, K).set(t, new o(m(this, le))), m(this, K).get(t).p(e, r);
+  push(e, t, s) {
+    w(this, ve).p(e, s), w(this, ae).has(t) || w(this, ae).set(t, new p(w(this, Qe))), w(this, ae).get(t).p(e, s);
   }
   count() {
     let e = /* @__PURE__ */ new Map();
-    for (let [t, r] of m(this, K).entries())
-      e.set(t, r.c());
-    return Object.assign(m(this, J).c(), {
+    for (let [t, s] of w(this, ae).entries())
+      e.set(t, s.c());
+    return Object.assign(w(this, ve).c(), {
       itemsPerContext: Object.fromEntries(e)
     });
   }
 }
-J = new WeakMap(), K = new WeakMap(), le = new WeakMap();
-function Wi(i) {
-  let e = /* @__PURE__ */ new Map(), t = -1, r = 0, n = 0, c = i.length;
-  for (let d = 0; d < c; d++) {
-    let w = i[d], b = (e.get(w) || 0) + 1;
-    e.set(w, b), b > t && (t = b, r = 0, n = 0), b >= t && (r++, n += w);
-  }
-  return n / r;
+ve = new WeakMap(), ae = new WeakMap(), Qe = new WeakMap();
+function nl(r) {
+  let e = /* @__PURE__ */ new Map(), t = -1, s = 0, i = 0, n = r.length;
+  for (let l = 0; l < n; l++) {
+    let o = r[l], h = (e.get(o) || 0) + 1;
+    e.set(o, h), h > t && (t = h, s = 0, i = 0), h >= t && (s++, i += o);
+  }
+  return i / s;
 }
-var V, X;
-class S {
+var ee, Te;
+class L {
   constructor() {
-    I(this, V);
-    I(this, X);
-    R(this, V, []), R(this, X, 0);
+    G(this, ee);
+    G(this, Te);
+    M(this, ee, []), M(this, Te, 0);
   }
   /**
    * Add a new Integer at the end of this AggregateCollection
    * @param item - The item to add
    */
   push(e) {
-    m(this, V).push(e), R(this, X, m(this, X) + e);
+    w(this, ee).push(e), M(this, Te, w(this, Te) + e);
   }
   size() {
-    return m(this, V).length;
+    return w(this, ee).length;
   }
   aggregate() {
-    let e = m(this, V).length;
+    let e = w(this, ee).length;
     if (e === 0)
       return {
         min: 0,
@@ -609,24 +2210,40 @@ class S {
         range: 0,
         sum: 0
       };
-    let t = m(this, V).slice().sort((w, b) => w - b), r = t[0], n = t[e - 1], c = Wi(t), d = m(this, X);
+    let t = w(this, ee).slice().sort((o, h) => o - h), s = t[0], i = t[e - 1], n = nl(t), l = w(this, Te);
     return {
-      min: r,
-      max: n,
-      mean: d / e,
-      mode: c,
-      range: n - r,
-      sum: d
+      min: s,
+      max: i,
+      mean: l / e,
+      mode: n,
+      range: i - s,
+      sum: l
     };
   }
   toArray() {
-    return m(this, V);
+    return w(this, ee);
   }
 }
-V = new WeakMap(), X = new WeakMap();
-function Hi(i) {
-  if (tt(i) || N(i)) return !1;
-  let e = i.charCodeAt(0);
+ee = new WeakMap(), Te = new WeakMap();
+function ll(r) {
+  return r.replaceAll(/(?:^['"])|(?:['"]$)/g, "");
+}
+function ol(r, e) {
+  return e >= 65 && e <= 90 && (e = e | 32), r === e;
+}
+function Ge(r, e) {
+  if (r === e) return !0;
+  let t = e.length, s = t - r.length;
+  if (s < 0)
+    return !1;
+  for (let i = t - 1; i >= s; i--)
+    if (ol(r.charCodeAt(i - s), e.charCodeAt(i)) === !1)
+      return !1;
+  return !0;
+}
+function fl(r) {
+  if (xs(r) || ms(r)) return !1;
+  let e = r.charCodeAt(0);
   return e === 47 || // /
   e === 42 || // *
   e === 95 || // _
@@ -635,28 +2252,28 @@ function Hi(i) {
   e === 36 || // $
   e === 35;
 }
-function tt(i) {
-  return i.length < 3 ? !1 : i.charCodeAt(0) === 45 && i.charCodeAt(1) === 45;
+function m(r, e) {
+  return xs(e) ? !1 : Ge(r, e);
 }
-function g(i, e) {
-  return tt(e) ? !1 : M(i, e);
+function al(r) {
+  return ms(r) ? r.slice(r.indexOf("-", 2) + 1) : r;
 }
-function Ki(i) {
-  return N(i) ? i.slice(i.indexOf("-", 2) + 1) : i;
+function hl(r) {
+  let e = 5, t = r.indexOf(";"), s = r.indexOf(",");
+  return t === -1 || s !== -1 && s < t ? r.substring(e, s) : r.substring(e, t);
 }
-function Ni(i) {
-  let e = 5, t = i.indexOf(";"), r = i.indexOf(",");
-  return t === -1 || r !== -1 && r < t ? i.substring(e, r) : i.substring(e, t);
-}
-function ji(i) {
-  let e = i.children;
+function Ni(r) {
+  let e = r.children;
   if (e) {
-    let t = e.last;
-    return !!(t && t.type === W && M("\\9", t.name));
+    let t = e.at(-1);
+    return !!(t && t.type === he && Ge("\\9", t.text));
   }
   return !1;
 }
-let Bi = new F([
+function pl(r) {
+  return ms(r);
+}
+let cl = new $([
   "border-radius",
   "border-top-left-radius",
   "border-top-right-radius",
@@ -667,496 +2284,464 @@ let Bi = new F([
   "border-end-end-radius",
   "border-end-start-radius"
 ]);
-function z(i, e) {
-  return e === 0 ? 0 : i / e;
+function H(r, e) {
+  return e === 0 ? 0 : r / e;
 }
-function Ji(i, e = {}) {
-  return e.useLocations === !0 ? ii(i, e, !0) : ii(i, e, !1);
+function dl(r, e = {}) {
+  return e.useLocations === !0 ? Ui(r, e, !0) : Ui(r, e, !1);
 }
-function ii(i, e, t) {
-  let r = Date.now();
-  function n(l) {
-    return c(l).trim();
-  }
-  function c(l) {
-    let re = l.loc;
-    return i.substring(re.start.offset, re.end.offset);
-  }
-  let d = 0, w = 0, b = 0, x = {
+function Ui(r, e, t) {
+  let s = Date.now(), i = (r.match(/\n/g) || []).length + 1, n = 0, l = 0, o = 0, h = {
     total: 0,
     unique: /* @__PURE__ */ new Map()
-  }, O = Date.now(), A = mi(i, {
-    parseCustomProperty: !0,
-    // To find font-families, colors, etc.
-    positions: !0,
-    // So we can use stringifyNode()
-    onComment: function(l) {
-      d++, w += l.length;
-    }
-  }), E = Date.now(), fi = A.loc.end.line - A.loc.start.line + 1, it = new o(t), he = new S(), me = [], rt = new o(t), ge = new o(t), lt = new o(t), nt = new o(t), st = new o(t), at = new o(t), ot = new o(t), de = new o(t), ut = new o(t), ye = new o(t), we = new o(t), ct = new o(t), ne = new o(t), ft = new o(t), ke = new S(), pt = new o(t), be = 0, xe = 0, Ce = new S(), ve = new S(), Se = new S(), ht = new o(t), mt = new o(t), gt = new o(t), ze = new S(), dt = new o(t), qe = new o(t), yt = /* @__PURE__ */ new Set(), Ae = new o(t), j, B, wt = new S(), kt = new S(), bt = new S(), xt = new o(t), se = new S(), Ct = new o(t), vt = [], Pe = new o(t), Re = new o(t), St = new o(t), zt = new o(t), Oe = new S(), qt = new o(t), At = /* @__PURE__ */ new Set(), L = 0, Pt = new S(), ae = 0, De = 0, Fe = new o(t), Ee = new S(), Rt = new o(t), ee = new o(t), _e = new o(t), Ie = new o(t), oe = new o(t), te = new S(), Me = new S(), Ot = new o(t), Ue = new o(t), Dt = new o(t), Ft = new o(t), Et = new o(t), Te = new o(t), Ve = new o(t), We = new o(t), ue = new o(t), ce = new o(t), Y = new $e(t), G = new o(t), He = new $e(t), _t = new o(t), ie = new o(t), It = new $e(t), Mt = new o(t), _ = 0;
-  C(A, {
-    enter(l) {
-      var re, Yt, Gt;
-      switch (l.type) {
-        case Ge: {
-          it.p(l.name, l.loc), ke.push(_), pt.p(_, l.loc);
-          let s = l.name;
-          if (s === "font-face") {
-            let a = /* @__PURE__ */ Object.create(null);
-            t && rt.p(l.loc.start.offset, l.loc), (re = l.block) == null || re.children.forEach((h) => {
-              h.type === "Declaration" && (a[h.property] = n(h.value));
-            }), me.push(a), he.push(1);
-            break;
-          }
-          let f = 1;
-          if (l.prelude !== null) {
-            let a = l.prelude, h = a && n(l.prelude), u = a.loc;
-            if (s === "media")
-              nt.p(h, u), Si(a) && (st.p(h, u), f++);
-            else if (s === "supports")
-              de.p(h, u), vi(a) && (ut.p(h, u), f++);
-            else if (M("keyframes", s)) {
-              let y = "@" + s + " " + h;
-              N(s) && (we.p(y, u), f++), ye.p(y, u);
-            } else if (s === "import")
-              C(l, (y) => {
-                if (y.type === "Condition" && y.kind === "supports") {
-                  let p = n(y);
-                  return de.p(p, y.loc), C.break;
-                }
-              }), lt.p(h, u);
-            else if (s === "charset")
-              ot.p(h, u);
-            else if (s === "container") {
-              if (ct.p(h, u), a.type === "AtrulePrelude" && ((Yt = a.children.first) == null ? void 0 : Yt.type) === "Identifier") {
-                let y = a.children.first.name;
-                ne.p(y, u);
-              }
-            } else s === "property" && ft.p(h, u);
-          } else
-            s === "layer" && (ge.p("<anonymous>", l.loc), f++);
-          he.push(f);
-          break;
-        }
-        // @ts-expect-error Oudated css-tree types
-        case "Layer": {
-          l.name !== null && ge.p(l.name, l.loc);
-          break;
-        }
-        // @ts-expect-error Oudated css-tree types
-        case "Feature": {
-          at.p(l.name, l.loc);
-          break;
-        }
-        case Qe: {
-          let s = l.prelude, f = l.block, a = s.children, h = f.children, u = a ? a.size : 0, y = h ? h.size : 0;
-          Ce.push(u + y), ht.p(u + y, l.loc), ve.push(u), mt.p(u, s.loc), Se.push(y), gt.p(y, f.loc), ze.push(_), dt.p(_, l.loc), be++, y === 0 && xe++;
-          break;
-        }
-        case yi: {
-          let s = n(l), f = l.loc;
-          if (this.atrule && M("keyframes", this.atrule.name))
-            return qe.p(s, f), this.skip;
-          oi(l) && Re.p(s, f);
-          let a = qi(l);
-          if (a !== !1)
-            for (let P of a)
-              St.p(P, f);
-          let h = ui(l);
-          zi(l) && Ae.p(s, f), yt.add(s), se.push(h), Ct.p(h, f), Oe.push(_ - 1), qt.p(_ - 1, f);
-          let u = gi(l).toArray(), [y, p, v] = u;
-          return xt.p(u.toString(), f), wt.push(y), kt.push(p), bt.push(v), j === void 0 && (j = u), B === void 0 && (B = u), B !== void 0 && ri(B, u) < 0 && (B = u), j !== void 0 && ri(j, u) > 0 && (j = u), vt.push(u), y > 0 && Pe.p(s, f), Ai(l, function(D) {
-            zt.p(D.name, D.loc);
-          }), this.skip;
+  }, c = Date.now(), u = dr(r, {
+    on_comment({ length: a }) {
+      n++, l += a;
+    }
+  }), f = Date.now(), x = new p(t), k = new L(), V = [], ws = new p(t), Ve = new p(t), As = new p(t), ys = new p(t), Es = new p(t), Cs = new p(t), bs = new p(t), gt = new p(t), Rs = new p(t), xt = new p(t), mt = new p(t), vs = new p(t), je = new p(t), Ts = new p(t), kt = new L(), Os = new p(t), wt = 0, At = 0, yt = new L(), Et = new L(), Ct = new L(), Ss = new p(t), Ns = new p(t), Us = new p(t), bt = new L(), Ls = new p(t), Rt = new p(t), Hs = /* @__PURE__ */ new Set(), vt = new p(t), _e, ue, Is = new L(), Ps = new L(), Ds = new L(), Fs = new p(t), Xe = new L(), Ms = new p(t), qs = [], Tt = new p(t), Ot = new p(t), zs = new p(t), Ks = new p(t), St = new L(), Bs = new p(t), $s = /* @__PURE__ */ new Set(), Ne = 0, Gs = new L(), Ze = 0, Nt = 0, Ut = new p(t), Lt = new L(), Ys = new p(t), Ue = new p(t), Ht = new p(t), It = new p(t), Je = new p(t), Le = new L(), Pt = new L(), Ws = new p(t), Dt = new p(t), Qs = new p(t), Vs = new p(t), js = new p(t), Ft = new p(t), Mt = new p(t), qt = new p(t), zt = new p(t), Kt = new p(t), xe = new ss(t), me = new p(t), Xs = new ss(t), Zs = new p(t), He = new p(t), Js = new ss(t), ei = new p(t);
+  function A(a) {
+    return {
+      line: a.line,
+      column: a.column,
+      offset: a.start,
+      length: a.length
+    };
+  }
+  let ke = -1;
+  B(u, (a, D) => {
+    var ci, _i, ui, fi;
+    ke >= 0 && D <= ke && (ke = -1);
+    let Wt = ke >= 0 && D > ke;
+    if (a.type === gr) {
+      let N = A(a);
+      if (kt.push(D), Os.p(D, N), x.p(a.name, N), P("font-face", a.name)) {
+        let E = /* @__PURE__ */ Object.create(null);
+        t && ws.p(a.start, A(a));
+        let R = a.children.find((d) => d.type === xr);
+        for (let d of (R == null ? void 0 : R.children) || [])
+          d.type === jt && d.value && (E[d.property] = d.value.text);
+        k.push(1), V.push(E);
+      }
+      if (a.prelude === null || a.prelude === void 0)
+        P("layer", a.name) && (Ve.p("<anonymous>", A(a)), k.push(2));
+      else {
+        let { name: E } = a, R = 1;
+        if (P("media", E))
+          ys.p(a.prelude.text, A(a)), br(a.prelude) && (Es.p(a.prelude.text, A(a)), R++);
+        else if (P("supports", E))
+          gt.p(a.prelude.text, A(a)), Cr(a.prelude) && (Rs.p(a.prelude.text, A(a)), R++);
+        else if (Ge("keyframes", E)) {
+          let d = `@${E} ${a.prelude.text}`;
+          xt.p(d, A(a)), a.is_vendor_prefixed && (mt.p(d, A(a)), R++), ke = D;
+        } else if (P("layer", E))
+          for (let d of a.prelude.text.split(",").map((_) => _.trim()))
+            Ve.p(d, A(a));
+        else if (P("import", E)) {
+          if (As.p(a.prelude.text, A(a)), a.prelude.has_children)
+            for (let d of a.prelude)
+              d.type === Hi && typeof d.value == "string" ? gt.p(d.value, A(d)) : d.type === mr && typeof d.value == "string" && Ve.p(d.value, A(d));
+        } else P("container", E) ? (vs.p(a.prelude.text, A(a)), ((ci = a.prelude.first_child) == null ? void 0 : ci.type) === kr && ((_i = a.prelude.first_child.first_child) == null ? void 0 : _i.type) === he && je.p(a.prelude.first_child.first_child.text, A(a))) : P("property", E) ? Ts.p(a.prelude.text, A(a)) : P("charset", E) && bs.p(a.prelude.text, A(a));
+        k.push(R);
+      }
+    } else if (a.type === wr)
+      if (Wt && a.prelude)
+        a.prelude.type === ds && a.prelude.text && Rt.p(a.prelude.text, A(a.prelude));
+      else {
+        wt++, (ui = a.block) != null && ui.is_empty && At++;
+        let N = 0, E = 0, R = A(a);
+        if (a.prelude)
+          for (const d of a.prelude.children)
+            d.type === ce && N++;
+        if (a.block)
+          for (const d of a.block.children)
+            d.type === jt && E++;
+        yt.push(N + E), Ss.p(N + E, R), Et.push(N), Ns.p(N, R), Ct.push(E), Us.p(E, R), bt.push(D), Ls.p(D, R);
+      }
+    else if (a.type === ce) {
+      if (Wt)
+        return I;
+      let N = A(a);
+      St.push(D > 0 ? D - 1 : 0), Bs.p(D > 0 ? D - 1 : 0, N), Hs.add(a.text);
+      let E = rs(a);
+      Xe.push(E), Ms.p(E, N), Rr(a) && vt.p(a.text, N), Di(a) && Ot.p(a.text, N);
+      let R = vr(a);
+      if (R !== !1)
+        for (let j of R)
+          zs.p(j, N);
+      Tr(a, function(T) {
+        let U = T.name.trim() === "" ? " " : T.name;
+        Ks.p(U, T.loc);
+      });
+      let d = _t(a), [_, z, Qt] = d;
+      return Fs.p(d.toString(), N), Is.push(_), Ps.push(z), Ds.push(Qt), _e === void 0 && (_e = d), ue === void 0 && (ue = d), ue !== void 0 && Li(ue, d) < 0 && (ue = d), _e !== void 0 && Li(_e, d) > 0 && (_e = d), qs.push(d), _ > 0 && Tt.p(a.text, N), I;
+    } else if (a.type === jt) {
+      Ne++, $s.add(a.text);
+      let N = A(a), E = D > 0 ? D - 1 : 0;
+      Lt.push(E), Ys.p(E, N);
+      let R = 1;
+      if (a.is_important) {
+        R++;
+        let T = a.text;
+        if (!T.toLowerCase().includes("!important")) {
+          let U = a.value.text, v = T.indexOf(U), Ae = T.slice(-1) === ";";
+          Dt.p(`${T.slice(v, Ae ? -1 : void 0)}`, A(a.value));
         }
-        case Le: {
-          if (!this.declaration)
-            break;
-          let s = l.unit;
-          return M("\\9", s) ? He.push(s.substring(0, s.length - 2), this.declaration.property, l.loc) : He.push(s, this.declaration.property, l.loc), this.skip;
+        Wt && (Nt++, R++);
+      }
+      Gs.push(R);
+      let { is_important: d, property: _, is_browserhack: z, is_vendor_prefixed: Qt } = a, j = A(a);
+      j.length = _.length, Ue.p(_, j), d && Ze++, Qt ? (Le.push(2), It.p(_, j)) : xs(_) ? (Je.p(_, j), Le.push(d ? 3 : 2), d && Ut.p(_, j)) : z ? (Ht.p(_, j), Le.push(2)) : Le.push(1);
+      {
+        let T = a.value, { text: U } = T, v = A(T), Ae = 1;
+        if (ut.has(U)) {
+          He.p(U, v), Pt.push(Ae);
+          return;
         }
-        case Ci: {
-          if (Xe("data:", l.value)) {
-            let s = l.value, f = s.length, a = Ni(s);
-            x.total++, b += f;
-            let h = {
-              line: l.loc.start.line,
-              column: l.loc.start.column,
-              offset: l.loc.start.offset,
-              length: l.loc.end.offset - l.loc.start.offset
-            };
-            if (x.unique.has(a)) {
-              let u = x.unique.get(a);
-              u.count++, u.size += f, x.unique.set(a, u), t && u.uniqueWithLocations && u.uniqueWithLocations.push(h);
-            } else {
-              let u = {
-                count: 1,
-                size: f,
-                uniqueWithLocations: t ? [h] : void 0
-              };
-              x.unique.set(a, u);
+        if (rl(T) && (Ws.p(T.text, v), Ae++), Ni(T) && (Dt.p(U, v), U = U.slice(0, -2), Ae++), Pt.push(Ae), m("margin", _) || m("margin-block", _) || m("margin-inline", _) || m("margin-top", _) || m("margin-right", _) || m("margin-bottom", _) || m("margin-left", _) || m("padding", _) || m("padding-block", _) || m("padding-inline", _) || m("padding-top", _) || m("padding-right", _) || m("padding-bottom", _) || m("padding-left", _))
+          Xn(T) && ei.p(_, v);
+        else {
+          if (m("z-index", _))
+            return Qs.p(U, v), I;
+          if (m("font", _)) {
+            if (!ts.has(U)) {
+              let C = el(T, function(Ie) {
+                Ie.type === "keyword" && He.p(Ie.value, v);
+              });
+              if (!C)
+                return I;
+              let { font_size: O, line_height: S, font_family: X } = C;
+              X && Ft.p(X, v), O && Mt.p(O, v), S && qt.p(S, v);
             }
-          }
-          break;
-        }
-        case wi: {
-          let s = l.loc;
-          if (fe(l)) {
-            Me.push(1), ie.p(n(l), s);
-            break;
-          }
-          let f = this.declaration, { property: a, important: h } = f, u = 1;
-          ci(l) && (Ot.p(n(l), s), u++), typeof h == "string" && (Ue.p(c(l) + "!" + h, s), u++), ji(l) && (Ue.p(n(l), s), u++);
-          let y = l.children;
-          if (Me.push(u), g("margin", a) || g("margin-block", a) || g("margin-inline", a) || g("margin-top", a) || g("margin-right", a) || g("margin-bottom", a) || g("margin-left", a) || g("padding", a) || g("padding-block", a) || g("padding-inline", a) || g("padding-top", a) || g("padding-right", a) || g("padding-bottom", a) || g("padding-left", a))
-            Fi(l) && Mt.p(a, f.loc);
+          } else if (m("font-size", _))
+            ts.has(U) || Mt.p(U, v);
           else {
-            if (g("z-index", a))
-              return Dt.p(n(l), s), this.skip;
-            if (g("font", a)) {
-              if (Ze(l)) return;
-              let p = Mi(l, n, function(Qt) {
-                Qt.type === "keyword" && ie.p(Qt.value, s);
-              });
-              if (!p)
-                return this.skip;
-              let { font_size: v, line_height: P, font_family: D } = p;
-              D && Te.p(D, s), v && Ve.p(v, s), P && We.p(P, s);
-              break;
-            } else if (g("font-size", a)) {
-              Ze(l) || Ve.p(n(l), s);
-              break;
-            } else if (g("font-family", a)) {
-              Ze(l) || Te.p(n(l), s);
-              break;
-            } else if (g("line-height", a))
-              We.p(n(l), s);
-            else if (g("transition", a) || g("animation", a)) {
-              Vi(y, function(p) {
-                p.type === "fn" ? ue.p(n(p.value), s) : p.type === "duration" ? ce.p(n(p.value), s) : p.type === "keyword" && ie.p(n(p.value), s);
-              });
-              break;
-            } else if (g("animation-duration", a) || g("transition-duration", a)) {
-              y && y.size > 1 ? y.forEach((p) => {
-                p.type !== Z && ce.p(n(p), s);
-              }) : ce.p(n(l), s);
-              break;
-            } else if (g("transition-timing-function", a) || g("animation-timing-function", a)) {
-              y && y.size > 1 ? y.forEach((p) => {
-                p.type !== Z && ue.p(n(p), s);
-              }) : ue.p(n(l), s);
-              break;
-            } else if (g("container-name", a))
-              ne.p(n(l), s);
-            else if (g("container", a))
-              ((Gt = y.first) == null ? void 0 : Gt.type) === "Identifier" && ne.p(y.first.name, s);
-            else if (Bi.has(Ki(a))) {
-              fe(l) || It.push(n(l), a, s);
-              break;
-            } else g("text-shadow", a) ? fe(l) || Ft.p(n(l), s) : g("box-shadow", a) && (fe(l) || Et.p(n(l), s));
+            if (m("font-family", _))
+              return ts.has(U) || Ft.p(U, v), I;
+            if (m("line-height", _))
+              qt.p(U, v);
+            else {
+              if (m("transition", _) || m("animation", _))
+                return il(T.children, function(C) {
+                  C.type === "fn" ? zt.p(C.value.text, v) : C.type === "duration" ? Kt.p(C.value.text, v) : C.type === "keyword" && He.p(C.value.text, v);
+                }), I;
+              if (m("animation-duration", _) || m("transition-duration", _))
+                for (let C of T.children)
+                  C.type !== Ee && Kt.p(C.text, v);
+              else if (m("transition-timing-function", _) || m("animation-timing-function", _))
+                for (let C of T.children)
+                  C.type !== Ee && zt.p(C.text, v);
+              else m("container-name", _) ? je.p(U, v) : m("container", _) ? ((fi = T.first_child) == null ? void 0 : fi.type) === he && je.p(T.first_child.text, v) : cl.has(al(_)) ? Js.push(U, _, v) : m("text-shadow", _) ? Vs.p(U, v) : m("box-shadow", _) && js.p(U, v);
+            }
           }
-          C(l, function(p) {
-            let v = p.name;
-            switch (p.type) {
-              case xi: {
-                let P = p.value.length;
-                return M("\\9", p.value) && (P = P - 2), Y.push("#" + p.value, a, s), G.p("hex" + P, s), C.skip;
+        }
+        let or = Ni(T);
+        B(T, (C) => {
+          switch (C.type) {
+            case ft: {
+              let O = C.unit, S = A(C);
+              return Xs.push(O, _, S), I;
+            }
+            case Ar: {
+              let O = C.text;
+              if (!O || !O.startsWith("#"))
+                return I;
+              let S = O;
+              or && !S.endsWith("\\9") && (S = S + "\\9");
+              let X = S.length - 1;
+              Ge("\\9", S) && (X = X - 2);
+              let Ie = A(C);
+              return xe.push(S, _, Ie), me.p("hex" + X, Ie), I;
+            }
+            case he: {
+              let O = C.text, S = A(C);
+              if (m("font", _) || m("font-family", _))
+                return I;
+              ut.has(O) && He.p(O, S);
+              let X = O.length;
+              if (X > 20 || X < 3)
+                return I;
+              if (jn.has(O)) {
+                xe.push(O, _, S), me.p(O.toLowerCase(), S);
+                return;
               }
-              case W: {
-                pe.has(v) && ie.p(v, s);
-                let P = v.length;
-                if (P > 20 || P < 3)
-                  return C.skip;
-                if (Di.has(v)) {
-                  let D = n(p);
-                  Y.push(D, a, s), G.p(v.toLowerCase(), s);
-                  return;
-                }
-                if (Pi.has(v)) {
-                  let D = n(p);
-                  Y.push(D, a, s), G.p("named", s);
-                  return;
-                }
-                if (Ri.has(v)) {
-                  let D = n(p);
-                  Y.push(D, a, s), G.p("system", s);
-                  return;
-                }
-                return C.skip;
+              if (Wn.has(O)) {
+                xe.push(O, _, S), me.p("named", S);
+                return;
               }
-              case et: {
-                if (q("var", v))
-                  return C.skip;
-                if (Oi.has(v)) {
-                  Y.push(n(p), a, p.loc), G.p(v.toLowerCase(), p.loc);
-                  return;
-                }
-                if (M("gradient", v)) {
-                  _t.p(n(p), p.loc);
-                  return;
-                }
+              if (Qn.has(O)) {
+                xe.push(O, _, S), me.p("system", S);
+                return;
               }
+              return I;
             }
-          });
-          break;
-        }
-        case "Declaration": {
-          if (this.atrulePrelude !== null)
-            return this.skip;
-          L++;
-          let s = 1;
-          At.add(n(l)), Ee.push(_ - 1), Rt.p(_ - 1, l.loc), l.important === !0 && (ae++, s++, this.atrule && M("keyframes", this.atrule.name) && (De++, s++)), Pt.push(s);
-          let {
-            property: f,
-            // @ts-expect-error TODO: fix this
-            loc: { start: a }
-          } = l, h = {
-            start: {
-              line: a.line,
-              column: a.column,
-              offset: a.offset
-            },
-            end: {
-              offset: a.offset + f.length
+            case gs: {
+              let O = C.name, S = A(C);
+              if (Vn.has(O)) {
+                xe.push(C.text, _, S), me.p(O.toLowerCase(), S);
+                return;
+              }
+              if (Ge("gradient", O)) {
+                Zs.p(C.text, S);
+                return;
+              }
             }
+          }
+        });
+      }
+    } else if (a.type === yr) {
+      let { value: N } = a, E = ll(N || "");
+      if (Er(E, "data:")) {
+        let R = E.length, d = hl(E);
+        h.total++, o += R;
+        let _ = {
+          line: a.line,
+          column: a.column,
+          offset: a.start,
+          length: a.length
+        };
+        if (h.unique.has(d)) {
+          let z = h.unique.get(d);
+          z.count++, z.size += R, h.unique.set(d, z), t && z.uniqueWithLocations && z.uniqueWithLocations.push(_);
+        } else {
+          let z = {
+            count: 1,
+            size: R,
+            uniqueWithLocations: t ? [_] : void 0
           };
-          ee.p(f, h), N(f) ? (Ie.p(f, h), te.push(2)) : Hi(f) ? (_e.p(f, h), te.push(2)) : tt(f) ? (oe.p(f, h), te.push(l.important ? 3 : 2), l.important === !0 && Fe.p(f, h)) : te.push(1);
-          break;
+          h.unique.set(d, z);
         }
       }
-      (l.type === Qe || l.type === Ge) && _++;
-    },
-    leave(l) {
-      (l.type === Qe || l.type === Ge) && _--;
-    }
+    } else if (a.type === Ii)
+      return Cs.p(a.name, A(a)), I;
   });
-  let Ut = At.size, Q = se.size(), Ke = wt.aggregate(), Ne = kt.aggregate(), je = bt.aggregate(), Tt = yt.size, k = Object.assign, Vt = i.length, Be = me.length, Wt = he.aggregate(), Ht = se.aggregate(), Kt = Pt.aggregate(), Nt = te.aggregate(), jt = Me.aggregate(), Bt = it.c();
+  let ti = $s.size, we = Xe.size(), Bt = Is.aggregate(), $t = Ps.aggregate(), Gt = Ds.aggregate(), si = Hs.size, b = Object.assign, ii = r.length, Yt = V.length, ri = k.aggregate(), ni = Xe.aggregate(), li = Gs.aggregate(), oi = Le.aggregate(), ai = Pt.aggregate(), hi = x.c();
   return {
     stylesheet: {
-      sourceLinesOfCode: Bt.total + Q + L + qe.size(),
-      linesOfCode: fi,
-      size: Vt,
-      complexity: Wt.sum + Ht.sum + Kt.sum + Nt.sum + jt.sum,
+      sourceLinesOfCode: hi.total + we + Ne + Rt.size(),
+      linesOfCode: i,
+      size: ii,
+      complexity: ri.sum + ni.sum + li.sum + oi.sum + ai.sum,
       comments: {
-        total: d,
-        size: w
+        total: n,
+        size: l
       },
       embeddedContent: {
         size: {
-          total: b,
-          ratio: z(b, Vt)
+          total: o,
+          ratio: H(o, ii)
         },
         types: {
-          total: x.total,
-          totalUnique: x.unique.size,
-          uniquenessRatio: z(x.unique.size, x.total),
-          unique: Object.fromEntries(x.unique)
+          total: h.total,
+          totalUnique: h.unique.size,
+          uniquenessRatio: H(h.unique.size, h.total),
+          unique: Object.fromEntries(h.unique)
         }
       }
     },
-    atrules: k(Bt, {
-      fontface: k(
+    atrules: b(hi, {
+      fontface: b(
         {
-          total: Be,
-          totalUnique: Be,
-          unique: me,
-          uniquenessRatio: Be === 0 ? 0 : 1
+          total: Yt,
+          totalUnique: Yt,
+          unique: V,
+          uniquenessRatio: Yt === 0 ? 0 : 1
         },
         t ? {
-          uniqueWithLocations: rt.c().uniqueWithLocations
+          uniqueWithLocations: ws.c().uniqueWithLocations
         } : {}
       ),
-      import: lt.c(),
-      media: k(nt.c(), {
-        browserhacks: st.c(),
-        features: at.c()
+      import: As.c(),
+      media: b(ys.c(), {
+        browserhacks: Es.c(),
+        features: Cs.c()
       }),
-      charset: ot.c(),
-      supports: k(de.c(), {
-        browserhacks: ut.c()
+      charset: bs.c(),
+      supports: b(gt.c(), {
+        browserhacks: Rs.c()
       }),
-      keyframes: k(ye.c(), {
-        prefixed: k(we.c(), {
-          ratio: z(we.size(), ye.size())
+      keyframes: b(xt.c(), {
+        prefixed: b(mt.c(), {
+          ratio: H(mt.size(), xt.size())
         })
       }),
-      container: k(ct.c(), {
-        names: ne.c()
+      container: b(vs.c(), {
+        names: je.c()
       }),
-      layer: ge.c(),
-      property: ft.c(),
-      complexity: Wt,
-      nesting: k(
-        ke.aggregate(),
+      layer: Ve.c(),
+      property: Ts.c(),
+      complexity: ri,
+      nesting: b(
+        kt.aggregate(),
         {
-          items: ke.toArray()
+          items: kt.toArray()
         },
-        pt.c()
+        Os.c()
       )
     }),
     rules: {
-      total: be,
+      total: wt,
       empty: {
-        total: xe,
-        ratio: z(xe, be)
+        total: At,
+        ratio: H(At, wt)
       },
-      sizes: k(
-        Ce.aggregate(),
+      sizes: b(
+        yt.aggregate(),
         {
-          items: Ce.toArray()
+          items: yt.toArray()
         },
-        ht.c()
+        Ss.c()
       ),
-      nesting: k(
-        ze.aggregate(),
+      nesting: b(
+        bt.aggregate(),
         {
-          items: ze.toArray()
+          items: bt.toArray()
         },
-        dt.c()
+        Ls.c()
       ),
-      selectors: k(
-        ve.aggregate(),
+      selectors: b(
+        Et.aggregate(),
         {
-          items: ve.toArray()
+          items: Et.toArray()
         },
-        mt.c()
+        Ns.c()
       ),
-      declarations: k(
-        Se.aggregate(),
+      declarations: b(
+        Ct.aggregate(),
         {
-          items: Se.toArray()
+          items: Ct.toArray()
         },
-        gt.c()
+        Us.c()
       )
     },
     selectors: {
-      total: Q,
-      totalUnique: Tt,
-      uniquenessRatio: z(Tt, Q),
-      specificity: k(
+      total: we,
+      totalUnique: si,
+      uniquenessRatio: H(si, we),
+      specificity: b(
         {
           /** @type Specificity */
-          min: B === void 0 ? [0, 0, 0] : B,
+          min: ue === void 0 ? [0, 0, 0] : ue,
           /** @type Specificity */
-          max: j === void 0 ? [0, 0, 0] : j,
+          max: _e === void 0 ? [0, 0, 0] : _e,
           /** @type Specificity */
-          sum: [Ke.sum, Ne.sum, je.sum],
+          sum: [Bt.sum, $t.sum, Gt.sum],
           /** @type Specificity */
-          mean: [Ke.mean, Ne.mean, je.mean],
+          mean: [Bt.mean, $t.mean, Gt.mean],
           /** @type Specificity */
-          mode: [Ke.mode, Ne.mode, je.mode],
+          mode: [Bt.mode, $t.mode, Gt.mode],
           /** @type Specificity */
-          items: vt
+          items: qs
         },
-        xt.c()
+        Fs.c()
       ),
-      complexity: k(Ht, Ct.c(), {
-        items: se.toArray()
+      complexity: b(ni, Ms.c(), {
+        items: Xe.toArray()
       }),
-      nesting: k(
-        Oe.aggregate(),
+      nesting: b(
+        St.aggregate(),
         {
-          items: Oe.toArray()
+          items: St.toArray()
         },
-        qt.c()
+        Bs.c()
       ),
-      id: k(Pe.c(), {
-        ratio: z(Pe.size(), Q)
+      id: b(Tt.c(), {
+        ratio: H(Tt.size(), we)
       }),
-      pseudoClasses: St.c(),
-      accessibility: k(Re.c(), {
-        ratio: z(Re.size(), Q)
+      pseudoClasses: zs.c(),
+      accessibility: b(Ot.c(), {
+        ratio: H(Ot.size(), we)
       }),
-      keyframes: qe.c(),
-      prefixed: k(Ae.c(), {
-        ratio: z(Ae.size(), Q)
+      keyframes: Rt.c(),
+      prefixed: b(vt.c(), {
+        ratio: H(vt.size(), we)
       }),
-      combinators: zt.c()
+      combinators: Ks.c()
     },
     declarations: {
-      total: L,
-      totalUnique: Ut,
-      uniquenessRatio: z(Ut, L),
+      total: Ne,
+      totalUnique: ti,
+      uniquenessRatio: H(ti, Ne),
       importants: {
-        total: ae,
-        ratio: z(ae, L),
+        total: Ze,
+        ratio: H(Ze, Ne),
         inKeyframes: {
-          total: De,
-          ratio: z(De, ae)
+          total: Nt,
+          ratio: H(Nt, Ze)
         }
       },
-      complexity: Kt,
-      nesting: k(
-        Ee.aggregate(),
+      complexity: li,
+      nesting: b(
+        Lt.aggregate(),
         {
-          items: Ee.toArray()
+          items: Lt.toArray()
         },
-        Rt.c()
+        Ys.c()
       )
     },
-    properties: k(ee.c(), {
-      prefixed: k(Ie.c(), {
-        ratio: z(Ie.size(), ee.size())
+    properties: b(Ue.c(), {
+      prefixed: b(It.c(), {
+        ratio: H(It.size(), Ue.size())
       }),
-      custom: k(oe.c(), {
-        ratio: z(oe.size(), ee.size()),
-        importants: k(Fe.c(), {
-          ratio: z(Fe.size(), oe.size())
+      custom: b(Je.c(), {
+        ratio: H(Je.size(), Ue.size()),
+        importants: b(Ut.c(), {
+          ratio: H(Ut.size(), Je.size())
         })
       }),
-      browserhacks: k(_e.c(), {
-        ratio: z(_e.size(), ee.size())
+      browserhacks: b(Ht.c(), {
+        ratio: H(Ht.size(), Ue.size())
       }),
-      complexity: Nt
+      complexity: oi
     }),
     values: {
-      colors: k(Y.count(), {
-        formats: G.c()
+      colors: b(xe.count(), {
+        formats: me.c()
       }),
-      gradients: _t.c(),
-      fontFamilies: Te.c(),
-      fontSizes: Ve.c(),
-      lineHeights: We.c(),
-      zindexes: Dt.c(),
-      textShadows: Ft.c(),
-      boxShadows: Et.c(),
-      borderRadiuses: It.count(),
+      gradients: Zs.c(),
+      fontFamilies: Ft.c(),
+      fontSizes: Mt.c(),
+      lineHeights: qt.c(),
+      zindexes: Qs.c(),
+      textShadows: Vs.c(),
+      boxShadows: js.c(),
+      borderRadiuses: Js.count(),
       animations: {
-        durations: ce.c(),
-        timingFunctions: ue.c()
+        durations: Kt.c(),
+        timingFunctions: zt.c()
       },
-      prefixes: Ot.c(),
-      browserhacks: Ue.c(),
-      units: He.count(),
-      complexity: jt,
-      keywords: ie.c(),
-      resets: Mt.c()
+      prefixes: Ws.c(),
+      browserhacks: Dt.c(),
+      units: Xs.count(),
+      complexity: ai,
+      keywords: He.c(),
+      resets: ei.c()
     },
     __meta__: {
-      parseTime: E - O,
-      analyzeTime: Date.now() - E,
-      total: Date.now() - r
+      parseTime: f - c,
+      analyzeTime: Date.now() - f,
+      total: Date.now() - s
     }
   };
 }
-function ri(i, e) {
-  return i[0] === e[0] ? i[1] === e[1] ? e[2] - i[2] : e[1] - i[1] : e[0] - i[0];
+function Li(r, e) {
+  return r[0] === e[0] ? r[1] === e[1] ? e[2] - r[2] : e[1] - r[1] : e[0] - r[0];
 }
 export {
-  F as KeywordSet,
-  Ji as analyze,
-  Oi as colorFunctions,
-  Di as colorKeywords,
-  ri as compareSpecificity,
-  pe as cssKeywords,
-  N as hasVendorPrefix,
-  oi as isAccessibilitySelector,
-  Si as isMediaBrowserhack,
-  Hi as isPropertyHack,
-  zi as isSelectorPrefixed,
-  vi as isSupportsBrowserhack,
-  ci as isValuePrefixed,
-  Pi as namedColors,
-  ui as selectorComplexity,
-  Ri as systemColors
+  $ as KeywordSet,
+  dl as analyze,
+  Oi as calculateSpecificity,
+  Vn as colorFunctions,
+  jn as colorKeywords,
+  Li as compareSpecificity,
+  ut as cssKeywords,
+  pl as hasVendorPrefix,
+  Di as isAccessibilitySelector,
+  br as isMediaBrowserhack,
+  fl as isPropertyHack,
+  Rr as isSelectorPrefixed,
+  Cr as isSupportsBrowserhack,
+  rl as isValuePrefixed,
+  Wn as namedColors,
+  rs as selectorComplexity,
+  Qn as systemColors
 };