@projectwallace/css-analyzer 7.6.2 → 8.0.0

package/dist/css-analyzer.js

@@ -1,188 +1,1810 @@
-var pi = Object.defineProperty;
-var Zt = (i) => {
-  throw TypeError(i);
+var or = 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 h = (i, e, t) => (Jt(i, e, "read from private field"), t ? t.call(i) : e.get(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 ar = (r, e, t) => e in r ? or(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var g = (r, e, t) => ar(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 h(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 I(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", V = "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 === V && q(t, r.name);
-}
-function vi(i) {
+import { walk as B, SUPPORTS_QUERY as Hi, BREAK as Q, MEDIA_TYPE as hr, MEDIA_FEATURE as Ii, str_equals as P, DIMENSION as ft, NUMBER as _s, IDENTIFIER as he, SELECTOR as ce, NTH_SELECTOR as cr, 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 _r, CLASS_SELECTOR as ur, ID_SELECTOR as fr, FUNCTION as gs, OPERATOR as Ee, is_custom as xs, is_vendor_prefixed as ms, parse as pr, AT_RULE as dr, BLOCK as gr, DECLARATION as jt, LAYER_NAME as xr, CONTAINER_QUERY as mr, STYLE_RULE as kr, HASH as wr, URL as Ar, str_starts_with as yr } from "@projectwallace/css-parser";
+function Er(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 Cr(r) {
   let e = !1;
-  return li(i, function(t) {
-    let { mediaType: r, name: n, value: c, type: g, kind: w } = t;
-    if (g === di && r !== null) {
-      if (Xe("\\0", r) || I("\\9 ", r))
-        return e = !0, this.break;
-    } else if (g === "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 === hr) {
+      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 D {
+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 D(["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 br(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 Rr(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 === cr) {
+        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 g = r.prev.data.loc.end, w = {
-          offset: g.offset,
-          line: g.line,
-          column: g.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 vr(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 Tr(r) {
+  return r < 128 && (y[r] & q) !== 0;
+}
+function Je(r) {
+  return r < 128 && (y[r] & pt) !== 0;
+}
+function Or(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 : Or(r);
+}
+function et(r) {
+  return r === 45 ? !0 : Me(r) || Tr(r);
+}
+const le = 1, it = 2, Sr = 3, Fi = 4, Mi = 5, xi = 6, de = 9, rt = 10, Nr = 11, qi = 12, ns = 13, Ur = 14, Lr = 15, zi = 16, Hr = 17, qe = 18, ls = 19, Ki = 20, Bi = 21, $i = 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, tt = 43, Zr = 37, Jr = 101, en = 69, Ai = 13, yi = 10;
+class Gi {
+  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(zi, 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(Ki, s, this.pos, i, n);
+      case mi:
+        return this.advance(), this.make_token(Bi, s, this.pos, i, n);
+      case $r:
+        return this.advance(), this.make_token($i, 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 === tt) {
+      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);
+          Je(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 (!Je(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 === tt || 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 === tt || l === K) && c) {
+          if (this.advance(), this.pos < this.source.length) {
+            let _ = this.source.charCodeAt(this.pos);
+            (_ === tt || _ === K) && this.advance();
           }
-        });
+          for (; this.pos < this.source.length; ) {
+            let _ = this.source.charCodeAt(this.pos);
+            if (_ >= 128 || (y[_] & 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(Nr, s, this.pos, e, t);
+      if (Me(n) || n === K && Me(this.peek())) {
+        for (; this.pos < this.source.length && et(this.source.charCodeAt(this.pos)); )
+          this.advance();
+        return this.make_token(qi, s, this.pos, e, t);
+      }
+    }
+    return this.make_token(rt, 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(), Je(n)) {
+          this.advance();
+          for (let l = 0; l < 5 && this.pos < this.source.length && Je(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 (et(i))
+        this.advance();
+      else
+        break;
+    }
+    return this.pos < this.source.length && this.source.charCodeAt(this.pos) === mi ? (this.advance(), this.make_token(it, 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 && et(this.source.charCodeAt(this.pos)); )
+      this.advance();
+    return this.make_token(Sr, s, this.pos, e, t);
+  }
+  consume_hash(e, t) {
+    let s = this.pos;
+    for (this.advance(); this.pos < this.source.length && et(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 st = 36;
+const tn = 1, nt = 2, ze = 3, pe = 4, Yi = 5, Wi = 6, lt = 7, Qi = 10, as = 11, ot = 12, Vi = 13, sn = 14, ji = 15, rn = 16, nn = 17, Xi = 18, ln = 19, dt = 20, hs = 21, Zi = 22, Ji = 23, Ke = 24, be = 25, Ge = 26, at = 27, cs = 28, er = 29, Be = 30, re = 31, tr = 56, on = 32, an = 33, hn = 34, cn = 35, _n = 36, un = 37, fn = 38, pn = 39, sr = 40, dn = 1, gn = 2, Ei = 4, xn = 8, mn = 32, ir = 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 * st), 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 * st;
+  }
+  // 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 * st);
+    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 * st;
+    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, ee = 43, rr = 46, ht = 126, nr = 62, In = 38, fe = 61, De = 124, bi = 36, Ri = 94, Pn = 58;
+function te(r) {
+  return r === Tn || r === On || r === Sn || r === Nn || r === Un;
+}
+function Dn(r) {
+  return r === nr || r === ee || 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 && te(r.charCodeAt(e)); )
+    e++;
+  return e;
+}
+function ye(r, e, t) {
+  for (; e < t; ) {
+    let s = r.charCodeAt(e);
+    if (te(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 (te(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 === rr || l === F || l === ee)
+      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",
+  [nt]: "Rule",
+  [ze]: "Atrule",
+  [pe]: "Declaration",
+  [Yi]: "Selector",
+  [Wi]: "Comment",
+  [lt]: "Block",
+  [Qi]: "Identifier",
+  [as]: "Number",
+  [ot]: "Dimension",
+  [Vi]: "String",
+  [sn]: "Hash",
+  [ji]: "Function",
+  [rn]: "Operator",
+  [nn]: "Parentheses",
+  [Xi]: "Url",
+  [ln]: "Value",
+  [dt]: "SelectorList",
+  [hs]: "TypeSelector",
+  [Zi]: "ClassSelector",
+  [Ji]: "IdSelector",
+  [Ke]: "AttributeSelector",
+  [be]: "PseudoClassSelector",
+  [Ge]: "PseudoElementSelector",
+  [at]: "Combinator",
+  [cs]: "UniversalSelector",
+  [er]: "NestingSelector",
+  [Be]: "Nth",
+  [re]: "NthOf",
+  [tr]: "Lang",
+  [on]: "MediaQuery",
+  [an]: "Feature",
+  [hn]: "MediaType",
+  [cn]: "ContainerQuery",
+  [_n]: "SupportsQuery",
+  [un]: "Layer",
+  [fn]: "Operator",
+  [pn]: "MediaFeatureRange",
+  [sr]: "AtrulePrelude"
+};
+class Ye {
+  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 === ot)
+      return es(t).value;
+    if (e === as)
+      return Number.parseFloat(this.text);
+    if (e === Xi) {
+      let n = this.first_child;
+      if (n && n.type === Vi)
+        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 === ot ? 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 === sr ? e : null;
+    }
+    if (this.type === nt)
+      return this.first_child;
+  }
+  /**
+   * Get the attribute operator (for attribute selectors: =, ~=, |=, ^=, $=, *=)
+   * Returns one of the ATTR_OPERATOR_* constants
+   */
+  get attr_operator() {
+    if (this.type === Ke)
+      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 === Ke)
+      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 === ot)
+      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 Ge:
+        return Fe(this.name);
+      case ze:
+        return Fe(this.name);
+      case ji:
+        return Fe(this.name);
+      case Qi:
+        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 === nt ? 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 === nt) {
+      let e = this.first_child;
+      if (!e) return null;
+      let t = e.next_sibling;
+      return t && t.type === lt ? t : null;
+    }
+    if (this.type === ze) {
+      let e = this.first_child;
+      for (; e; ) {
+        if (e.type === lt && !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 !== lt) return;
+    let e = this.first_child;
+    for (; e; ) {
+      if (e.type !== Wi)
+        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 Ye(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 Ye(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 === Ge) && this.arena.has_flag(this.index, ir) ? !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 !== Be && 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 !== Be && 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 (te(n)) {
+        i--;
+        continue;
+      }
+      n === F ? s = "-" + s : n === ee && (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 === Ke && (i.attr_operator = this.attr_operator, i.attr_flags = this.attr_flags), (this.type === Be || 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 Gi(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 _ = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+      if (Y("odd", _) || Y("even", _))
+        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) === ee) {
+      const _ = 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 = _.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(_);
+    }
+    if (this.lexer.token_type === qi) {
+      const _ = this.source.substring(this.lexer.token_start, this.lexer.token_end), f = Mn(_, "n");
+      if (f !== -1) {
+        if (n = this.lexer.token_start, l = this.lexer.token_start + f + 1, f + 1 < _.length) {
+          const x = _.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 === rt ? (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 === ee || e === F) {
+        const t = e === F ? "-" : "";
+        if (this.skip_whitespace(), this.lexer.next_token_fast(!0), this.lexer.token_type === rt) {
+          let s = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+          return s.charCodeAt(0) === ee && (s = s.substring(1)), t === "-" ? t + s : s;
+        }
+      }
+    }
+    if (this.lexer.token_type === rt) {
+      let e = this.source.substring(this.lexer.token_start, this.lexer.token_end);
+      const t = e.charCodeAt(0);
+      if (t === ee || t === F)
+        return t === ee && (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(Be, 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 Gi(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(
+          Yi,
+          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 === nr || n === ee || 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(Ji, t, s);
+      case de:
+        let i = this.source.charCodeAt(t);
+        return i === rr ? this.parse_class_selector(t) : i === W ? this.parse_universal_or_namespace_selector(t, s) : i === In ? this.create_node(er, t, s) : i === De ? this.parse_empty_namespace_selector(t) : null;
+      case ls:
+        return this.parse_attribute_selector(t);
+      case zi:
+        return this.parse_pseudo(t);
+      case it:
+        return this.parse_pseudo_function(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(Zi, 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 === Ki && (t--, t === 0)) {
+        n = this.lexer.token_start, s = this.lexer.token_end;
+        break;
+      }
+    }
+    let l = this.create_node(Ke, 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 (te(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 _ = this.source.charCodeAt(c), f = c + 1 < s ? this.source.charCodeAt(c + 1) : 0;
+    if (_ === fe)
+      l = c + 1, this.arena.set_attr_operator(e, wn);
+    else if (_ === ht && f === fe)
+      l = c + 2, this.arena.set_attr_operator(e, An);
+    else if (_ === De && f === fe)
+      l = c + 2, this.arena.set_attr_operator(e, yn);
+    else if (_ === Ri && f === fe)
+      l = c + 2, this.arena.set_attr_operator(e, En);
+    else if (_ === bi && f === fe)
+      l = c + 2, this.arena.set_attr_operator(e, Cn);
+    else if (_ === 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 (te(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 ? Ge : 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 === it)
+      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 _ = this.lexer.token_type;
+      if (_ === Bi || _ === it)
+        o++;
+      else if (_ === $i && (o--, o === 0)) {
+        l = this.lexer.token_start, h = this.lexer.token_end;
+        break;
+      }
+    }
+    let c = this.create_node(t ? Ge : 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, ir), l > n) {
+      let _ = this.source.substring(s, i);
+      if (this.is_nth_pseudo(_)) {
+        let f = this.parse_nth_expression(n, l);
+        f !== null && this.arena.set_first_child(c, f);
+      } else if (Y("lang", _))
+        this.parse_lang_identifiers(n, l, c);
+      else {
+        let f = this.selector_end;
+        const x = this.lexer.save_position();
+        let k = Y("has", _), 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, _ = this.lexer.token_end;
+      if (h !== ns && h !== qe) {
+        if (h === Mi || h === le) {
+          let f = this.create_node(tr, c, _);
+          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 _ = this.arena.create_node(re, e, t - e, this.lexer.line, 1);
+      return n !== null && c !== null ? (this.arena.set_first_child(_, n), this.arena.set_next_sibling(n, c)) : n !== null && this.arena.set_first_child(_, n), _;
+    } 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 || te(this.source.charCodeAt(s - 1)), o = s + 2 >= t || te(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 (te(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 Ye(e, r, i);
+  }
+  return new Ye(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 D([
+const _t = (r) => {
+  var n, l, o;
+  let e = 0, t = 0, s = 0, i = r.first_child;
+  for (; i; ) {
+    switch (i.type) {
+      case fr:
+        e += 1;
+        break;
+      case ps:
+      case ur:
+        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) === _r && 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 _ = (n = i.first_child) == null ? void 0 : n.first_child;
+            if ((_ == null ? void 0 : _.type) === ce) {
+              let f = _.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 _ = c.first_child;
+              for (; _ && _.type !== is; ) {
+                const f = _t({
+                  first_child: _
+                });
+                e += f[0] ?? 0, t += f[1] ?? 0, s += f[2] ?? 0, _ = _.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 +1957,7 @@ const Pi = new D([
   "mediumorchid",
   "darksalmon",
   "mediumspringgreen"
-]), Ri = new D([
+]), Qn = new $([
   // CSS System Colors
   // Spec: https://drafts.csswg.org/css-color/#css-system-colors
   "accentcolor",
@@ -357,7 +1979,7 @@ const Pi = new D([
   "selecteditem",
   "selecteditemtext",
   "visitedtext"
-]), Oi = new D(["rgba", "rgb", "hsla", "hsl", "oklch", "color", "hwb", "lch", "lab", "oklab"]), Di = new D(["transparent", "currentcolor"]), pe = new D([
+]), 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 +1989,13 @@ const Pi = new D([
   "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 === V && 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 D(["caption", "icon", "menu", "message-box", "small-caption", "status-bar"]), _i = new D([
+const ts = new $(["caption", "icon", "menu", "message-box", "small-caption", "status-bar"]), Zn = new $([
   /* <absolute-size> values */
   "xx-small",
   "x-small",
@@ -395,164 +2008,150 @@ const Ei = new D(["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 === V && 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 === V && 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 === V) {
-        let F = b.name;
-        if (_i.has(F)) {
-          n = F;
-          return;
-        }
-      }
+    if (o.next_sibling === null) {
+      t[1] = o, !s && !t[0] && n && (s = n.text), n = o;
+      continue;
     }
-  });
-  let g = 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: g
+    font_size: s,
+    line_height: i,
+    font_family: l
   };
 }
-const Ui = new D(["linear", "ease", "ease-in", "ease-out", "ease-in-out", "step-start", "step-end"]), Ti = new D(["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 === V ? 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 === V && 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, M, U, $;
-class o {
+var oe, X, Z, Re;
+class p {
   constructor(e = !1) {
-    _(this, H);
-    _(this, M);
-    _(this, U, []);
-    _(this, $);
-    R(this, H, /* @__PURE__ */ new Map()), R(this, M, 0), e && R(this, U, []), R(this, $, e);
+    G(this, oe);
+    G(this, X);
+    G(this, Z, []);
+    G(this, Re);
+    M(this, oe, /* @__PURE__ */ new Map()), M(this, X, 0), e && M(this, Z, []), M(this, Re, e);
   }
   p(e, t) {
-    let r = h(this, M);
-    if (h(this, $)) {
-      let n = t.start, c = n.offset, g = r * 4;
-      h(this, U)[g] = n.line, h(this, U)[g + 1] = n.column, h(this, U)[g + 2] = c, h(this, U)[g + 3] = t.end.offset - c;
+    let s = w(this, X);
+    if (w(this, Re)) {
+      let i = s * 4;
+      w(this, Z)[i] = t.line, w(this, Z)[i + 1] = t.column, w(this, Z)[i + 2] = t.offset, w(this, Z)[i + 3] = t.length;
     }
-    if (h(this, H).has(e)) {
-      h(this, H).get(e).push(r), Ye(this, M)._++;
+    if (w(this, oe).has(e)) {
+      w(this, oe).get(e).push(s), Vt(this, X)._++;
       return;
     }
-    h(this, H).set(e, [r]), Ye(this, M)._++;
+    w(this, oe).set(e, [s]), Vt(this, X)._++;
   }
   size() {
-    return h(this, M);
+    return w(this, X);
   }
   c() {
-    let e = /* @__PURE__ */ new Map(), t = {}, r = h(this, $), n = h(this, H), c = h(this, U), g = n.size;
-    n.forEach((b, x) => {
-      if (r) {
-        let O = b.map(function(A) {
-          let F = A * 4;
+    let e = /* @__PURE__ */ new Map(), t = {}, s = w(this, Re), i = w(this, oe), n = w(this, Z), l = i.size;
+    i.forEach((h, c) => {
+      if (s) {
+        let _ = h.map(function(f) {
+          let x = f * 4;
           return {
-            line: c[F],
-            column: c[F + 1],
-            offset: c[F + 2],
-            length: c[F + 3]
+            line: n[x],
+            column: n[x + 1],
+            offset: n[x + 2],
+            length: n[x + 3]
           };
         });
-        e.set(x, O);
+        e.set(c, _);
       } else
-        t[x] = b.length;
+        t[c] = h.length;
     });
-    let w = h(this, M);
-    return r ? {
-      total: w,
-      totalUnique: g,
+    let o = w(this, X);
+    return s ? {
+      total: o,
+      totalUnique: l,
       unique: t,
-      uniquenessRatio: w === 0 ? 0 : g / w,
+      uniquenessRatio: o === 0 ? 0 : l / o,
       uniqueWithLocations: Object.fromEntries(e)
     } : {
-      total: w,
-      totalUnique: g,
+      total: o,
+      totalUnique: l,
       unique: t,
-      uniquenessRatio: w === 0 ? 0 : g / w,
+      uniquenessRatio: o === 0 ? 0 : l / o,
       uniqueWithLocations: void 0
     };
   }
 }
-H = new WeakMap(), M = new WeakMap(), U = new WeakMap(), $ = new WeakMap();
-var J, K, le;
-class $e {
+oe = new WeakMap(), X = new WeakMap(), Z = new WeakMap(), Re = new WeakMap();
+var ve, ae, We;
+class ss {
   constructor(e) {
-    _(this, J);
-    _(this, K);
-    _(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, We);
+    M(this, ve, new p(e)), M(this, ae, /* @__PURE__ */ new Map()), M(this, We, e);
   }
   /**
    * Add an item to this #list's context
@@ -560,46 +2159,46 @@ class $e {
    * @param context Context to push Item to
    * @param node_location
    */
-  push(e, t, r) {
-    h(this, J).p(e, r), h(this, K).has(t) || h(this, K).set(t, new o(h(this, le))), h(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, We))), w(this, ae).get(t).p(e, s);
   }
   count() {
     let e = /* @__PURE__ */ new Map();
-    for (let [t, r] of h(this, K).entries())
-      e.set(t, r.c());
-    return Object.assign(h(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 g = 0; g < c; g++) {
-    let w = i[g], 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(), We = 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 T, X;
-class S {
+var J, Te;
+class L {
   constructor() {
-    _(this, T);
-    _(this, X);
-    R(this, T, []), R(this, X, 0);
+    G(this, J);
+    G(this, Te);
+    M(this, J, []), M(this, Te, 0);
   }
   /**
    * Add a new Integer at the end of this AggregateCollection
    * @param item - The item to add
    */
   push(e) {
-    h(this, T).push(e), R(this, X, h(this, X) + e);
+    w(this, J).push(e), M(this, Te, w(this, Te) + e);
   }
   size() {
-    return h(this, T).length;
+    return w(this, J).length;
   }
   aggregate() {
-    let e = h(this, T).length;
+    let e = w(this, J).length;
     if (e === 0)
       return {
         min: 0,
@@ -609,24 +2208,40 @@ class S {
         range: 0,
         sum: 0
       };
-    let t = h(this, T).slice().sort((w, b) => w - b), r = t[0], n = t[e - 1], c = Wi(t), g = h(this, X);
+    let t = w(this, J).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: g / e,
-      mode: c,
-      range: n - r,
-      sum: g
+      min: s,
+      max: i,
+      mean: l / e,
+      mode: n,
+      range: i - s,
+      sum: l
     };
   }
   toArray() {
-    return h(this, T);
+    return w(this, J);
   }
 }
-T = new WeakMap(), X = new WeakMap();
-function Hi(i) {
-  if (tt(i) || N(i)) return !1;
-  let e = i.charCodeAt(0);
+J = 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 $e(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 +2250,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 : $e(r, e);
 }
-function m(i, e) {
-  return tt(e) ? !1 : I(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 === V && I("\\9", t.name));
+    let t = e.at(-1);
+    return !!(t && t.type === he && $e("\\9", t.text));
   }
   return !1;
 }
-let Bi = new D([
+function pl(r) {
+  return ms(r);
+}
+let cl = new $([
   "border-radius",
   "border-top-left-radius",
   "border-top-right-radius",
@@ -667,496 +2282,464 @@ let Bi = new D([
   "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 g = 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) {
-      g++, w += l.length;
-    }
-  }), F = 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), E = 0;
-  C(A, {
-    enter(l) {
-      var re, Yt, Gt;
-      switch (l.type) {
-        case Ge: {
-          it.p(l.name, l.loc), ke.push(E), pt.p(E, 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((u) => {
-              u.type === "Declaration" && (a[u.property] = n(u.value));
-            }), me.push(a), he.push(1);
-            break;
-          }
-          let d = 1;
-          if (l.prelude !== null) {
-            let a = l.prelude, u = a && n(l.prelude), p = a.loc;
-            if (s === "media")
-              nt.p(u, p), Si(a) && (st.p(u, p), d++);
-            else if (s === "supports")
-              de.p(u, p), vi(a) && (ut.p(u, p), d++);
-            else if (I("keyframes", s)) {
-              let y = "@" + s + " " + u;
-              N(s) && (we.p(y, p), d++), ye.p(y, p);
-            } else if (s === "import")
-              C(l, (y) => {
-                if (y.type === "Condition" && y.kind === "supports") {
-                  let f = n(y);
-                  return de.p(f, y.loc), C.break;
-                }
-              }), lt.p(u, p);
-            else if (s === "charset")
-              ot.p(u, p);
-            else if (s === "container") {
-              if (ct.p(u, p), a.type === "AtrulePrelude" && ((Yt = a.children.first) == null ? void 0 : Yt.type) === "Identifier") {
-                let y = a.children.first.name;
-                ne.p(y, p);
-              }
-            } else s === "property" && ft.p(u, p);
-          } else
-            s === "layer" && (ge.p("<anonymous>", l.loc), d++);
-          he.push(d);
-          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, d = l.block, a = s.children, u = d.children, p = a ? a.size : 0, y = u ? u.size : 0;
-          Ce.push(p + y), ht.p(p + y, l.loc), ve.push(p), mt.p(p, s.loc), Se.push(y), gt.p(y, d.loc), ze.push(E), dt.p(E, l.loc), be++, y === 0 && xe++;
-          break;
-        }
-        case yi: {
-          let s = n(l);
-          if (this.atrule && I("keyframes", this.atrule.name))
-            return qe.p(s, l.loc), this.skip;
-          oi(l) && Re.p(s, l.loc);
-          let d = qi(l);
-          if (d !== !1)
-            for (let v of d)
-              St.p(v, l.loc);
-          let a = ui(l);
-          zi(l) && Ae.p(s, l.loc), yt.add(s), se.push(a), Ct.p(a, l.loc), Oe.push(E - 1), qt.p(E - 1, l.loc);
-          let u = gi(l).toArray(), [p, y, f] = u;
-          return xt.p(u.toString(), l.loc), wt.push(p), kt.push(y), bt.push(f), 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), p > 0 && Pe.p(s, l.loc), Ai(l, function(P) {
-            zt.p(P.name, P.loc);
-          }), this.skip;
+  }, c = Date.now(), _ = pr(r, {
+    on_comment({ length: a }) {
+      n++, l += a;
+    }
+  }), f = Date.now(), x = new p(t), k = new L(), V = [], ws = new p(t), Qe = 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), Ve = 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), je = 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(), Xe = 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), Ze = 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(_, (a, D) => {
+    var ci, _i, ui, fi;
+    ke >= 0 && D <= ke && (ke = -1);
+    let Wt = ke >= 0 && D > ke;
+    if (a.type === dr) {
+      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 === gr);
+        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) && (Qe.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)), Cr(a.prelude) && (Es.p(a.prelude.text, A(a)), R++);
+        else if (P("supports", E))
+          gt.p(a.prelude.text, A(a)), Er(a.prelude) && (Rs.p(a.prelude.text, A(a)), R++);
+        else if ($e("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((u) => u.trim()))
+            Qe.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 === xr && typeof d.value == "string" && Qe.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) === mr && ((_i = a.prelude.first_child.first_child) == null ? void 0 : _i.type) === he && Ve.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 === kr)
+      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);
+      je.push(E), Ms.p(E, N), br(a) && vt.p(a.text, N), Di(a) && Ot.p(a.text, N);
+      let R = Rr(a);
+      if (R !== !1)
+        for (let se of R)
+          zs.p(se, N);
+      vr(a, function(T) {
+        let U = T.name.trim() === "" ? " " : T.name;
+        Ks.p(U, T.loc);
+      });
+      let d = _t(a), [u, z, Qt] = d;
+      return Fs.p(d.toString(), N), Is.push(u), 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), u > 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 I("\\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: u, is_browserhack: z, is_vendor_prefixed: Qt } = a, se = A(a);
+      Ue.p(u, se), d && Xe++, Qt ? (Le.push(2), It.p(u, se)) : xs(u) ? (Ze.p(u, se), Le.push(d ? 3 : 2), d && Ut.p(u, se)) : z ? (Ht.p(u, se), 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, d = s.length, a = Ni(s);
-            x.total++, b += d;
-            let u = {
-              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 p = x.unique.get(a);
-              p.count++, p.size += d, x.unique.set(a, p), t && p.uniqueWithLocations && p.uniqueWithLocations.push(u);
-            } else {
-              let p = {
-                count: 1,
-                size: d,
-                uniqueWithLocations: t ? [u] : void 0
-              };
-              x.unique.set(a, p);
+        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", u) || m("margin-block", u) || m("margin-inline", u) || m("margin-top", u) || m("margin-right", u) || m("margin-bottom", u) || m("margin-left", u) || m("padding", u) || m("padding-block", u) || m("padding-inline", u) || m("padding-top", u) || m("padding-right", u) || m("padding-bottom", u) || m("padding-left", u))
+          Xn(T) && ei.p(u, v);
+        else {
+          if (m("z-index", u))
+            return Qs.p(U, v), I;
+          if (m("font", u)) {
+            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: j } = C;
+              j && Ft.p(j, 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 d = this.declaration, { property: a, important: u } = d, p = 1;
-          ci(l) && (Ot.p(n(l), s), p++), typeof u == "string" && (Ue.p(c(l) + "!" + u, s), p++), ji(l) && (Ue.p(n(l), s), p++);
-          let y = l.children;
-          if (Me.push(p), m("margin", a) || m("margin-block", a) || m("margin-inline", a) || m("margin-top", a) || m("margin-right", a) || m("margin-bottom", a) || m("margin-left", a) || m("padding", a) || m("padding-block", a) || m("padding-inline", a) || m("padding-top", a) || m("padding-right", a) || m("padding-bottom", a) || m("padding-left", a))
-            Fi(l) && Mt.p(a, d.loc);
+          } else if (m("font-size", u))
+            ts.has(U) || Mt.p(U, v);
           else {
-            if (m("z-index", a))
-              return Dt.p(n(l), s), this.skip;
-            if (m("font", a)) {
-              if (Ze(l)) return;
-              let f = Mi(l, n, function(Qt) {
-                Qt.type === "keyword" && ie.p(Qt.value, s);
-              });
-              if (!f)
-                return this.skip;
-              let { font_size: v, line_height: P, font_family: W } = f;
-              W && Te.p(W, s), v && Ve.p(v, s), P && We.p(P, s);
-              break;
-            } else if (m("font-size", a)) {
-              Ze(l) || Ve.p(n(l), s);
-              break;
-            } else if (m("font-family", a)) {
-              Ze(l) || Te.p(n(l), s);
-              break;
-            } else if (m("line-height", a))
-              We.p(n(l), s);
-            else if (m("transition", a) || m("animation", a)) {
-              Vi(y, function(f) {
-                f.type === "fn" ? ue.p(n(f.value), s) : f.type === "duration" ? ce.p(n(f.value), s) : f.type === "keyword" && ie.p(n(f.value), s);
-              });
-              break;
-            } else if (m("animation-duration", a) || m("transition-duration", a)) {
-              y && y.size > 1 ? y.forEach((f) => {
-                f.type !== Z && ce.p(n(f), s);
-              }) : ce.p(n(l), s);
-              break;
-            } else if (m("transition-timing-function", a) || m("animation-timing-function", a)) {
-              y && y.size > 1 ? y.forEach((f) => {
-                f.type !== Z && ue.p(n(f), s);
-              }) : ue.p(n(l), s);
-              break;
-            } else if (m("container-name", a))
-              ne.p(n(l), s);
-            else if (m("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 m("text-shadow", a) ? fe(l) || Ft.p(n(l), s) : m("box-shadow", a) && (fe(l) || Et.p(n(l), s));
+            if (m("font-family", u))
+              return ts.has(U) || Ft.p(U, v), I;
+            if (m("line-height", u))
+              qt.p(U, v);
+            else {
+              if (m("transition", u) || m("animation", u))
+                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", u) || m("transition-duration", u))
+                for (let C of T.children)
+                  C.type !== Ee && Kt.p(C.text, v);
+              else if (m("transition-timing-function", u) || m("animation-timing-function", u))
+                for (let C of T.children)
+                  C.type !== Ee && zt.p(C.text, v);
+              else m("container-name", u) ? Ve.p(U, v) : m("container", u) ? ((fi = T.first_child) == null ? void 0 : fi.type) === he && Ve.p(T.first_child.text, v) : cl.has(al(u)) ? Js.push(U, u, v) : m("text-shadow", u) ? Vs.p(U, v) : m("box-shadow", u) && js.p(U, v);
+            }
           }
-          C(l, function(f) {
-            let v = f.name;
-            switch (f.type) {
-              case xi: {
-                let P = f.value.length;
-                return I("\\9", f.value) && (P = P - 2), Y.push("#" + f.value, a, s), G.p("hex" + P, s), C.skip;
+        }
+        let lr = Ni(T);
+        B(T, (C) => {
+          switch (C.type) {
+            case ft: {
+              let O = C.unit, S = A(C);
+              return Xs.push(O, u, S), I;
+            }
+            case wr: {
+              let O = C.text;
+              if (!O || !O.startsWith("#"))
+                return I;
+              let S = O;
+              lr && !S.endsWith("\\9") && (S = S + "\\9");
+              let j = S.length - 1;
+              $e("\\9", S) && (j = j - 2);
+              let Ie = A(C);
+              return xe.push(S, u, Ie), me.p("hex" + j, Ie), I;
+            }
+            case he: {
+              let O = C.text, S = A(C);
+              if (m("font", u) || m("font-family", u))
+                return I;
+              ut.has(O) && He.p(O, S);
+              let j = O.length;
+              if (j > 20 || j < 3)
+                return I;
+              if (jn.has(O)) {
+                xe.push(O, u, S), me.p(O.toLowerCase(), S);
+                return;
               }
-              case V: {
-                pe.has(v) && ie.p(v, s);
-                let P = v.length;
-                if (P > 20 || P < 3)
-                  return C.skip;
-                if (Di.has(v)) {
-                  let W = n(f);
-                  Y.push(W, a, s), G.p(v.toLowerCase(), s);
-                  return;
-                }
-                if (Pi.has(v)) {
-                  let W = n(f);
-                  Y.push(W, a, s), G.p("named", s);
-                  return;
-                }
-                if (Ri.has(v)) {
-                  let W = n(f);
-                  Y.push(W, a, s), G.p("system", s);
-                  return;
-                }
-                return C.skip;
+              if (Wn.has(O)) {
+                xe.push(O, u, S), me.p("named", S);
+                return;
               }
-              case et: {
-                if (q("var", v))
-                  return C.skip;
-                if (Oi.has(v)) {
-                  Y.push(n(f), a, f.loc), G.p(v.toLowerCase(), f.loc);
-                  return;
-                }
-                if (I("gradient", v)) {
-                  _t.p(n(f), f.loc);
-                  return;
-                }
+              if (Qn.has(O)) {
+                xe.push(O, u, 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(E - 1), Rt.p(E - 1, l.loc), l.important === !0 && (ae++, s++, this.atrule && I("keyframes", this.atrule.name) && (De++, s++)), Pt.push(s);
-          let {
-            property: d,
-            // @ts-expect-error TODO: fix this
-            loc: { start: a }
-          } = l, u = {
-            start: {
-              line: a.line,
-              column: a.column,
-              offset: a.offset
-            },
-            end: {
-              offset: a.offset + d.length
+            case gs: {
+              let O = C.name, S = A(C);
+              if (Vn.has(O)) {
+                xe.push(C.text, u, S), me.p(O.toLowerCase(), S);
+                return;
+              }
+              if ($e("gradient", O)) {
+                Zs.p(C.text, S);
+                return;
+              }
             }
+          }
+        });
+      }
+    } else if (a.type === Ar) {
+      let { value: N } = a, E = ll(N || "");
+      if (yr(E, "data:")) {
+        let R = E.length, d = hl(E);
+        h.total++, o += R;
+        let u = {
+          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(u);
+        } else {
+          let z = {
+            count: 1,
+            size: R,
+            uniqueWithLocations: t ? [u] : void 0
           };
-          ee.p(d, u), N(d) ? (Ie.p(d, u), te.push(2)) : Hi(d) ? (_e.p(d, u), te.push(2)) : tt(d) ? (oe.p(d, u), te.push(l.important ? 3 : 2), l.important === !0 && Fe.p(d, u)) : te.push(1);
-          break;
+          h.unique.set(d, z);
         }
       }
-      (l.type === Qe || l.type === Ge) && E++;
-    },
-    leave(l) {
-      (l.type === Qe || l.type === Ge) && E--;
-    }
+    } 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 = je.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 = je.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: g,
-        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: Ve.c()
       }),
-      layer: ge.c(),
-      property: ft.c(),
-      complexity: Wt,
-      nesting: k(
-        ke.aggregate(),
+      layer: Qe.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: je.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: Xe,
+        ratio: H(Xe, Ne),
         inKeyframes: {
-          total: De,
-          ratio: z(De, ae)
+          total: Nt,
+          ratio: H(Nt, Xe)
         }
       },
-      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(Ze.c(), {
+        ratio: H(Ze.size(), Ue.size()),
+        importants: b(Ut.c(), {
+          ratio: H(Ut.size(), Ze.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: F - O,
-      analyzeTime: Date.now() - F,
-      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 {
-  D 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,
+  Cr as isMediaBrowserhack,
+  fl as isPropertyHack,
+  br as isSelectorPrefixed,
+  Er as isSupportsBrowserhack,
+  rl as isValuePrefixed,
+  Wn as namedColors,
+  rs as selectorComplexity,
+  Qn as systemColors
 };