@projectwallace/css-design-tokens 0.9.0 → 0.11.0

package/dist/css-design-tokens.js

@@ -1,85 +1,1171 @@
-import { cssKeywords as T, colorKeywords as W, namedColors as K, systemColors as M, colorFunctions as Z, analyze as U } from "@projectwallace/css-analyzer";
-import { convert as V } from "css-time-sort";
-import { convert as J } from "color-sorter";
-import { parse as $ } from "css-tree";
-import { ColorSpace as o, sRGB as Q, XYZ_D65 as ee, XYZ_D50 as te, XYZ_ABS_D65 as re, Lab_D65 as ne, Lab as ie, LCH as le, sRGB_Linear as se, HSL as oe, HWB as ue, HSV as ae, P3_Linear as fe, P3 as ce, A98RGB_Linear as pe, A98RGB as me, ProPhoto_Linear as ge, ProPhoto as he, REC_2020_Linear as de, REC_2020 as _e, OKLab as ve, OKLCH as $e, OKLrab as be, parse as xe } from "colorjs.io/fn";
-const A = 0, j = 1, z = 2, y = 3, I = 4, R = 5, H = 6, X = 7, D = 8, P = 9, Y = 10, v = 11, ye = /* @__PURE__ */ new Map([
-  [A, "white"],
-  [j, "black"],
-  [z, "grey"],
-  [y, "red"],
-  [I, "orange"],
-  [R, "yellow"],
-  [H, "green"],
-  [X, "cyan"],
-  [D, "blue"],
-  [P, "magenta"],
-  [Y, "pink"],
-  [v, "unknown"]
+import { cssKeywords as nt, colorKeywords as rt, namedColors as ot, systemColors as ht, colorFunctions as lt, analyze as at } from "@projectwallace/css-analyzer";
+import { convert as ut } from "css-time-sort";
+import { convert as _t } from "color-sorter";
+import { ColorSpace as a, sRGB as ct, XYZ_D65 as ft, XYZ_D50 as dt, XYZ_ABS_D65 as pt, Lab_D65 as gt, Lab as mt, LCH as vt, sRGB_Linear as Et, HSL as At, HWB as kt, HSV as xt, P3_Linear as Ct, P3 as Rt, A98RGB_Linear as wt, A98RGB as yt, ProPhoto_Linear as bt, ProPhoto as Tt, REC_2020_Linear as Ot, REC_2020 as Nt, OKLab as St, OKLCH as Lt, OKLrab as Ht, tryColor as $t } from "colorjs.io/fn";
+import { parse_value as He } from "@projectwallace/css-parser";
+const $e = 0, Ue = 1, Ie = 2, he = 3, Pe = 4, Fe = 5, De = 6, Ke = 7, Me = 8, Ge = 9, Be = 10, W = 11, Ut = /* @__PURE__ */ new Map([
+  [$e, "white"],
+  [Ue, "black"],
+  [Ie, "grey"],
+  [he, "red"],
+  [Pe, "orange"],
+  [Fe, "yellow"],
+  [De, "green"],
+  [Ke, "cyan"],
+  [Me, "blue"],
+  [Ge, "magenta"],
+  [Be, "pink"],
+  [W, "unknown"]
 ]);
-function we(n) {
-  let t = /* @__PURE__ */ new Map();
-  for (let i in n) {
-    let e = v;
-    if (!i.includes("var(") && !i.includes("calc(")) {
-      let s = J(i), { hue: l, saturation: r, lightness: f } = s;
-      r < 10 && f === 100 ? e = A : r < 10 && f === 0 ? e = j : r < 5 ? e = z : l < 22 ? e = y : l < 50 ? e = I : l < 72 ? e = R : l < 144 ? e = H : l < 180 ? e = X : l < 250 ? e = D : l < 300 ? e = P : l < 350 ? e = Y : e = y;
-    }
-    t.has(e) ? t.get(e).push(i) : t.set(e, [i]);
-  }
-  return Array.from(t).sort(
-    (i, e) => i[0] === v || e[0] === v ? -1 : e[1].length - i[1].length
+function It(r) {
+  let e = /* @__PURE__ */ new Map();
+  for (let t in r) {
+    let s = W;
+    if (!t.includes("var(") && !t.includes("calc(")) {
+      let i = _t(t), { hue: n, saturation: o, lightness: h } = i;
+      o < 10 && h === 100 ? s = $e : o < 10 && h === 0 ? s = Ue : o < 5 ? s = Ie : n < 22 ? s = he : n < 50 ? s = Pe : n < 72 ? s = Fe : n < 144 ? s = De : n < 180 ? s = Ke : n < 250 ? s = Me : n < 300 ? s = Ge : n < 350 ? s = Be : s = he;
+    }
+    e.has(s) ? e.get(s).push(t) : e.set(s, [t]);
+  }
+  return Array.from(e).sort(
+    (t, s) => t[0] === W || s[0] === W ? -1 : s[1].length - t[1].length
   );
 }
-const c = "com.projectwallace.css-authored-as", u = "com.projectwallace.usage-count", x = "com.projectwallace.css-properties";
-o.register(Q);
-o.register(ee);
-o.register(te);
-o.register(re);
-o.register(ne);
-o.register(ie);
-o.register(le);
-o.register(se);
-o.register(oe);
-o.register(ue);
-o.register(ae);
-o.register(fe);
-o.register(ce);
-o.register(pe);
-o.register(me);
-o.register(ge);
-o.register(he);
-o.register(de);
-o.register(_e);
-o.register(ve);
-o.register($e);
-o.register(be);
-function g(n) {
-  let t = n.toLowerCase();
-  if (t === "transparent")
+let de = 1, p = 2, ee = 4, S = 8, y = 16, l = new Uint8Array(128);
+for (let r = 48; r <= 57; r++)
+  l[r] = p;
+for (let r = 48; r <= 57; r++)
+  l[r] |= ee;
+for (let r = 65; r <= 70; r++)
+  l[r] = ee;
+for (let r = 97; r <= 102; r++)
+  l[r] = ee;
+for (let r = 65; r <= 90; r++)
+  l[r] |= de;
+for (let r = 97; r <= 122; r++)
+  l[r] |= de;
+l[32] = S;
+l[9] = S;
+l[10] = y;
+l[13] = y;
+l[12] = y;
+function Pt(r) {
+  return r < 128 && (l[r] & p) !== 0;
+}
+function K(r) {
+  return r < 128 && (l[r] & ee) !== 0;
+}
+function Ft(r) {
+  return r < 128 && (l[r] & de) !== 0;
+}
+function Ae(r) {
+  return r < 128 && (l[r] & S) !== 0;
+}
+function C(r) {
+  return r < 128 && (l[r] & y) !== 0;
+}
+function P(r) {
+  return r >= 128 || r === 95 ? !0 : Ft(r);
+}
+function M(r) {
+  return r === 45 ? !0 : P(r) || Pt(r);
+}
+const Ye = 1, le = 2, Dt = 3, We = 4, ae = 5, ke = 6, qe = 9, je = 10, Xe = 11, ze = 12, Kt = 13, Mt = 14, Gt = 15, Bt = 16, Yt = 17, Qe = 18, Wt = 19, qt = 20, ue = 21, q = 22, jt = 23, Xt = 24, O = 26, zt = 123, Qt = 125, Vt = 58, Zt = 59, Jt = 44, es = 91, ts = 93, xe = 40, ss = 41, Ce = 47, Re = 42, is = 34, ns = 39, te = 46, rs = 60, os = 33, g = 45, hs = 62, ls = 64, as = 35, se = 92, G = 43, us = 37, _s = 101, cs = 69, we = 13, ye = 10;
+class fs {
+  source;
+  pos;
+  line;
+  column;
+  on_comment;
+  // Current token properties (avoiding object allocation)
+  token_type;
+  token_start;
+  token_end;
+  token_line;
+  token_column;
+  constructor(e, t) {
+    this.source = e, this.pos = 0, this.line = 1, this.column = 1, this.on_comment = t, this.token_type = O, 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 o = this.source.charCodeAt(this.pos);
+        if (o >= 128 || (l[o] & (S | y)) === 0) break;
+        this.advance();
+      }
+    if (this.pos >= this.source.length)
+      return this.make_token(O, this.pos, this.pos);
+    let t = this.source.charCodeAt(this.pos), s = this.pos, i = this.line, n = this.column;
+    switch (t) {
+      case zt:
+        return this.advance(), this.make_token(jt, s, this.pos, i, n);
+      case Qt:
+        return this.advance(), this.make_token(Xt, s, this.pos, i, n);
+      case Vt:
+        return this.advance(), this.make_token(Bt, s, this.pos, i, n);
+      case Zt:
+        return this.advance(), this.make_token(Yt, s, this.pos, i, n);
+      case Jt:
+        return this.advance(), this.make_token(Qe, s, this.pos, i, n);
+      case es:
+        return this.advance(), this.make_token(Wt, s, this.pos, i, n);
+      case ts:
+        return this.advance(), this.make_token(qt, s, this.pos, i, n);
+      case xe:
+        return this.advance(), this.make_token(ue, s, this.pos, i, n);
+      case ss:
+        return this.advance(), this.make_token(q, s, this.pos, i, n);
+    }
+    if (t < 128 && (l[t] & (S | y)) !== 0)
+      return this.consume_whitespace(i, n);
+    if (t === Ce && this.peek() === Re) {
+      let o = s, h = i, u = n;
+      for (this.advance(2); this.pos < this.source.length - 1; ) {
+        if (this.source.charCodeAt(this.pos) === Re && this.peek() === Ce) {
+          this.advance(2);
+          break;
+        }
+        this.advance();
+      }
+      let f = this.pos;
+      return this.on_comment && this.on_comment({
+        start: o,
+        end: f,
+        length: f - o,
+        line: h,
+        column: u
+      }), this.next_token_fast(e);
+    }
+    if (t === is || t === ns)
+      return this.consume_string(t, i, n);
+    if (t < 128 && (l[t] & p) !== 0)
+      return this.consume_number(i, n);
+    if (t === te) {
+      let o = this.peek();
+      if (o < 128 && (l[o] & p) !== 0)
+        return this.consume_number(i, n);
+    }
+    if (t === rs && this.pos + 3 < this.source.length && this.peek() === os && this.peek(2) === g && this.peek(3) === g)
+      return this.advance(4), this.make_token(Mt, s, this.pos, i, n);
+    if (t === g && this.pos + 2 < this.source.length && this.peek() === g && this.peek(2) === hs)
+      return this.advance(3), this.make_token(Gt, s, this.pos, i, n);
+    if (t === ls)
+      return this.consume_at_keyword(i, n);
+    if (t === as)
+      return this.consume_hash(i, n);
+    if (P(t))
+      return this.consume_ident_or_function(i, n);
+    if (t === g) {
+      let o = this.peek();
+      if (P(o) || o === g)
+        return this.consume_ident_or_function(i, n);
+    }
+    if (t === se) {
+      let o = this.peek();
+      if (o !== 0 && !C(o))
+        return this.consume_ident_or_function(i, n);
+    }
+    if (t === g || t === G) {
+      let o = this.peek();
+      if (o < 128 && (l[o] & p) !== 0)
+        return this.consume_number(i, n);
+      if (o === te) {
+        let u = this.peek(2);
+        if (u < 128 && (l[u] & p) !== 0)
+          return this.consume_number(i, n);
+      }
+    }
+    return this.advance(), this.make_token(qe, 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 || (l[i] & (S | y)) === 0) break;
+      this.advance();
+    }
+    return this.make_token(Kt, 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(ae, i, this.pos, t, s);
+      if (C(n))
+        return this.make_token(ke, i, this.pos, t, s);
+      if (n === se) {
+        if (this.advance(), this.pos < this.source.length) {
+          let o = this.source.charCodeAt(this.pos);
+          K(o) ? this.consume_hex_escape() : C(o) ? this.advance() : this.advance();
+        }
+        continue;
+      }
+      this.advance();
+    }
+    return this.make_token(ke, 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 (!K(t)) break;
+      this.advance(), e++;
+    }
+    if (this.pos < this.source.length) {
+      let t = this.source.charCodeAt(this.pos);
+      (Ae(t) || C(t)) && this.advance();
+    }
+  }
+  consume_number(e, t) {
+    let s = this.pos, i = this.source.charCodeAt(this.pos);
+    for ((i === G || i === g) && this.advance(); this.pos < this.source.length; ) {
+      let n = this.source.charCodeAt(this.pos);
+      if (n >= 128 || (l[n] & p) === 0) break;
+      this.advance();
+    }
+    if (this.pos < this.source.length && this.source.charCodeAt(this.pos) === te && this.pos + 1 < this.source.length) {
+      let n = this.peek();
+      if (n < 128 && (l[n] & p) !== 0)
+        for (this.advance(); this.pos < this.source.length; ) {
+          let o = this.source.charCodeAt(this.pos);
+          if (o >= 128 || (l[o] & p) === 0) break;
+          this.advance();
+        }
+    }
+    if (this.pos < this.source.length) {
+      let n = this.source.charCodeAt(this.pos);
+      if (n === _s || n === cs) {
+        let o = this.peek(), h = o < 128 && (l[o] & p) !== 0, u = this.peek(2), f = u < 128 && (l[u] & p) !== 0;
+        if (h || (o === G || o === g) && f) {
+          if (this.advance(), this.pos < this.source.length) {
+            let d = this.source.charCodeAt(this.pos);
+            (d === G || d === g) && this.advance();
+          }
+          for (; this.pos < this.source.length; ) {
+            let d = this.source.charCodeAt(this.pos);
+            if (d >= 128 || (l[d] & p) === 0) break;
+            this.advance();
+          }
+        }
+      }
+    }
+    if (this.pos < this.source.length) {
+      let n = this.source.charCodeAt(this.pos);
+      if (n === us)
+        return this.advance(), this.make_token(Xe, s, this.pos, e, t);
+      if (P(n) || n === g && P(this.peek())) {
+        for (; this.pos < this.source.length && M(this.source.charCodeAt(this.pos)); )
+          this.advance();
+        return this.make_token(ze, s, this.pos, e, t);
+      }
+    }
+    return this.make_token(je, 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 === se) {
+        if (this.pos + 1 >= this.source.length) break;
+        let n = this.peek();
+        if (C(n)) break;
+        if (this.advance(), K(n)) {
+          this.advance();
+          for (let o = 0; o < 5 && this.pos < this.source.length && K(this.source.charCodeAt(this.pos)); o++)
+            this.advance();
+          if (this.pos < this.source.length) {
+            let o = this.source.charCodeAt(this.pos);
+            (Ae(o) || C(o)) && this.advance();
+          }
+        } else
+          this.advance();
+      } else if (M(i))
+        this.advance();
+      else
+        break;
+    }
+    return this.pos < this.source.length && this.source.charCodeAt(this.pos) === xe ? (this.advance(), this.make_token(le, s, this.pos, e, t)) : this.make_token(Ye, s, this.pos, e, t);
+  }
+  consume_at_keyword(e, t) {
+    let s = this.pos;
+    for (this.advance(); this.pos < this.source.length && M(this.source.charCodeAt(this.pos)); )
+      this.advance();
+    return this.make_token(Dt, s, this.pos, e, t);
+  }
+  consume_hash(e, t) {
+    let s = this.pos;
+    for (this.advance(); this.pos < this.source.length && M(this.source.charCodeAt(this.pos)); )
+      this.advance();
+    return this.make_token(We, 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++, C(t) ? (t === we && this.pos < this.source.length && this.source.charCodeAt(this.pos) === ye && 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++, C(s) ? (s === we && this.pos < this.source.length && this.source.charCodeAt(this.pos) === ye && (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 {
-      colorSpace: "srgb",
-      components: [0, 0, 0],
-      alpha: 0
+      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
     };
-  if (T.has(t) || W.has(t) || t.includes("var("))
+  }
+  /**
+   * 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 B = 36;
+const ds = 1, j = 2, F = 3, R = 4, ps = 5, Ve = 6, X = 7, pe = 10, Z = 11, D = 12, ge = 13, Ze = 14, me = 15, _e = 16, Je = 17, ve = 18, ce = 19, et = 20, gs = 21, ms = 22, vs = 23, z = 24, Q = 25, fe = 26, Es = 27, As = 28, ks = 29, V = 30, w = 31, xs = 56, Cs = 32, Rs = 33, ws = 34, ys = 35, bs = 36, Ts = 37, Os = 38, Ns = 39, tt = 40, Ss = 1, Ls = 2, be = 4, Hs = 8, $s = 32, Us = 64, Is = 128;
+class L {
+  buffer;
+  view;
+  capacity;
+  // Number of nodes that can fit
+  count;
+  // Number of nodes currently allocated
+  growth_count;
+  // Number of times the arena has grown
+  overflow_lengths;
+  // Stores actual lengths for nodes > 65535 chars
+  // Growth multiplier when capacity is exceeded
+  static 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)
+  static NODES_PER_KB = 325;
+  // Buffer to avoid frequent growth (15%)
+  static CAPACITY_BUFFER = 1.2;
+  constructor(e = 1024) {
+    this.capacity = e, this.count = 1, this.growth_count = 0, this.buffer = new ArrayBuffer(e * B), 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 * L.NODES_PER_KB), i = Math.ceil(s * L.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 * B;
+  }
+  // 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, be)) {
+      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, be), 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 * L.GROWTH_FACTOR), t = new ArrayBuffer(e * B);
+    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 o = this.count;
+    this.count++;
+    const h = o * B;
+    return this.view.setUint8(h, e), this.view.setUint32(h + 12, t, !0), this.view.setUint32(h + 24, i, !0), this.view.setUint32(h + 28, n, !0), this.set_length(o, s), o;
+  }
+  // --- 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;
+  }
+}
+const Ps = 32, Fs = 9, Ds = 10, Ks = 13, Ms = 12, Gs = 47, Bs = 42, H = 45, Ee = 43, Ys = 46;
+function st(r) {
+  return r === Ps || r === Fs || r === Ds || r === Ks || r === Ms;
+}
+function ie(r) {
+  return r >= 48 && r <= 57;
+}
+function ne(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 Ws(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 I(r, e, t) {
+  if ((e === void 0 || t === void 0) && (e = 0, t = r.length), r.charCodeAt(e) !== H || r.charCodeAt(e + 1) === H || t - e < 3)
+    return !1;
+  for (let i = e + 2; i < t; i++)
+    if (r.charCodeAt(i) === H)
+      return !0;
+  return !1;
+}
+function re(r) {
+  let e = 0;
+  for (let n = 0; n < r.length; n++) {
+    let o = r.charCodeAt(n);
+    if (o === 101 || o === 69) {
+      if (n + 1 < r.length) {
+        let h = r.charCodeAt(n + 1);
+        if (ie(h)) {
+          e = n + 1;
+          continue;
+        }
+        if ((h === 43 || h === 45) && n + 2 < r.length) {
+          let u = r.charCodeAt(n + 2);
+          if (ie(u)) {
+            e = n + 1;
+            continue;
+          }
+        }
+      }
+      break;
+    }
+    if (ie(o) || o === Ys || o === H || o === 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 qs = {
+  [ds]: "StyleSheet",
+  [j]: "Rule",
+  [F]: "Atrule",
+  [R]: "Declaration",
+  [ps]: "Selector",
+  [Ve]: "Comment",
+  [X]: "Block",
+  [pe]: "Identifier",
+  [Z]: "Number",
+  [D]: "Dimension",
+  [ge]: "String",
+  [Ze]: "Hash",
+  [me]: "Function",
+  [_e]: "Operator",
+  [Je]: "Parentheses",
+  [ve]: "Url",
+  [ce]: "Value",
+  [et]: "SelectorList",
+  [gs]: "TypeSelector",
+  [ms]: "ClassSelector",
+  [vs]: "IdSelector",
+  [z]: "AttributeSelector",
+  [Q]: "PseudoClassSelector",
+  [fe]: "PseudoElementSelector",
+  [Es]: "Combinator",
+  [As]: "UniversalSelector",
+  [ks]: "NestingSelector",
+  [V]: "Nth",
+  [w]: "NthOf",
+  [xs]: "Lang",
+  [Cs]: "MediaQuery",
+  [Rs]: "Feature",
+  [ws]: "MediaType",
+  [ys]: "ContainerQuery",
+  [bs]: "SupportsQuery",
+  [Ts]: "Layer",
+  [Os]: "Operator",
+  [Ns]: "MediaFeatureRange",
+  [tt]: "AtrulePrelude"
+};
+class J {
+  arena;
+  source;
+  index;
+  constructor(e, t, s) {
+    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 qs[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 === R && this.first_child)
+      return this.first_child;
+    if (e === D)
+      return re(t).value;
+    if (e === Z)
+      return Number.parseFloat(this.text);
+    if (e === ve) {
+      let n = this.first_child;
+      if (n && n.type === ge)
+        return n.text;
+      if (Ws(t, "url(")) {
+        let o = t.indexOf("("), h = t.lastIndexOf(")");
+        if (o !== -1 && h !== -1 && h > o)
+          return t.substring(o + 1, h).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 === Z ? Number.parseFloat(e) : this.type === D ? re(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 === F) {
+      let e = this.first_child;
+      return e && e.type === tt ? e : null;
+    }
+    if (this.type === j)
+      return this.first_child;
+  }
+  /**
+   * Get the attribute operator (for attribute selectors: =, ~=, |=, ^=, $=, *=)
+   * Returns one of the ATTR_OPERATOR_* constants
+   */
+  get attr_operator() {
+    if (this.type === z)
+      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 === z)
+      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 === D)
+      return re(this.text).unit;
+  }
+  /** Check if this declaration has !important */
+  get is_important() {
+    if (this.type === R)
+      return this.arena.has_flag(this.index, Ss);
+  }
+  /** Check if this declaration has a browser hack prefix */
+  get is_browserhack() {
+    if (this.type === R)
+      return this.arena.has_flag(this.index, Is);
+  }
+  /** Check if this has a vendor prefix (computed on-demand) */
+  get is_vendor_prefixed() {
+    switch (this.type) {
+      case R:
+        return I(this.name);
+      case Q:
+      case fe:
+        return I(this.name);
+      case F:
+        return I(this.name);
+      case me:
+        return I(this.name);
+      case pe:
+        return I(this.text);
+      default:
+        return !1;
+    }
+  }
+  /** Check if this node has an error */
+  get has_error() {
+    return this.arena.has_flag(this.index, Ls);
+  }
+  /** Check if this node has a prelude (at-rules and style rules) */
+  get has_prelude() {
+    return this.type === F ? this.arena.get_value_length(this.index) > 0 : this.type === j ? this.first_child !== null : !1;
+  }
+  /** Check if this rule has a block { } */
+  get has_block() {
+    return this.arena.has_flag(this.index, Hs);
+  }
+  /** Check if this style rule has declarations */
+  get has_declarations() {
+    return this.arena.has_flag(this.index, $s);
+  }
+  /** Get the block node (for style rules and at-rules with blocks) */
+  get block() {
+    if (this.type === j) {
+      let e = this.first_child;
+      if (!e) return null;
+      let t = e.next_sibling;
+      return t && t.type === X ? t : null;
+    }
+    if (this.type === F) {
+      let e = this.first_child;
+      for (; e; ) {
+        if (e.type === X && !e.next_sibling)
+          return e;
+        e = e.next_sibling;
+      }
+      return null;
+    }
     return null;
-  try {
-    let i = xe(n), [e, s, l] = i.coords;
+  }
+  /** Check if this block is empty (no declarations or rules, only comments allowed) */
+  get is_empty() {
+    if (this.type !== X) return;
+    let e = this.first_child;
+    for (; e; ) {
+      if (e.type !== Ve)
+        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 J(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 J(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 === Q || this.type === fe) && this.arena.has_flag(this.index, Us) ? !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 !== V && this.type !== w) 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 !== V && this.type !== w) 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 (st(n)) {
+        i--;
+        continue;
+      }
+      n === H ? 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 === w)
+      return this.first_child ?? void 0;
+  }
+  /** Get the selector list from :nth-child(2n+1 of .foo) */
+  get selector() {
+    return this.type !== w ? void 0 : this.first_child?.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 !== Q) return;
+    let e = this.first_child;
+    if (e) {
+      if (e.type === et)
+        return e;
+      if (e.type === w)
+        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 === R && (i.property = this.name), this.value !== void 0 && this.value !== null && (i.value = this.value, this.unit && (i.unit = this.unit)), this.type === R && (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 === z && (i.attr_operator = this.attr_operator, i.attr_flags = this.attr_flags), (this.type === V || this.type === w) && (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 js {
+  lexer;
+  arena;
+  source;
+  value_end;
+  constructor(e, t) {
+    this.arena = e, this.source = t, this.lexer = new fs(t), this.value_end = 0;
+  }
+  // Parse a declaration value range into a VALUE wrapper node
+  // Returns single VALUE node index
+  parse_value(e, t, s, i) {
+    this.value_end = t, this.lexer.pos = e, this.lexer.line = s, this.lexer.column = i;
+    let n = this.parse_value_tokens();
+    if (n.length === 0)
+      return this.arena.create_node(ce, e, 0, s, i);
+    let o = this.arena.get_start_offset(n[0]), h = n[n.length - 1], u = this.arena.get_start_offset(h) + this.arena.get_length(h), f = this.arena.create_node(ce, o, u - o, s, i);
+    return this.arena.append_children(f, n), f;
+  }
+  // Core token parsing logic
+  parse_value_tokens() {
+    let e = [];
+    for (; this.lexer.pos < this.value_end && (this.lexer.next_token_fast(!1), !(this.lexer.token_start >= this.value_end || this.lexer.token_type === O)); ) {
+      if (this.is_whitespace_inline())
+        continue;
+      let s = this.parse_value_node();
+      s !== null && e.push(s);
+    }
+    return e;
+  }
+  // Helper to check if token is all whitespace (inline for hot paths)
+  is_whitespace_inline() {
+    if (this.lexer.token_start >= this.lexer.token_end) return !1;
+    for (let e = this.lexer.token_start; e < this.lexer.token_end; e++)
+      if (!st(this.source.charCodeAt(e)))
+        return !1;
+    return !0;
+  }
+  parse_value_node() {
+    let e = this.lexer.token_type, t = this.lexer.token_start, s = this.lexer.token_end;
+    switch (e) {
+      case Ye:
+        return this.create_node(pe, t, s);
+      case je:
+        return this.create_node(Z, t, s);
+      case Xe:
+      case ze:
+        return this.create_node(D, t, s);
+      case ae:
+        return this.create_node(ge, t, s);
+      case We:
+        return this.create_node(Ze, t, s);
+      case le:
+        return this.parse_function_node(t, s);
+      case qe:
+        return this.parse_operator_node(t, s);
+      case Qe:
+        return this.create_node(_e, t, s);
+      case ue:
+        return this.parse_parenthesis_node(t, s);
+      default:
+        return null;
+    }
+  }
+  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_length(i, s - t), i;
+  }
+  create_operator_node(e, t) {
+    return this.create_node(_e, e, t);
+  }
+  parse_operator_node(e, t) {
+    let s = this.source.charCodeAt(e);
+    return s === Ee || s === H || s === Bs || s === Gs ? this.create_operator_node(e, t) : null;
+  }
+  parse_function_node(e, t) {
+    let s = t - 1, i = this.source.substring(e, s), n = this.arena.create_node(
+      ne("url", i) ? ve : me,
+      e,
+      0,
+      // length unknown yet
+      this.lexer.token_line,
+      this.lexer.token_column
+    );
+    if (this.arena.set_content_start_delta(n, 0), this.arena.set_content_length(n, s - e), ne("url", i) || ne("src", i)) {
+      let b = this.lexer.save_position();
+      for (this.lexer.next_token_fast(!1); this.is_whitespace_inline() && this.lexer.pos < this.value_end; )
+        this.lexer.next_token_fast(!1);
+      let m = this.lexer.token_type;
+      if (this.lexer.restore_position(b), m !== ae) {
+        let T = 1, $ = t, k = t, U = t;
+        for (; T > 0; ) {
+          this.lexer.next_token_fast(!1);
+          let x = this.lexer.token_type;
+          if (x === O) break;
+          if (x === ue || x === le)
+            T++;
+          else if (x === q && (T--, T === 0)) {
+            U = this.lexer.token_start, $ = this.lexer.token_end;
+            break;
+          }
+        }
+        return this.arena.set_length(n, $ - e), this.arena.set_value_start_delta(n, k - e), this.arena.set_value_length(n, U - k), n;
+      }
+    }
+    let o = [], h = 1, u = t, f = t, d = t;
+    for (; this.lexer.pos < this.value_end && h > 0; ) {
+      this.lexer.next_token_fast(!1);
+      let b = this.lexer.token_type;
+      if (b === O || this.lexer.token_start >= this.value_end) break;
+      if (b === q && (h--, h === 0)) {
+        d = this.lexer.token_start, u = this.lexer.token_end;
+        break;
+      }
+      if (this.is_whitespace_inline()) continue;
+      let m = this.parse_value_node();
+      m !== null && o.push(m);
+    }
+    return this.arena.set_length(n, u - e), this.arena.set_value_start_delta(n, f - e), this.arena.set_value_length(n, d - f), this.arena.append_children(n, o), n;
+  }
+  parse_parenthesis_node(e, t) {
+    let s = this.arena.create_node(
+      Je,
+      e,
+      0,
+      // length unknown yet
+      this.lexer.token_line,
+      this.lexer.token_column
+    ), i = [], n = 1, o = t;
+    for (; this.lexer.pos < this.value_end && n > 0; ) {
+      this.lexer.next_token_fast(!1);
+      let h = this.lexer.token_type;
+      if (h === O || this.lexer.token_start >= this.value_end) break;
+      if (h === q && (n--, n === 0)) {
+        o = this.lexer.token_end;
+        break;
+      }
+      if (this.is_whitespace_inline()) continue;
+      let u = this.parse_value_node();
+      u !== null && i.push(u);
+    }
+    return this.arena.set_length(s, o - e), this.arena.append_children(s, i), s;
+  }
+}
+function it(r) {
+  const e = new L(L.capacity_for_source(r.length)), s = new js(e, r).parse_value(0, r.length, 1, 1);
+  return new J(e, r, s);
+}
+const v = "com.projectwallace.css-authored-as", _ = "com.projectwallace.usage-count", oe = "com.projectwallace.css-properties";
+a.register(ct);
+a.register(ft);
+a.register(dt);
+a.register(pt);
+a.register(gt);
+a.register(mt);
+a.register(vt);
+a.register(Et);
+a.register(At);
+a.register(kt);
+a.register(xt);
+a.register(Ct);
+a.register(Rt);
+a.register(wt);
+a.register(yt);
+a.register(bt);
+a.register(Tt);
+a.register(Ot);
+a.register(Nt);
+a.register(St);
+a.register(Lt);
+a.register(Ht);
+function N(r) {
+  let e = r.toLowerCase();
+  if (e === "transparent")
     return {
-      colorSpace: i.spaceId,
-      components: [
-        e ?? "none",
-        s ?? "none",
-        l ?? "none"
-      ],
-      alpha: i.alpha ?? 0
+      colorSpace: "srgb",
+      components: [0, 0, 0],
+      alpha: 0
     };
-  } catch {
+  if (nt.has(e) || rt.has(e) || e.includes("var("))
     return null;
-  }
+  let t = $t(r);
+  if (t === null) return null;
+  let [s, i, n] = t.coords;
+  return {
+    colorSpace: t.space.id,
+    components: [s ?? "none", i ?? "none", n ?? "none"],
+    alpha: t.alpha ?? 1
+  };
 }
-function O() {
+function Te() {
   return {
     color: void 0,
     offsetX: void 0,
@@ -89,138 +1175,125 @@ function O() {
     inset: !1
   };
 }
-function Se(n) {
-  let t = $(n, {
-    context: "value",
-    positions: !0
-  });
-  function i(l) {
-    return l.loc ? n.slice(l.loc.start.offset, l.loc.end.offset) : "";
-  }
-  let e = O(), s = [e];
-  return t.children.size < 2 ? null : (t.children.forEach((l) => {
-    if (l.type === "Identifier") {
-      if (l.name.toLowerCase() === "inset")
-        e.inset = !0;
-      else if (K.has(l.name) || M.has(l.name)) {
-        let r = g(l.name);
-        if (r === null)
-          return;
-        e.color = r;
+function Xs(r) {
+  let e = it(r), t = Te(), s = [t];
+  if (e.children.length < 2)
+    return null;
+  for (let i of e.children)
+    if (i.type_name === "Identifier") {
+      if (i.name.toLowerCase() === "inset")
+        t.inset = !0;
+      else if (ot.has(i.name) || ht.has(i.name)) {
+        let n = N(i.name);
+        if (n === null)
+          continue;
+        t.color = n;
       }
-    } else if (l.type === "Dimension" || l.type === "Number" && l.value === "0") {
-      let r = l.type === "Dimension" ? {
-        value: Number(l.value),
-        unit: l.unit
+    } else if (i.type_name === "Dimension" || i.type_name === "Number" && i.value === 0) {
+      let n = i.type_name === "Dimension" ? {
+        value: Number(i.value),
+        unit: i.unit
       } : {
         value: 0,
         unit: "px"
       };
-      e.offsetX ? e.offsetY ? e.blur ? e.spread || (e.spread = r) : e.blur = r : e.offsetY = r : e.offsetX = r;
-    } else if (l.type === "Function") {
-      if (Z.has(l.name)) {
-        let r = g(i(l));
-        if (r === null)
-          return;
-        e.color = r;
-      } else if (l.name.toLowerCase() === "var" && !e.color) {
-        let r = g(i(l));
-        if (r === null)
-          return;
-        e.color = r;
+      t.offsetX ? t.offsetY ? t.blur ? t.spread || (t.spread = n) : t.blur = n : t.offsetY = n : t.offsetX = n;
+    } else if (i.type_name === "Function") {
+      if (lt.has(i.name)) {
+        let n = N(i.text);
+        if (n === null)
+          continue;
+        t.color = n;
+      } else if (i.name.toLowerCase() === "var" && !t.color) {
+        let n = N(i.text);
+        if (n === null)
+          continue;
+        t.color = n;
       }
-    } else if (l.type === "Hash") {
-      let r = g(i(l));
-      if (r === null)
-        return;
-      e.color = r;
-    } else l.type === "Operator" && l.value === "," && (L(e), e = O(), s.push(e));
-  }), L(e), s);
-}
-const _ = {
+    } else if (i.type_name === "Hash") {
+      let n = N(i.text);
+      if (n === null)
+        continue;
+      t.color = n;
+    } else i.type_name === "Operator" && i.name === "," && (Oe(t), t = Te(), s.push(t));
+  return Oe(t), s;
+}
+const Y = {
   value: 0,
   unit: "px"
 };
-function L(n) {
-  return n.offsetX || (n.offsetX = _), n.offsetY || (n.offsetY = _), n.blur || (n.blur = _), n.spread || (n.spread = _), n.color || (n.color = g("#000")), n;
+function Oe(r) {
+  return r.offsetX || (r.offsetX = Y), r.offsetY || (r.offsetY = Y), r.blur || (r.blur = Y), r.spread || (r.spread = Y), r.color || (r.color = N("#000")), r;
 }
-const E = /* @__PURE__ */ new Map([
+const Ne = /* @__PURE__ */ new Map([
   ["linear", [0, 0, 1, 1]],
   ["ease", [0.25, 0.1, 0.25, 1]],
   ["ease-in", [0.42, 0, 1, 1]],
   ["ease-out", [0, 0, 0.58, 1]],
   ["ease-in-out", [0.42, 0, 0.58, 1]]
 ]);
-function Ne(n) {
-  if (n = n.trim().toLowerCase(), E.has(n))
-    return E.get(n);
-  if (n.includes("var("))
+function zs(r) {
+  if (r = r.trim().toLowerCase(), Ne.has(r))
+    return Ne.get(r);
+  if (r.includes("var("))
     return null;
-  if (n.startsWith("cubic-bezier(")) {
-    let t = n.replace("cubic-bezier(", "").replace(")", "").split(",").map((i) => Number(i.trim()));
-    if (t.length === 4 && t.every((i) => Number.isFinite(i)))
-      return t;
+  if (r.startsWith("cubic-bezier(")) {
+    let e = r.replace("cubic-bezier(", "").replace(")", "").split(",").map((t) => Number(t.trim()));
+    if (e.length === 4 && e.every((t) => Number.isFinite(t)))
+      return e;
   }
   return null;
 }
-function C(n) {
-  return n.replaceAll(/^['"]|['"]$/g, "");
+function Se(r) {
+  return r.replaceAll(/^['"]|['"]$/g, "");
 }
-function Oe(n) {
-  if (n.toLowerCase().includes("var("))
+function Qs(r) {
+  if (r.toLowerCase().includes("var("))
     return;
-  let t = $(n, {
-    context: "value",
-    positions: !0
-  });
-  function i(r) {
-    return r.loc ? n.slice(r.loc.start.offset, r.loc.end.offset) : "";
-  }
-  let e = [];
-  if (!t.children || t.children.size === 0)
-    return e;
-  let s = "", l;
-  for (let r of t.children) {
-    if (r.type === "Operator" && r.value === ",") {
-      e.push(C(s)), s = "", l = r.type;
+  let e = it(r), t = [], { children: s, has_children: i } = e;
+  if (!i || s.length === 0)
+    return t;
+  let n = "", o;
+  for (let h of s) {
+    if (h.type_name === "Operator" && h.name === ",") {
+      t.push(Se(n)), n = "", o = h.type_name;
       continue;
     }
-    l === "Identifier" && r.type === "Identifier" && (s += " "), s += i(r), l = r.type;
+    o === "Identifier" && h.type_name === "Identifier" && (n += " "), n += h.text, o = h.type_name;
   }
-  return e.push(C(s)), e;
+  return t.push(Se(n)), t;
 }
-function a(n) {
-  if (n === void 0 || typeof n == "number" && isNaN(n))
+function c(r) {
+  if (r === void 0 || typeof r == "number" && isNaN(r))
     return "0";
-  typeof n != "string" && (n = n.toString());
-  let t = 0;
-  for (let i of n)
-    t = (t << 5) - t + i.charCodeAt(0), t |= 0;
-  return (t >>> 0).toString(16);
-}
-function Le(n) {
-  let t = $(n, { context: "value" });
-  if (t.children === null || t.children.size !== 1) return null;
-  let i = t.children.first;
-  switch (i.type) {
+  typeof r != "string" && (r = r.toString());
+  let e = 0;
+  for (let t of r)
+    e = (e << 5) - e + t.charCodeAt(0), e |= 0;
+  return (e >>> 0).toString(16);
+}
+const Vs = /* @__PURE__ */ new Set(["px", "rem"]);
+function Zs(r) {
+  let e = He(r);
+  if (!e.has_children || e.children.length !== 1) return null;
+  let t = e.first_child;
+  switch (t.type_name) {
     case "Dimension": {
-      let e = Number(i.value);
-      return e === 0 ? 0 : {
-        value: e,
-        unit: i.unit
-      };
+      let { value: s, unit: i } = t;
+      return s === 0 ? 0 : i === "%" ? Number(s) / 100 : (i = i.toLowerCase(), Vs.has(i) ? {
+        value: s,
+        unit: i
+      } : null);
     }
     case "Number":
-      return Number(i.value);
-    case "Percentage":
-      return Number(i.value) / 100;
+      return Number(t.value);
     case "Identifier":
-      if (i.name === "normal")
+      if (t.name.toLowerCase() === "normal")
         return 1.2;
   }
   return null;
 }
-let q = /* @__PURE__ */ new Map([
+let Le = /* @__PURE__ */ new Map([
   ["xx-small", 0.6],
   ["x-small", 0.75],
   ["small", 0.89],
@@ -230,36 +1303,36 @@ let q = /* @__PURE__ */ new Map([
   ["xx-large", 2],
   ["xxx-large", 3]
 ]);
-function Ee(n) {
-  let t = $(n, { context: "value" });
-  if (t.children === null || t.children.size !== 1) return null;
-  let i = t.children.first;
-  switch (i.type) {
+function Js(r) {
+  let e = He(r);
+  if (!e.has_children || e.children.length !== 1) return null;
+  let t = e.first_child;
+  switch (t.type_name) {
     case "Dimension": {
-      let e = i.unit.toLowerCase();
-      if (e === "px" || e === "rem") {
-        let s = Number(i.value);
-        return s === 0 ? {
+      let s = t.unit.toLowerCase();
+      if (s === "px" || s === "rem") {
+        let i = Number(t.value);
+        return i === 0 ? {
           value: 0,
           unit: "px"
         } : {
-          value: s,
-          unit: e
+          value: i,
+          unit: s
         };
       }
       break;
     }
     case "Identifier": {
-      let e = i.name.toLowerCase();
-      if (q.has(e))
+      let s = t.name.toLowerCase();
+      if (Le.has(s))
         return {
-          value: q.get(e),
+          value: Le.get(s),
           unit: "rem"
         };
       break;
     }
     case "Number": {
-      if (Number(i.value) === 0)
+      if (Number(t.value) === 0)
         return {
           value: 0,
           unit: "px"
@@ -269,217 +1342,218 @@ function Ee(n) {
   }
   return null;
 }
-function Re(n) {
-  let t = U(n);
-  return Ce(t);
+function oi(r) {
+  let e = at(r);
+  return ei(e);
 }
-function p(n) {
-  return "uniqueWithLocations" in n ? n.uniqueWithLocations : n.unique;
+function E(r) {
+  return "uniqueWithLocations" in r && r.uniqueWithLocations != null ? r.uniqueWithLocations : r.unique;
 }
-function m(n) {
-  return Array.isArray(n) ? n.length : n;
+function A(r) {
+  return Array.isArray(r) ? r.length : r;
 }
-function Ce(n) {
+function ei(r) {
   return {
     color: (() => {
-      let t = /* @__PURE__ */ Object.create(null), i = p(n.values.colors), e = we(i);
-      for (let [s, l] of e)
-        for (let r of l) {
-          let f = g(r), w = m(i[r]);
-          if (f !== null) {
-            let { colorSpace: k, components: F, alpha: B } = f, h = `${ye.get(s)}-${a([k, ...F, B].join(""))}`, G = n.values.colors.itemsPerContext, S = Object.entries(G).reduce((d, [N, b]) => r in b.unique || b.uniqueWithLocations && r in b.uniqueWithLocations ? d.add(N) : d, /* @__PURE__ */ new Set());
-            if (t[h]) {
-              let d = t[h].$extensions[x];
-              t[h].$extensions[x] = Array.from(new Set(d).union(S)), t[h].$extensions[u] += w;
+      let e = /* @__PURE__ */ Object.create(null), t = E(r.values.colors), s = It(t);
+      for (let [i, n] of s)
+        for (let o of n) {
+          let h = N(o), u = A(t[o]);
+          if (h !== null) {
+            let { colorSpace: f, components: d, alpha: b } = h, m = `${Ut.get(i)}-${c([f, ...d, b].join(""))}`, T = r.values.colors.itemsPerContext, $ = Object.entries(T).reduce((k, [U, x]) => o in x.unique || x.uniqueWithLocations && o in x.uniqueWithLocations ? k.add(U) : k, /* @__PURE__ */ new Set());
+            if (e[m]) {
+              let k = e[m].$extensions[oe];
+              e[m].$extensions[oe] = Array.from(new Set(k).union($)), e[m].$extensions[_] += u;
             } else
-              t[h] = {
+              e[m] = {
                 $type: "color",
-                $value: f,
+                $value: h,
                 $extensions: {
-                  [c]: r,
-                  [u]: w,
-                  [x]: Array.from(S)
+                  [v]: o,
+                  [_]: u,
+                  [oe]: Array.from($)
                 }
               };
           }
         }
-      return t;
+      return e;
     })(),
     font_size: (() => {
-      let t = /* @__PURE__ */ Object.create(null), i = p(n.values.fontSizes);
-      for (let e in i) {
-        let s = Ee(e), l = {
-          [c]: e,
-          [u]: m(i[e])
+      let e = /* @__PURE__ */ Object.create(null), t = E(r.values.fontSizes);
+      for (let s in t) {
+        let i = Js(s), n = {
+          [v]: s,
+          [_]: A(t[s])
         };
-        if (s === null) {
-          let r = `fontSize-${a(e)}`;
-          t[r] = {
-            $value: e,
-            $extensions: l
+        if (i === null) {
+          let o = `fontSize-${c(s)}`;
+          e[o] = {
+            $value: s,
+            $extensions: n
           };
         } else {
-          let r = `fontSize-${a(s.value.toString() + s.unit)}`;
-          t[r] ? t[r].$extensions[u] += l[u] : t[r] = {
+          let o = `fontSize-${c(i.value.toString() + i.unit)}`;
+          e[o] ? e[o].$extensions[_] += n[_] : e[o] = {
             $type: "dimension",
-            $value: s,
-            $extensions: l
+            $value: i,
+            $extensions: n
           };
         }
       }
-      return t;
+      return e;
     })(),
     font_family: (() => {
-      let t = /* @__PURE__ */ Object.create(null), i = p(n.values.fontFamilies);
-      for (let e in i) {
-        let s = Oe(e), l = `fontFamily-${a(e)}`, r = {
-          [c]: e,
-          [u]: m(i[e])
+      let e = /* @__PURE__ */ Object.create(null), t = E(r.values.fontFamilies);
+      for (let s in t) {
+        let i = Qs(s), n = `fontFamily-${c(s)}`, o = {
+          [v]: s,
+          [_]: A(t[s])
         };
-        s === void 0 ? t[l] = {
-          $value: e,
-          $extensions: r
-        } : t[l] = {
-          $type: "fontFamily",
+        i === void 0 ? e[n] = {
           $value: s,
-          $extensions: r
+          $extensions: o
+        } : e[n] = {
+          $type: "fontFamily",
+          $value: i,
+          $extensions: o
         };
       }
-      return t;
+      return e;
     })(),
     line_height: (() => {
-      let t = /* @__PURE__ */ Object.create(null), i = p(n.values.lineHeights);
-      for (let e in i) {
-        let s = Le(e), l = {
-          [c]: e,
-          [u]: m(i[e])
+      let e = /* @__PURE__ */ Object.create(null), t = E(r.values.lineHeights);
+      for (let s in t) {
+        let i = Zs(s), n = {
+          [v]: s,
+          [_]: A(t[s])
         };
-        if (s === null) {
-          let r = `lineHeight-${a(e)}`;
-          t[r] = {
-            $value: e,
-            $extensions: l
+        if (i === null) {
+          let o = `lineHeight-${c(s)}`;
+          e[o] = {
+            $value: s,
+            $extensions: n
           };
-        } else if (typeof s == "number") {
-          let r = `lineHeight-${a(s)}`;
-          t[r] ? t[r].$extensions[u] += l[u] : t[r] = {
+        } else if (typeof i == "number") {
+          let o = `lineHeight-${c(i)}`;
+          e[o] ? e[o].$extensions[_] += n[_] : e[o] = {
             $type: "number",
-            $value: s,
-            $extensions: l
+            $value: i,
+            $extensions: n
           };
-        } else if (typeof s == "object")
-          if (s.unit === "px" || s.unit === "rem") {
-            let r = `lineHeight-${a(s.value.toString() + s.unit)}`;
-            t[r] ? t[r].$extensions[u] += l[u] : t[r] = {
+        } else if (typeof i == "object")
+          if (i.unit === "px" || i.unit === "rem") {
+            let o = `lineHeight-${c(i.value.toString() + i.unit)}`;
+            e[o] ? e[o].$extensions[_] += n[_] : e[o] = {
               $type: "dimension",
-              $value: s,
-              $extensions: l
+              $value: i,
+              $extensions: n
             };
           } else {
-            let r = `lineHeight-${a(e)}`;
-            t[r] = {
-              $value: e,
-              $extensions: l
+            let o = `lineHeight-${c(s)}`;
+            e[o] = {
+              $value: s,
+              $extensions: n
             };
           }
       }
-      return t;
+      return e;
     })(),
     gradient: (() => {
-      let t = /* @__PURE__ */ Object.create(null), i = p(n.values.gradients);
-      for (let e in i)
-        t[`gradient-${a(e)}`] = {
-          $value: e,
+      let e = /* @__PURE__ */ Object.create(null), t = E(r.values.gradients);
+      for (let s in t)
+        e[`gradient-${c(s)}`] = {
+          $value: s,
           $extensions: {
-            [c]: e,
-            [u]: m(i[e])
+            [v]: s,
+            [_]: A(t[s])
           }
         };
-      return t;
+      return e;
     })(),
     box_shadow: (() => {
-      let t = /* @__PURE__ */ Object.create(null), i = p(n.values.boxShadows);
-      for (let e in i) {
-        let s = `boxShadow-${a(e)}`, l = Se(e), r = {
-          [c]: e,
-          [u]: m(i[e])
+      let e = /* @__PURE__ */ Object.create(null), t = E(r.values.boxShadows);
+      for (let s in t) {
+        let i = `boxShadow-${c(s)}`, n = Xs(s), o = {
+          [v]: s,
+          [_]: A(t[s])
         };
-        l === null ? t[s] = {
-          $value: e,
-          $extensions: r
-        } : t[s] = {
+        n === null ? e[i] = {
+          $value: s,
+          $extensions: o
+        } : e[i] = {
           $type: "shadow",
-          $value: l.length === 1 ? l[0] : l,
-          $extensions: r
+          $value: n.length === 1 ? n[0] : n,
+          $extensions: o
         };
       }
-      return t;
+      return e;
     })(),
     radius: (() => {
-      let t = /* @__PURE__ */ Object.create(null), i = p(n.values.borderRadiuses);
-      for (let e in i) {
-        let s = `radius-${a(e)}`;
-        t[s] = {
-          $value: e,
+      let e = /* @__PURE__ */ Object.create(null), t = E(r.values.borderRadiuses);
+      for (let s in t) {
+        let i = `radius-${c(s)}`;
+        e[i] = {
+          $value: s,
           $extensions: {
-            [c]: e,
-            [u]: m(i[e])
+            [v]: s,
+            [_]: A(t[s])
           }
         };
       }
-      return t;
+      return e;
     })(),
     duration: (() => {
-      let t = /* @__PURE__ */ Object.create(null), i = p(n.values.animations.durations);
-      for (let e in i) {
-        let s = V(e), l = s < Number.MAX_SAFE_INTEGER - 1, r = {
-          [c]: e,
-          [u]: m(i[e])
+      let e = /* @__PURE__ */ Object.create(null), t = E(r.values.animations.durations);
+      for (let s in t) {
+        let i = ut(s), n = i < Number.MAX_SAFE_INTEGER - 1, o = {
+          [v]: s,
+          [_]: A(t[s])
         };
-        if (l) {
-          let f = `duration-${a(s.toString())}`;
-          t[f] ? t[f].$extensions[u] += r[u] : t[f] = {
+        if (n) {
+          let h = `duration-${c(i.toString())}`;
+          e[h] ? e[h].$extensions[_] += o[_] : e[h] = {
             $type: "duration",
             $value: {
-              value: s,
+              value: i,
               unit: "ms"
             },
-            $extensions: r
+            $extensions: o
           };
         } else {
-          let f = `duration-${a("invalid" + s.toString())}`;
-          t[f] = {
-            $value: e,
-            $extensions: r
+          let h = `duration-${c("invalid" + i.toString())}`;
+          e[h] = {
+            $value: s,
+            $extensions: o
           };
         }
       }
-      return t;
+      return e;
     })(),
     easing: (() => {
-      let t = /* @__PURE__ */ Object.create(null), i = p(n.values.animations.timingFunctions);
-      for (let e in i) {
-        let s = `easing-${a(e)}`, l = Ne(e), r = {
-          [c]: e,
-          [u]: m(i[e])
+      let e = /* @__PURE__ */ Object.create(null), t = E(r.values.animations.timingFunctions);
+      for (let s in t) {
+        let i = `easing-${c(s)}`, n = zs(s), o = {
+          [v]: s,
+          [_]: A(t[s])
         };
-        l !== null ? t[s] = {
-          $value: l,
+        n !== null ? e[i] = {
+          $value: n,
           $type: "cubicBezier",
-          $extensions: r
-        } : t[s] = {
-          $value: e,
-          $extensions: r
+          $extensions: o
+        } : e[i] = {
+          $value: s,
+          $extensions: o
         };
       }
-      return t;
+      return e;
     })()
   };
 }
 export {
-  c as EXTENSION_AUTHORED_AS,
-  x as EXTENSION_CSS_PROPERTIES,
-  u as EXTENSION_USAGE_COUNT,
-  Ce as analysis_to_tokens,
-  Re as css_to_tokens
+  v as EXTENSION_AUTHORED_AS,
+  oe as EXTENSION_CSS_PROPERTIES,
+  _ as EXTENSION_USAGE_COUNT,
+  ei as analysis_to_tokens,
+  N as color_to_token,
+  oi as css_to_tokens
 };