rainbowindex 0.4.0 → 0.5.0

package/dist/{chunk-6DAHUFNU.mjs → chunk-ZI5ZYNSU.mjs}

@@ -42,7 +42,91 @@ import {
   registerCustomTextSizes,
   registerCustomUtility,
   snapshotCompilationContext
-} from "./chunk-5Y7EXXLS.mjs";
+} from "./chunk-KRZL4IDK.mjs";
+
+// src/shared.ts
+function isRIDebug() {
+  return typeof process !== "undefined" && !!process.env.RI_DEBUG;
+}
+function withTimeout(promise, ms, message) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(message)), ms);
+    if (typeof timer === "object" && "unref" in timer) timer.unref();
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+}
+function stripCSSComments(input) {
+  if (!input.includes("/")) return input;
+  const len = input.length;
+  let result = "";
+  let copyStart = 0;
+  let i = 0;
+  let quote = 0;
+  while (i < len) {
+    const c = input.charCodeAt(i);
+    if (quote !== 0) {
+      if (c === 92) {
+        i += 2;
+        continue;
+      }
+      if (c === quote) quote = 0;
+      i++;
+      continue;
+    }
+    if (c === 34 || c === 39) {
+      quote = c;
+      i++;
+      continue;
+    }
+    if (c === 47) {
+      const next = input.charCodeAt(i + 1);
+      if (next === 42) {
+        result += input.slice(copyStart, i);
+        result += " ";
+        const end = input.indexOf("*/", i + 2);
+        copyStart = end === -1 ? len : end + 2;
+        if (end === -1) break;
+        i = copyStart;
+        continue;
+      }
+      if (next === 47) {
+        result += input.slice(copyStart, i);
+        const end = input.indexOf("\n", i + 2);
+        copyStart = end === -1 ? len : end + 1;
+        if (end === -1) break;
+        result += "\n";
+        i = copyStart;
+        continue;
+      }
+    }
+    i++;
+  }
+  if (copyStart === 0) return input;
+  if (copyStart < len) result += input.slice(copyStart);
+  return result;
+}
+var BOUNDARY_WHITESPACE_RE = /\s/;
+function isAtRuleBoundary(css, idx) {
+  if (idx === 0) return true;
+  const prev = css.charCodeAt(idx - 1);
+  if (prev === 32 || prev >= 9 && prev <= 13 || prev === 59 || prev === 123 || prev === 125)
+    return true;
+  if (prev === 47 && idx >= 2 && css.charCodeAt(idx - 2) === 42) return true;
+  return prev > 127 && BOUNDARY_WHITESPACE_RE.test(css[idx - 1]);
+}
+var CSS_CUSTOM_IDENT_RE = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
+function codepointCompare(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
 
 // src/directives/foundation.ts
 var DIRECTIVE_TYPE_NAMES = [
@@ -71,7 +155,29 @@ var DIRECTIVE_TYPE_NAMES = [
   "register"
 ];
 var REMOVAL_KEY = "--ri-rm";
+var IDENT_KEY_RE = /^[\w-]+$/;
 var WS_CHAR_RE = /\s/;
+function topLevelIndexOf(str, char) {
+  let depth = 0;
+  for (let i = 0; i < str.length; i++) {
+    const c = str[i];
+    if (c === '"' || c === "'") {
+      i++;
+      while (i < str.length && str[i] !== c) {
+        if (str[i] === "\\") i++;
+        i++;
+      }
+      continue;
+    }
+    if (c === "(" || c === "[") depth++;
+    else if (c === ")" || c === "]") {
+      if (depth > 0) depth--;
+    } else if (c === char && depth === 0) {
+      return i;
+    }
+  }
+  return -1;
+}
 function* scanEntries(src, opts) {
   let i = 0;
   while (i < src.length) {
@@ -133,7 +239,7 @@ function* scanEntries(src, opts) {
       const block = src.slice(i + 1, close).trim();
       i = close + 1;
       if (colonIdx === -1) {
-        if (value) yield { key: "", value, fragment: true };
+        if (value) yield { key: "", value, fragment: true, block };
         continue;
       }
       if (key === REMOVAL_KEY) {
@@ -155,6 +261,70 @@ function* scanEntries(src, opts) {
     yield { key, value };
   }
 }
+function parseKeyValueBody(body, warnings, directiveName) {
+  const entries = [];
+  const removals = [];
+  const cleanedBody = stripCSSComments(body);
+  const flush = (raw) => {
+    const line = raw.trim();
+    if (!line) return;
+    if (line.startsWith("!")) {
+      removals.push(line.slice(1).trim());
+      return;
+    }
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) return;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    if (key === REMOVAL_KEY && value) {
+      removals.push(value);
+      return;
+    }
+    if (key && !IDENT_KEY_RE.test(key)) {
+      warnings?.push(
+        `[RI-1035] Invalid @${directiveName ?? "directive"} entry key "${key}" \u2014 keys may only contain letters, numbers, hyphens, and underscores. The entry was skipped.`
+      );
+      return;
+    }
+    if (key && value) {
+      entries.push([key, value]);
+    }
+  };
+  let start = 0;
+  let depth = 0;
+  let lastNonWS = "";
+  for (let i = 0; i < cleanedBody.length; i++) {
+    const ch = cleanedBody[i];
+    if (ch === '"' || ch === "'") {
+      i++;
+      while (i < cleanedBody.length && cleanedBody[i] !== ch) {
+        if (cleanedBody[i] === "\\") i++;
+        i++;
+      }
+      lastNonWS = ch;
+      continue;
+    }
+    if (ch === "(" || ch === "[") {
+      depth++;
+      lastNonWS = ch;
+      continue;
+    }
+    if (ch === ")" || ch === "]") {
+      if (depth > 0) depth--;
+      lastNonWS = ch;
+      continue;
+    }
+    if (depth === 0 && (ch === ";" || ch === "\n" && lastNonWS !== ",")) {
+      flush(cleanedBody.slice(start, i));
+      start = i + 1;
+      lastNonWS = "";
+      continue;
+    }
+    if (!WS_CHAR_RE.test(ch)) lastNonWS = ch;
+  }
+  flush(cleanedBody.slice(start));
+  return { entries, removals };
+}
 function findClosingBrace(src, start) {
   let depth = 1;
   for (let i = start + 1; i < src.length; i++) {
@@ -191,90 +361,6 @@ function hasApplyLikeDirective(src) {
 }
 var APPLY_LIKE_MATCH_RE = new RegExp(`@(?:${APPLY_LIKE_NAMES})\\s+([^;{}]+)`, "g");
 
-// src/shared.ts
-function isRIDebug() {
-  return typeof process !== "undefined" && !!process.env.RI_DEBUG;
-}
-function withTimeout(promise, ms, message) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => reject(new Error(message)), ms);
-    if (typeof timer === "object" && "unref" in timer) timer.unref();
-    promise.then(
-      (value) => {
-        clearTimeout(timer);
-        resolve(value);
-      },
-      (err) => {
-        clearTimeout(timer);
-        reject(err);
-      }
-    );
-  });
-}
-function stripCSSComments(input) {
-  if (!input.includes("/")) return input;
-  const len = input.length;
-  let result = "";
-  let copyStart = 0;
-  let i = 0;
-  let quote = 0;
-  while (i < len) {
-    const c = input.charCodeAt(i);
-    if (quote !== 0) {
-      if (c === 92) {
-        i += 2;
-        continue;
-      }
-      if (c === quote) quote = 0;
-      i++;
-      continue;
-    }
-    if (c === 34 || c === 39) {
-      quote = c;
-      i++;
-      continue;
-    }
-    if (c === 47) {
-      const next = input.charCodeAt(i + 1);
-      if (next === 42) {
-        result += input.slice(copyStart, i);
-        result += " ";
-        const end = input.indexOf("*/", i + 2);
-        copyStart = end === -1 ? len : end + 2;
-        if (end === -1) break;
-        i = copyStart;
-        continue;
-      }
-      if (next === 47) {
-        result += input.slice(copyStart, i);
-        const end = input.indexOf("\n", i + 2);
-        copyStart = end === -1 ? len : end + 1;
-        if (end === -1) break;
-        result += "\n";
-        i = copyStart;
-        continue;
-      }
-    }
-    i++;
-  }
-  if (copyStart === 0) return input;
-  if (copyStart < len) result += input.slice(copyStart);
-  return result;
-}
-var BOUNDARY_WHITESPACE_RE = /\s/;
-function isAtRuleBoundary(css, idx) {
-  if (idx === 0) return true;
-  const prev = css.charCodeAt(idx - 1);
-  if (prev === 32 || prev >= 9 && prev <= 13 || prev === 59 || prev === 123 || prev === 125)
-    return true;
-  if (prev === 47 && idx >= 2 && css.charCodeAt(idx - 2) === 42) return true;
-  return prev > 127 && BOUNDARY_WHITESPACE_RE.test(css[idx - 1]);
-}
-var CSS_CUSTOM_IDENT_RE = /^[a-zA-Z][a-zA-Z0-9_-]*$/;
-function codepointCompare(a, b) {
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-
 // src/directives/activation.ts
 var DIRECTIVE_NAMES_SET = /* @__PURE__ */ new Set([
   ...DIRECTIVE_TYPE_NAMES,
@@ -445,77 +531,8 @@ function mixColorAlpha(color, alpha) {
   return `color-mix(in oklab, ${color} ${alpha}, transparent)`;
 }
 
-// src/integrations/font-providers/model.ts
-var SAFE_FONT_FAMILY_CHARS = "a-zA-Z0-9 ._-";
-var SAFE_FONT_FAMILY_RE = new RegExp(`^[${SAFE_FONT_FAMILY_CHARS}]+$`);
-var GOOGLE_DEFAULT_WEIGHT = "100 900";
-var GOOGLE_DEFAULT_STYLE = "normal italic";
-function kindFromProvider(provider) {
-  if (provider === "google") return "google";
-  if (provider === "system") return "system";
-  if (provider === "") return "manual";
-  return "local";
-}
-function createFontFace(partial) {
-  const isGoogle = partial.provider === "google";
-  return {
-    weight: isGoogle ? GOOGLE_DEFAULT_WEIGHT : "400",
-    style: isGoogle ? GOOGLE_DEFAULT_STYLE : "normal",
-    display: "swap",
-    subset: "latin",
-    ...partial
-  };
-}
-function createFontSlot(partial) {
-  const defaultProvider = partial.kind === "google" ? "google" : partial.kind === "system" ? "system" : "";
-  const faces = partial.faces && partial.faces.length > 0 ? partial.faces.map((f) => ({ ...f })) : [createFontFace({ provider: defaultProvider })];
-  return {
-    slot: partial.slot,
-    family: partial.family,
-    kind: partial.kind ?? kindFromProvider(faces[0].provider),
-    fallback: [...partial.fallback ?? []],
-    features: partial.features ?? null,
-    variation: partial.variation ?? null,
-    preload: partial.preload ?? false,
-    faces,
-    metricsFallback: partial.metricsFallback,
-    sizeAdjust: partial.sizeAdjust,
-    ascent: partial.ascent,
-    descent: partial.descent,
-    lineGap: partial.lineGap
-  };
-}
-
-// src/directives/parsers.ts
-var UNSAFE_FONT_FAMILY_CHARS_RE = new RegExp(`[^${SAFE_FONT_FAMILY_CHARS}]`, "g");
-var MAX_UTILITY_BODY_LENGTH = 1e4;
-var MAX_CUSTOM_SELECTOR_LENGTH = 2e3;
+// src/directives/color.ts
 var MAX_COLOR_ENTRIES = 500;
-var MAX_FONT_CONFIGS = 20;
-var CUSTOM_VARIANT_NAME_RE = /^[a-z][\w-]*$/;
-var IDENT_KEY_RE = /^[\w-]+$/;
-var WS_CHAR_RE2 = /\s/;
-function topLevelIndexOf(str, char) {
-  let depth = 0;
-  for (let i = 0; i < str.length; i++) {
-    const c = str[i];
-    if (c === '"' || c === "'") {
-      i++;
-      while (i < str.length && str[i] !== c) {
-        if (str[i] === "\\") i++;
-        i++;
-      }
-      continue;
-    }
-    if (c === "(" || c === "[") depth++;
-    else if (c === ")" || c === "]") {
-      if (depth > 0) depth--;
-    } else if (c === char && depth === 0) {
-      return i;
-    }
-  }
-  return -1;
-}
 function expandColorStopRef(v) {
   if (v.includes("(") || v.startsWith("#")) return v;
   const m = v.match(/^([\w][\w-]*)-(\d+)$/);
@@ -548,147 +565,6 @@ function expandColorSide(side) {
   if (Number.isNaN(num)) return expanded;
   return mixColorAlpha(expanded, clampAlphaPercent(num, isPercent));
 }
-var TRUTHY_FONT_VALUES = /* @__PURE__ */ new Set(["true", "yes", "on"]);
-var FACE_DEFAULT_KEYS = /* @__PURE__ */ new Set([
-  "weight",
-  "style",
-  "display",
-  "subset",
-  "unicodeRange",
-  "unicode-range"
-]);
-function applyFaceOptions(face, entries) {
-  for (const [key, value] of entries) {
-    switch (key) {
-      case "weight":
-        face.weight = value;
-        face._weightExplicit = true;
-        break;
-      case "style":
-        face.style = value;
-        face._styleExplicit = true;
-        break;
-      case "display":
-        face.display = value;
-        break;
-      case "subset":
-        face.subset = value;
-        break;
-      case "unicodeRange":
-      case "unicode-range":
-        face.unicodeRange = value;
-        break;
-      case "preload":
-        face.preload = TRUTHY_FONT_VALUES.has(value);
-        break;
-    }
-  }
-}
-function applySlotOptions(slot, entries) {
-  for (const [key, value] of entries) {
-    switch (key) {
-      case "fallback":
-        slot.fallback = value.split(",").map((s) => s.trim());
-        break;
-      case "features":
-        slot.features = value;
-        break;
-      case "variation":
-        slot.variation = value;
-        break;
-      case "preload":
-        slot.preload = TRUTHY_FONT_VALUES.has(value);
-        break;
-      case "metricsFallback":
-        slot.metricsFallback = value.replace(/["']/g, "");
-        break;
-      case "sizeAdjust": {
-        const n = Number.parseFloat(value);
-        if (!Number.isNaN(n)) slot.sizeAdjust = n;
-        break;
-      }
-      case "ascent": {
-        const n = Number.parseFloat(value);
-        if (!Number.isNaN(n)) slot.ascent = n;
-        break;
-      }
-      case "descent": {
-        const n = Number.parseFloat(value);
-        if (!Number.isNaN(n)) slot.descent = n;
-        break;
-      }
-      case "lineGap": {
-        const n = Number.parseFloat(value);
-        if (!Number.isNaN(n)) slot.lineGap = n;
-        break;
-      }
-    }
-  }
-}
-function parseKeyValueBody(body, warnings, directiveName) {
-  const entries = [];
-  const removals = [];
-  const cleanedBody = stripCSSComments(body);
-  const flush = (raw) => {
-    const line = raw.trim();
-    if (!line) return;
-    if (line.startsWith("!")) {
-      removals.push(line.slice(1).trim());
-      return;
-    }
-    const colonIdx = line.indexOf(":");
-    if (colonIdx === -1) return;
-    const key = line.slice(0, colonIdx).trim();
-    const value = line.slice(colonIdx + 1).trim();
-    if (key === REMOVAL_KEY && value) {
-      removals.push(value);
-      return;
-    }
-    if (key && !IDENT_KEY_RE.test(key)) {
-      warnings?.push(
-        `[RI-1035] Invalid @${directiveName ?? "directive"} entry key "${key}" \u2014 keys may only contain letters, numbers, hyphens, and underscores. The entry was skipped.`
-      );
-      return;
-    }
-    if (key && value) {
-      entries.push([key, value]);
-    }
-  };
-  let start = 0;
-  let depth = 0;
-  let lastNonWS = "";
-  for (let i = 0; i < cleanedBody.length; i++) {
-    const ch = cleanedBody[i];
-    if (ch === '"' || ch === "'") {
-      i++;
-      while (i < cleanedBody.length && cleanedBody[i] !== ch) {
-        if (cleanedBody[i] === "\\") i++;
-        i++;
-      }
-      lastNonWS = ch;
-      continue;
-    }
-    if (ch === "(" || ch === "[") {
-      depth++;
-      lastNonWS = ch;
-      continue;
-    }
-    if (ch === ")" || ch === "]") {
-      if (depth > 0) depth--;
-      lastNonWS = ch;
-      continue;
-    }
-    if (depth === 0 && (ch === ";" || ch === "\n" && lastNonWS !== ",")) {
-      flush(cleanedBody.slice(start, i));
-      start = i + 1;
-      lastNonWS = "";
-      continue;
-    }
-    if (!WS_CHAR_RE2.test(ch)) lastNonWS = ch;
-  }
-  flush(cleanedBody.slice(start));
-  return { entries, removals };
-}
 function parseColorBody(body, warnings) {
   const cleanedBody = stripCSSComments(body);
   const colors = {};
@@ -759,104 +635,602 @@ function parseColorBody(body, warnings) {
         `[RI-1108] @color "${key}" has an options block but its value is not generative \u2014 dark/inline/parabolic options only apply to "chroma hue" colors and were ignored.`
       );
     }
-    if (!Object.hasOwn(colors, key)) colorCount++;
-    colors[key] = def;
+    if (!Object.hasOwn(colors, key)) colorCount++;
+    colors[key] = def;
+  }
+  return { colors, removals };
+}
+function parseColorValue(key, value, warnings) {
+  const slashIdx = findPairSeparator(value);
+  if (slashIdx !== -1) {
+    const light = expandColorSide(value.slice(0, slashIdx).trim());
+    const dark = expandColorSide(value.slice(slashIdx + 1).trim());
+    return { type: "pair", light, dark };
+  }
+  if (/^light-dark\s*\(/.test(value)) {
+    const inner = value.slice(value.indexOf("(") + 1, value.lastIndexOf(")")).trim();
+    const commaIdx = topLevelIndexOf(inner, ",");
+    if (commaIdx !== -1) {
+      const light = expandColorSide(inner.slice(0, commaIdx).trim());
+      const dark = expandColorSide(inner.slice(commaIdx + 1).trim());
+      return { type: "pair", light, dark };
+    }
+  }
+  if (value === "transparent" || value === "currentColor" || value === "inherit") {
+    return { type: "keyword", value };
+  }
+  if (/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/.test(value)) {
+    return { type: "explicit", value };
+  }
+  if (/^(oklch|oklab|rgb|hsl|hwb|lch|lab|color|color-mix|var)\s*\(/.test(value)) {
+    return { type: "explicit", value };
+  }
+  const parts = value.split(/\s+/);
+  if (parts.length === 2) {
+    const chroma = Number.parseFloat(parts[0]);
+    const hue = Number.parseFloat(parts[1]);
+    if (!Number.isNaN(chroma) && !Number.isNaN(hue)) {
+      if (chroma < 0 || chroma > 0.4) {
+        warnings?.push(
+          `[RI-1102] @color "${key}" chroma ${chroma} is outside the typical range [0, 0.4] \u2014 clamping to valid range.`
+        );
+      }
+      const clampedChroma = Math.max(0, Math.min(0.4, chroma));
+      const normalizedHue = (hue % 360 + 360) % 360;
+      return { type: "generative", chroma: clampedChroma, hue: normalizedHue };
+    }
+    warnings?.push(
+      `[RI-1101] Invalid @color value "${key}: ${value}" \u2014 expected "chroma hue" (e.g., "0.15 30") or a CSS color function.`
+    );
+    return null;
+  }
+  if (parts.length === 1) {
+    const expanded = expandColorSide(value);
+    if (expanded !== value) return { type: "explicit", value: expanded };
+    if (/^[\w-]+$/.test(value)) return { type: "alias", source: value };
+  }
+  warnings?.push(
+    `[RI-1101] Invalid @color value "${key}: ${value}" \u2014 expected "chroma hue" (e.g., "0.15 30"), a color name alias, or a CSS color function.`
+  );
+  return null;
+}
+function parseDarkOverrideValue(value) {
+  const val = value.trim();
+  if (val === "mirror") return { strategy: "mirror" };
+  if (val === "fixed") return { strategy: "fixed" };
+  if (val.startsWith("shift")) {
+    const chromaMatch = val.match(/chroma\s+([+-]?\d+(?:\.\d+)?)/);
+    const hueMatch = val.match(/hue\s+([+-]?\d+(?:\.\d+)?)/);
+    const chromaDelta = chromaMatch ? Number.parseFloat(chromaMatch[1]) : 0;
+    const hueDelta = hueMatch ? Number.parseFloat(hueMatch[1]) : 0;
+    return {
+      strategy: "shift",
+      chromaDelta: Number.isNaN(chromaDelta) ? 0 : chromaDelta,
+      hueDelta: Number.isNaN(hueDelta) ? 0 : hueDelta
+    };
+  }
+  return void 0;
+}
+function findPairSeparator(value) {
+  let depth = 0;
+  for (let i = 0; i < value.length; i++) {
+    if (value[i] === "(" || value[i] === "[") depth++;
+    else if (value[i] === ")" || value[i] === "]") {
+      depth--;
+      if (depth < 0) return -1;
+    } else if (value[i] === "/" && depth === 0) {
+      const prev = value[i - 1];
+      const next = value[i + 1];
+      if (prev !== void 0 && !/\s/.test(prev) && next !== void 0 && /[\d.]/.test(next)) {
+        continue;
+      }
+      const before = value.slice(0, i).trim();
+      const after = value.slice(i + 1).trim();
+      if (before && after) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+
+// src/integrations/font-providers/model.ts
+var SAFE_FONT_FAMILY_CHARS = "a-zA-Z0-9 ._-";
+var SAFE_FONT_FAMILY_RE = new RegExp(`^[${SAFE_FONT_FAMILY_CHARS}]+$`);
+var GOOGLE_DEFAULT_WEIGHT = "100 900";
+var GOOGLE_DEFAULT_STYLE = "normal italic";
+function kindFromProvider(provider) {
+  if (provider === "google") return "google";
+  if (provider === "system") return "system";
+  if (provider === "") return "manual";
+  return "local";
+}
+function createFontFace(partial) {
+  const isGoogle = partial.provider === "google";
+  return {
+    weight: isGoogle ? GOOGLE_DEFAULT_WEIGHT : "400",
+    style: isGoogle ? GOOGLE_DEFAULT_STYLE : "normal",
+    display: "swap",
+    ...partial
+  };
+}
+function createFontSlot(partial) {
+  const defaultProvider = partial.kind === "google" ? "google" : partial.kind === "system" ? "system" : "";
+  const faces = partial.faces && partial.faces.length > 0 ? partial.faces.map((f) => ({ ...f })) : [createFontFace({ provider: defaultProvider })];
+  const slot = {
+    slot: partial.slot,
+    family: partial.family,
+    kind: partial.kind ?? kindFromProvider(faces[0].provider),
+    fallback: [...partial.fallback ?? []],
+    features: partial.features ?? null,
+    variation: partial.variation ?? null,
+    faces
+  };
+  if (partial.metrics !== void 0) slot.metrics = partial.metrics;
+  return slot;
+}
+
+// src/directives/font.ts
+var UNSAFE_FONT_FAMILY_CHARS_RE = new RegExp(`[^${SAFE_FONT_FAMILY_CHARS}]`, "g");
+var MAX_FONT_CONFIGS = 20;
+var TRUTHY_FONT_VALUES = /* @__PURE__ */ new Set(["true", "yes", "on"]);
+function stripQuotes(s) {
+  return s.replace(/["']/g, "");
+}
+function sanitizeFamily(family) {
+  return family.replace(UNSAFE_FONT_FAMILY_CHARS_RE, "");
+}
+function sanitizeFallbacks(parts) {
+  return parts.map((s) => SAFE_FONT_FAMILY_RE.test(s) ? s : sanitizeFamily(s).trim()).filter((s) => s.length > 0);
+}
+function isUnsafeCSSValue(value) {
+  if (value.includes("\0")) return true;
+  for (let i = 0; i < value.length; i++) {
+    const c = value[i];
+    if (c === '"' || c === "'") {
+      i++;
+      while (i < value.length && value[i] !== c) {
+        if (value[i] === "\\") i++;
+        i++;
+      }
+      if (i >= value.length) return true;
+      continue;
+    }
+    if (c === "}") return true;
+  }
+  return false;
+}
+function dropUnsafeValue(key, value, slot, warnings) {
+  if (!isUnsafeCSSValue(value)) return false;
+  warnings?.push(
+    `[RI-1217] @font option "${key}" in slot "${slot}" has a value that can't be emitted safely into CSS \u2014 the entry was ignored.`
+  );
+  return true;
+}
+function warnDeprecated(warnings, slot, oldForm, replacement) {
+  warnings?.push(
+    `[RI-1218] @font slot "${slot}": ${oldForm} is deprecated \u2014 ${replacement}. The old form still works but will be removed.`
+  );
+}
+function topLevelFromIndex(s) {
+  let last = -1;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === '"' || c === "'") {
+      i++;
+      while (i < s.length && s[i] !== c) {
+        if (s[i] === "\\") i++;
+        i++;
+      }
+      continue;
+    }
+    if (c === "f" && i > 0 && s[i - 1] === " " && s.startsWith("from ", i)) last = i;
+  }
+  return last;
+}
+function splitTopLevelCommas(s) {
+  const parts = [];
+  let rest = s;
+  for (; ; ) {
+    const i = topLevelIndexOf(rest, ",");
+    if (i === -1) {
+      parts.push(rest);
+      return parts;
+    }
+    parts.push(rest.slice(0, i));
+    rest = rest.slice(i + 1);
+  }
+}
+function parsePreamble(text, slot, warnings) {
+  const pre = text.replace(/\s+/g, " ").trim();
+  if (pre === "system") return { system: true, family: "", fallback: [] };
+  let stackText = pre;
+  let provider;
+  const fromIdx = topLevelFromIndex(pre);
+  if (fromIdx !== -1) {
+    const tail = stripQuotes(pre.slice(fromIdx + 4).trim());
+    if (tail) {
+      provider = tail;
+      stackText = pre.slice(0, fromIdx).trim();
+    }
+  }
+  const parts = splitTopLevelCommas(stackText).map((s) => stripQuotes(s.trim()).trim());
+  const family = parts[0] ?? "";
+  const fallback = sanitizeFallbacks(parts.slice(1));
+  if (provider === void 0 || provider === "google") {
+    return provider === "google" ? { family, fallback, google: true } : { family, fallback };
+  }
+  if (provider === "system") {
+    warnDeprecated(warnings, slot, "`from system`", "use the bare `system` keyword");
+    return { system: true, family: "", fallback: [] };
+  }
+  warnDeprecated(
+    warnings,
+    slot,
+    `\`from "${provider}"\``,
+    `declare the file as a face entry (\`face: ${provider};\`)`
+  );
+  return { family, fallback, legacyFaceSrc: provider };
+}
+function parseMetricsValue(value, slot, warnings) {
+  if (value === "none") return null;
+  const tokens = value.match(/"[^"]*"|'[^']*'|\S+/g) ?? [];
+  const familyParts = [];
+  const nums = [];
+  let malformed = false;
+  for (const t of tokens) {
+    const n = Number.parseFloat(t);
+    if (Number.isNaN(n)) {
+      if (nums.length > 0) {
+        malformed = true;
+        break;
+      }
+      familyParts.push(stripQuotes(t));
+    } else {
+      nums.push(n);
+    }
+  }
+  const fallbackName = familyParts.join(" ").trim();
+  if (malformed || nums.length !== 0 && nums.length !== 4 || familyParts.length > 0 && fallbackName === "") {
+    warnings?.push(
+      `[RI-1220] @font slot "${slot}" has an invalid metrics value "${value}" \u2014 use \`metrics: none\`, \`metrics: "<local font>"\`, or \`metrics: "<local font>" <size-adjust> <ascent> <descent> <line-gap>\` (four percentages). The entry was ignored.`
+    );
+    return void 0;
+  }
+  const cfg = {};
+  if (fallbackName) cfg.fallback = fallbackName;
+  if (nums.length === 4) {
+    cfg.sizeAdjust = nums[0];
+    cfg.ascent = nums[1];
+    cfg.descent = nums[2];
+    cfg.lineGap = nums[3];
+  }
+  return cfg;
+}
+function normalizeFaceEntries(entries, slot, warnings) {
+  const out = [];
+  for (const [key, value] of entries) {
+    if (key === "unicodeRange") {
+      warnDeprecated(warnings, slot, "`unicodeRange:`", "use the CSS spelling `unicode-range:`");
+      out.push(["unicode-range", value]);
+    } else if (key === "subset") {
+      warnDeprecated(
+        warnings,
+        slot,
+        "`subset:`",
+        "remove the entry (the Google css2 API takes no subset hint)"
+      );
+    } else {
+      out.push([key, value]);
+    }
+  }
+  return out;
+}
+function applyFaceOptions(face, entries, slot, warnings) {
+  for (const [key, value] of entries) {
+    if (dropUnsafeValue(key, value, slot, warnings)) continue;
+    switch (key) {
+      case "weight":
+        face.weight = value;
+        face._weightExplicit = true;
+        break;
+      case "style":
+        face.style = value;
+        face._styleExplicit = true;
+        break;
+      case "display":
+        face.display = value;
+        break;
+      case "unicode-range":
+        face.unicodeRange = value;
+        break;
+      case "preload":
+        face.preload = TRUTHY_FONT_VALUES.has(value);
+        break;
+      case "src":
+        warnings?.push(
+          `[RI-1217] Unknown @font option "src" in slot "${slot}" \u2014 the face source is the face: value itself (\`face: /path.woff2 { \u2026 }\`). The entry was ignored.`
+        );
+        break;
+      default:
+        warnings?.push(
+          `[RI-1217] Unknown @font option "${key}" in slot "${slot}" \u2014 the entry was ignored.`
+        );
+        break;
+    }
+  }
+}
+var LEGACY_METRICS_KEYS = /* @__PURE__ */ new Set([
+  "metricsFallback",
+  "sizeAdjust",
+  "ascent",
+  "descent",
+  "lineGap"
+]);
+function parseSlotBody(body, slot, warnings) {
+  const out = { faceDefaults: [], faces: [], legacyMetrics: [] };
+  for (const entry of scanEntries(body, { newlineTerminates: true })) {
+    if (entry.unclosedBlock) {
+      warnings?.push(
+        `[RI-1217] @font slot "${slot}" has an unterminated { block after "${entry.key || entry.value}" \u2014 the entry was ignored.`
+      );
+      continue;
+    }
+    if (entry.fragment) {
+      if (entry.value === "@face" && entry.block !== void 0) {
+        warnDeprecated(warnings, slot, "`@face { src: \u2026; }`", "use `face: <src> { \u2026 }`");
+        let src = "";
+        const own = [];
+        for (const [k, v] of parseKeyValueBody(entry.block, warnings, "font").entries) {
+          if (k === "src") src = stripQuotes(v);
+          else own.push([k, v]);
+        }
+        out.faces.push({ src, entries: own });
+      } else if (entry.value) {
+        warnings?.push(
+          `[RI-1217] @font slot "${slot}" has a stray value "${entry.value.slice(0, 60)}" with no key \u2014 if it continues the previous entry's value, keep the entry on one line. The text was ignored.`
+        );
+      }
+      continue;
+    }
+    if (entry.removal || !entry.key) continue;
+    if (!IDENT_KEY_RE.test(entry.key)) {
+      warnings?.push(
+        `[RI-1035] Invalid @font entry key "${entry.key}" \u2014 keys may only contain letters, numbers, hyphens, and underscores. The entry was skipped.`
+      );
+      continue;
+    }
+    if (entry.block !== void 0 && entry.key !== "face") {
+      warnings?.push(
+        `[RI-1217] @font option "${entry.key}" in slot "${slot}" takes no { \u2026 } block \u2014 the block was ignored.`
+      );
+    }
+    if (entry.key === "face" && !entry.value) {
+      warnings?.push(
+        `[RI-1217] @font slot "${slot}" has a face: entry with no source \u2014 use \`face: <src> [{ \u2026 }]\`. The entry was ignored.`
+      );
+      continue;
+    }
+    if (!entry.value) continue;
+    if (LEGACY_METRICS_KEYS.has(entry.key)) {
+      out.legacyMetrics.push([entry.key, entry.value]);
+      continue;
+    }
+    switch (entry.key) {
+      case "face":
+        out.faces.push({
+          src: stripQuotes(entry.value),
+          entries: entry.block !== void 0 ? parseKeyValueBody(entry.block, warnings, "font").entries : []
+        });
+        break;
+      case "features":
+        if (!dropUnsafeValue(entry.key, entry.value, slot, warnings)) out.features = entry.value;
+        break;
+      case "variation":
+        if (!dropUnsafeValue(entry.key, entry.value, slot, warnings)) out.variation = entry.value;
+        break;
+      case "metrics": {
+        const cfg = parseMetricsValue(entry.value, slot, warnings);
+        if (cfg !== void 0) out.metrics = cfg;
+        break;
+      }
+      case "weight":
+      case "style":
+      case "display":
+      case "unicode-range":
+      case "preload":
+        out.faceDefaults.push([entry.key, entry.value]);
+        break;
+      case "italic":
+        warnDeprecated(warnings, slot, "`italic: <src>`", "use `face: <src> { style: italic; }`");
+        out.faces.push({ src: stripQuotes(entry.value), entries: [["style", "italic"]] });
+        break;
+      case "fallback":
+        warnDeprecated(
+          warnings,
+          slot,
+          "`fallback:`",
+          'list fallbacks after the family in the slot preamble (`sans: "Inter", ui-sans-serif from google;`)'
+        );
+        out.fallbackOverride = sanitizeFallbacks(
+          splitTopLevelCommas(entry.value).map((s) => stripQuotes(s.trim()).trim())
+        );
+        break;
+      case "unicodeRange":
+        warnDeprecated(warnings, slot, "`unicodeRange:`", "use the CSS spelling `unicode-range:`");
+        out.faceDefaults.push(["unicode-range", entry.value]);
+        break;
+      case "subset":
+        warnDeprecated(
+          warnings,
+          slot,
+          "`subset:`",
+          "remove the entry (the Google css2 API takes no subset hint)"
+        );
+        break;
+      default:
+        warnings?.push(
+          `[RI-1217] Unknown @font option "${entry.key}" in slot "${slot}" \u2014 the entry was ignored.`
+        );
+        break;
+    }
+  }
+  foldLegacyMetrics(out, slot, warnings);
+  return out;
+}
+function foldLegacyMetrics(body, slot, warnings) {
+  if (body.legacyMetrics.length === 0) return;
+  warnDeprecated(
+    warnings,
+    slot,
+    "the metricsFallback/sizeAdjust/ascent/descent/lineGap keys",
+    'use the single `metrics:` key (e.g. `metrics: "Arial" 107.64 90.49 22.48 0;`) or omit it for automatic metrics'
+  );
+  if (body.metrics !== void 0) return;
+  const cfg = {};
+  for (const [key, value] of body.legacyMetrics) {
+    if (key === "metricsFallback") {
+      cfg.fallback = stripQuotes(value);
+    } else {
+      const n = Number.parseFloat(value);
+      if (!Number.isNaN(n)) cfg[key] = n;
+    }
+  }
+  const numeric = [cfg.sizeAdjust, cfg.ascent, cfg.descent, cfg.lineGap].filter(
+    (n) => n !== void 0
+  ).length;
+  if (numeric === 4 || numeric === 0 && cfg.fallback !== void 0) {
+    body.metrics = cfg;
+  } else if (numeric > 0) {
+    warnings?.push(
+      `[RI-1220] @font slot "${slot}" sets only ${numeric} of the four metric overrides \u2014 size-adjust, ascent, descent, and line-gap are all required. The values were ignored (automatic metrics still apply).`
+    );
+  }
+}
+function buildFace(provider, defaults, slot, warnings, own) {
+  const face = createFontFace({ provider });
+  applyFaceOptions(face, defaults, slot, warnings);
+  if (own) applyFaceOptions(face, own, slot, warnings);
+  return face;
+}
+function warnDuplicateFaces(slot, warnings) {
+  if (!warnings || slot.faces.length < 2) return;
+  const seen = /* @__PURE__ */ new Set();
+  for (const face of slot.faces) {
+    const key = `${face.weight}|${face.style}`;
+    if (seen.has(key)) {
+      warnings.push(
+        `[RI-1214] @font slot "${slot.slot}" has duplicate faces with weight "${face.weight}" and style "${face.style}" \u2014 the later @font-face wins. Remove the duplicate or give it a distinct weight/style.`
+      );
+    }
+    seen.add(key);
   }
-  return { colors, removals };
 }
-function parseColorValue(key, value, warnings) {
-  const slashIdx = findPairSeparator(value);
-  if (slashIdx !== -1) {
-    const light = expandColorSide(value.slice(0, slashIdx).trim());
-    const dark = expandColorSide(value.slice(slashIdx + 1).trim());
-    return { type: "pair", light, dark };
-  }
-  if (/^light-dark\s*\(/.test(value)) {
-    const inner = value.slice(value.indexOf("(") + 1, value.lastIndexOf(")")).trim();
-    const commaIdx = topLevelIndexOf(inner, ",");
-    if (commaIdx !== -1) {
-      const light = expandColorSide(inner.slice(0, commaIdx).trim());
-      const dark = expandColorSide(inner.slice(commaIdx + 1).trim());
-      return { type: "pair", light, dark };
+function buildSlot(slot, preambleText, blockBody, warnings) {
+  const pre = parsePreamble(preambleText, slot, warnings);
+  const body = parseSlotBody(blockBody ?? "", slot, warnings);
+  const preloadDefault = body.faceDefaults.some(([k]) => k === "preload");
+  if (pre.system) {
+    if (preloadDefault) {
+      warnings?.push(
+        `[RI-1219] @font slot "${slot}": preload has no effect on system fonts \u2014 only local font files can be preloaded.`
+      );
     }
+    return createFontSlot({ slot, family: "", kind: "system" });
   }
-  if (value === "transparent" || value === "currentColor" || value === "inherit") {
-    return { type: "keyword", value };
-  }
-  if (/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/.test(value)) {
-    return { type: "explicit", value };
+  if (!SAFE_FONT_FAMILY_RE.test(pre.family)) {
+    if (pre.family === "") {
+      warnings?.push(
+        `[RI-1217] @font slot "${slot}" has no font family \u2014 the slot emits an empty font variable.`
+      );
+    }
+    return createFontSlot({ slot, family: sanitizeFamily(pre.family), kind: "manual" });
   }
-  if (/^(oklch|oklab|rgb|hsl|hwb|lch|lab|color|color-mix|var)\s*\(/.test(value)) {
-    return { type: "explicit", value };
+  const srcFaces = pre.legacyFaceSrc ? [{ src: pre.legacyFaceSrc, entries: [] }, ...body.faces] : body.faces;
+  let config;
+  if (pre.google) {
+    if (srcFaces.length > 0) {
+      warnings?.push(
+        `[RI-1204] @font slot "${slot}" loads "${pre.family}" from google but also declares local face entries \u2014 provider fonts can't be combined with local faces. The extra faces were ignored.`
+      );
+    }
+    config = createFontSlot({
+      slot,
+      family: pre.family,
+      kind: "google",
+      fallback: pre.fallback,
+      faces: [buildFace("google", body.faceDefaults, slot, warnings)]
+    });
+  } else if (srcFaces.length > 0) {
+    config = createFontSlot({
+      slot,
+      family: pre.family,
+      kind: "local",
+      fallback: pre.fallback,
+      faces: srcFaces.map(
+        (f) => buildFace(
+          f.src,
+          body.faceDefaults,
+          slot,
+          warnings,
+          normalizeFaceEntries(f.entries, slot, warnings)
+        )
+      )
+    });
+    warnDuplicateFaces(config, warnings);
+  } else {
+    config = createFontSlot({
+      slot,
+      family: pre.family,
+      kind: "manual",
+      fallback: pre.fallback,
+      faces: [buildFace("", body.faceDefaults, slot, warnings)]
+    });
   }
-  const parts = value.split(/\s+/);
-  if (parts.length === 2) {
-    const chroma = Number.parseFloat(parts[0]);
-    const hue = Number.parseFloat(parts[1]);
-    if (!Number.isNaN(chroma) && !Number.isNaN(hue)) {
-      if (chroma < 0 || chroma > 0.4) {
-        warnings?.push(
-          `[RI-1102] @color "${key}" chroma ${chroma} is outside the typical range [0, 0.4] \u2014 clamping to valid range.`
-        );
-      }
-      const clampedChroma = Math.max(0, Math.min(0.4, chroma));
-      const normalizedHue = (hue % 360 + 360) % 360;
-      return { type: "generative", chroma: clampedChroma, hue: normalizedHue };
+  if (body.fallbackOverride) config.fallback = body.fallbackOverride;
+  if (body.features !== void 0) config.features = body.features;
+  if (body.variation !== void 0) config.variation = body.variation;
+  if (body.metrics !== void 0) {
+    if (config.kind === "manual") {
+      warnings?.push(
+        `[RI-1220] @font slot "${slot}" sets metrics on a manual font stack \u2014 metrics apply to loaded (google or local file) fonts only. The entry has no effect.`
+      );
     }
+    config.metrics = body.metrics;
+  }
+  if (config.kind !== "local" && preloadDefault) {
     warnings?.push(
-      `[RI-1101] Invalid @color value "${key}: ${value}" \u2014 expected "chroma hue" (e.g., "0.15 30") or a CSS color function.`
+      `[RI-1219] @font slot "${slot}": preload has no effect on ${config.kind} fonts \u2014 only local font files can be preloaded.`
     );
-    return null;
-  }
-  if (parts.length === 1) {
-    const expanded = expandColorSide(value);
-    if (expanded !== value) return { type: "explicit", value: expanded };
-    if (/^[\w-]+$/.test(value)) return { type: "alias", source: value };
-  }
-  warnings?.push(
-    `[RI-1101] Invalid @color value "${key}: ${value}" \u2014 expected "chroma hue" (e.g., "0.15 30"), a color name alias, or a CSS color function.`
-  );
-  return null;
-}
-function parseDarkOverrideValue(value) {
-  const val = value.trim();
-  if (val === "mirror") return { strategy: "mirror" };
-  if (val === "fixed") return { strategy: "fixed" };
-  if (val.startsWith("shift")) {
-    const chromaMatch = val.match(/chroma\s+([+-]?\d+(?:\.\d+)?)/);
-    const hueMatch = val.match(/hue\s+([+-]?\d+(?:\.\d+)?)/);
-    const chromaDelta = chromaMatch ? Number.parseFloat(chromaMatch[1]) : 0;
-    const hueDelta = hueMatch ? Number.parseFloat(hueMatch[1]) : 0;
-    return {
-      strategy: "shift",
-      chromaDelta: Number.isNaN(chromaDelta) ? 0 : chromaDelta,
-      hueDelta: Number.isNaN(hueDelta) ? 0 : hueDelta
-    };
   }
-  return void 0;
+  return config;
 }
-function findPairSeparator(value) {
-  let depth = 0;
-  for (let i = 0; i < value.length; i++) {
-    if (value[i] === "(" || value[i] === "[") depth++;
-    else if (value[i] === ")" || value[i] === "]") {
-      depth--;
-      if (depth < 0) return -1;
-    } else if (value[i] === "/" && depth === 0) {
-      const prev = value[i - 1];
-      const next = value[i + 1];
-      if (prev !== void 0 && !/\s/.test(prev) && next !== void 0 && /[\d.]/.test(next)) {
-        continue;
-      }
-      const before = value.slice(0, i).trim();
-      const after = value.slice(i + 1).trim();
-      if (before && after) {
-        return i;
-      }
+function parseNestedFontBlock(body, warnings) {
+  const cleanedBody = stripCSSComments(body);
+  const configs = [];
+  for (const entry of scanEntries(cleanedBody, { newlineTerminates: false })) {
+    if (entry.removal || entry.fragment) continue;
+    if (entry.unclosedBlock) break;
+    if (!entry.key) continue;
+    if (configs.length >= MAX_FONT_CONFIGS) {
+      warnings?.push(
+        `[RI-1216] @font block exceeds ${MAX_FONT_CONFIGS} slot definitions \u2014 the remaining slots were skipped. Split rarely-used slots into a separate stylesheet or remove unused ones.`
+      );
+      break;
+    }
+    if (entry.block !== void 0) {
+      configs.push(buildSlot(entry.key, entry.value, entry.block, warnings));
+    } else if (entry.value) {
+      configs.push(buildSlot(entry.key, entry.value, void 0, warnings));
     }
   }
-  return -1;
+  return configs;
 }
+
+// src/directives/parsers.ts
+var MAX_UTILITY_BODY_LENGTH = 1e4;
+var MAX_CUSTOM_SELECTOR_LENGTH = 2e3;
+var CUSTOM_VARIANT_NAME_RE = /^[a-z][\w-]*$/;
 function parseTextBody(body, warnings) {
   const { entries, removals } = parseKeyValueBody(body, warnings, "text");
   const text = {};
@@ -941,191 +1315,18 @@ function parsePreflightDirective(body, modifier, base) {
   }
   return config;
 }
-function sanitizeFamily(family) {
-  return family.replace(UNSAFE_FONT_FAMILY_CHARS_RE, "");
-}
-function buildFace(provider, faceDefaults, forceStyle) {
-  const face = createFontFace({ provider });
-  applyFaceOptions(face, faceDefaults);
-  if (forceStyle !== void 0) {
-    face.style = forceStyle;
-    face._styleExplicit = true;
-  }
-  return face;
-}
-function faceFromBlock(entries, faceDefaults) {
-  let src = "";
-  const own = [];
-  for (const [k, v] of entries) {
-    if (k === "src") src = v.replace(/["']/g, "");
-    else own.push([k, v]);
-  }
-  const face = createFontFace({ provider: src });
-  applyFaceOptions(face, faceDefaults);
-  applyFaceOptions(face, own);
-  return face;
-}
-function extractFaceBlocks(body, warnings) {
-  const faceBlocks = [];
-  let rest = "";
-  let i = 0;
-  while (i < body.length) {
-    const at = body.indexOf("@face", i);
-    if (at === -1) {
-      rest += body.slice(i);
-      break;
-    }
-    rest += body.slice(i, at);
-    let j = at + 5;
-    while (j < body.length && /\s/.test(body[j])) j++;
-    if (body[j] !== "{") {
-      rest += body.slice(at, j);
-      i = j;
-      continue;
-    }
-    const close = findClosingBrace(body, j);
-    if (close === -1) {
-      rest += body.slice(at);
-      break;
-    }
-    faceBlocks.push(parseKeyValueBody(body.slice(j + 1, close), warnings, "font").entries);
-    i = close + 1;
-  }
-  return { faceBlocks, rest };
-}
-function processSlotBlock(blockBody, warnings) {
-  const { faceBlocks, rest } = extractFaceBlocks(blockBody, warnings);
-  const { entries } = parseKeyValueBody(rest, warnings, "font");
-  const faceDefaults = [];
-  const slotOpts = [];
-  const italicSrcs = [];
-  for (const [k, v] of entries) {
-    if (k === "italic") italicSrcs.push(v.replace(/["']/g, ""));
-    else if (FACE_DEFAULT_KEYS.has(k)) faceDefaults.push([k, v]);
-    else slotOpts.push([k, v]);
-  }
-  return { faceDefaults, slotOpts, faceBlocks, italicSrcs };
-}
-function buildFaces(primaryProvider, block) {
-  const faces = [];
-  if (primaryProvider !== null) faces.push(buildFace(primaryProvider, block.faceDefaults));
-  for (const fb of block.faceBlocks) faces.push(faceFromBlock(fb, block.faceDefaults));
-  for (const src of block.italicSrcs) faces.push(buildFace(src, block.faceDefaults, "italic"));
-  if (faces.length === 0) faces.push(buildFace("", block.faceDefaults));
-  return faces;
-}
-function warnDuplicateFaces(slot, warnings) {
-  if (!warnings || slot.faces.length < 2) return;
-  const seen = /* @__PURE__ */ new Set();
-  for (const face of slot.faces) {
-    const key = `${face.weight}|${face.style}`;
-    if (seen.has(key)) {
-      warnings.push(
-        `[RI-1214] @font slot "${slot.slot}" has duplicate faces with weight "${face.weight}" and style "${face.style}" \u2014 the later @font-face wins. Remove the duplicate or give it a distinct weight/style.`
-      );
-    }
-    seen.add(key);
-  }
-}
-function parseFontBody(body, slot, warnings) {
-  const normalizedBody = stripCSSComments(body).trim();
-  if (normalizedBody === "system") {
-    return createFontSlot({ slot, family: "", kind: "system" });
-  }
-  const braceIdx = topLevelIndexOf(normalizedBody, "{");
-  const matchable = braceIdx === -1 ? normalizedBody.replace(/\s+/g, " ") : normalizedBody.slice(0, braceIdx).replace(/\s+/g, " ") + normalizedBody.slice(braceIdx);
-  const fromMatch = matchable.match(/^(["'])(.+?)\1\s+from\s+(.+?)(?:\s*\{([\s\S]*)\})?$/);
-  if (fromMatch) {
-    const family = fromMatch[2];
-    if (!SAFE_FONT_FAMILY_RE.test(family)) {
-      return createFontSlot({ slot, family: sanitizeFamily(family), kind: "manual" });
-    }
-    const provider = fromMatch[3].trim().replace(/["']/g, "");
-    const kind = kindFromProvider(provider);
-    const block = processSlotBlock(fromMatch[4] || "", warnings);
-    if (kind === "google" || kind === "system") {
-      if (block.faceBlocks.length > 0 || block.italicSrcs.length > 0) {
-        warnings?.push(
-          `[RI-1204] @font slot "${slot}" loads "${family}" from "${provider}" but also declares @face/italic faces \u2014 provider fonts can't be combined with local faces. The extra faces were ignored.`
-        );
-      }
-      const config2 = createFontSlot({
-        slot,
-        family,
-        kind,
-        faces: [buildFace(provider, block.faceDefaults)]
-      });
-      applySlotOptions(config2, block.slotOpts);
-      return config2;
-    }
-    const config = createFontSlot({ slot, family, kind, faces: buildFaces(provider, block) });
-    applySlotOptions(config, block.slotOpts);
-    warnDuplicateFaces(config, warnings);
-    return config;
-  }
-  const manualMatch = matchable.match(/^(.+?)(?:\s*\{([\s\S]*)\})?$/);
-  if (manualMatch) {
-    const stackParts = manualMatch[1].trim().split(",").map((s) => s.trim());
-    const family = stackParts[0].replace(/["']/g, "");
-    if (!SAFE_FONT_FAMILY_RE.test(family)) {
-      return createFontSlot({ slot, family: sanitizeFamily(family), kind: "manual" });
-    }
-    const fallback = stackParts.slice(1).map((s) => s.replace(/["']/g, "").trim());
-    const block = processSlotBlock(manualMatch[2] || "", warnings);
-    if (block.faceBlocks.length > 0 || block.italicSrcs.length > 0) {
-      const config2 = createFontSlot({
-        slot,
-        family,
-        kind: "local",
-        fallback,
-        faces: buildFaces(null, block)
-      });
-      applySlotOptions(config2, block.slotOpts);
-      warnDuplicateFaces(config2, warnings);
-      return config2;
-    }
-    const config = createFontSlot({
-      slot,
-      family,
-      kind: "manual",
-      fallback,
-      faces: [buildFace("", block.faceDefaults)]
-    });
-    applySlotOptions(config, block.slotOpts);
-    return config;
-  }
-  return createFontSlot({
-    slot,
-    family: sanitizeFamily(normalizedBody.replace(/["']/g, "")),
-    kind: "manual"
-  });
+function stripLeadingClassDot(name) {
+  return name.startsWith(".") ? name.slice(1) : name;
 }
-function parseNestedFontBlock(body, warnings) {
-  const cleanedBody = stripCSSComments(body);
-  const configs = [];
-  for (const entry of scanEntries(cleanedBody, { newlineTerminates: false })) {
-    if (entry.removal || entry.fragment) continue;
-    if (entry.unclosedBlock) break;
-    if (!entry.key) continue;
-    if (configs.length >= MAX_FONT_CONFIGS) {
+function isValidUtilityName(name, warnings) {
+  if (IDENT_KEY_RE.test(name)) {
+    if (/[A-Z]/.test(name)) {
       warnings?.push(
-        `[RI-1216] @font block exceeds ${MAX_FONT_CONFIGS} slot definitions \u2014 the remaining slots were skipped. Split rarely-used slots into a separate stylesheet or remove unused ones.`
+        `[RI-1038] @utility name "${name}" contains uppercase letters \u2014 the markup scanner only matches lowercase tokens, so class="${name}" will never generate it. It still works via @a/@apply and inline @source. Prefer a lowercase-hyphen name.`
       );
-      break;
-    }
-    if (entry.block !== void 0) {
-      configs.push(parseFontBody(`${entry.value} { ${entry.block} }`, entry.key, warnings));
-    } else if (entry.value) {
-      configs.push(parseFontBody(entry.value, entry.key, warnings));
     }
+    return true;
   }
-  return configs;
-}
-function stripLeadingClassDot(name) {
-  return name.startsWith(".") ? name.slice(1) : name;
-}
-function isValidUtilityName(name, warnings) {
-  if (IDENT_KEY_RE.test(name)) return true;
   warnings?.push(
     `[RI-1035] Invalid @utility name "${name}" \u2014 names may only contain letters, numbers, hyphens, and underscores (plus an optional trailing "-*" for functional utilities). The utility was skipped.`
   );
@@ -2996,6 +3197,17 @@ function parseCustomUtilityBody(body) {
   flushStatement(body.length);
   return root;
 }
+var parsedBodyCache = /* @__PURE__ */ new Map();
+var PARSED_BODY_CACHE_MAX = 500;
+function getParsedBody(body) {
+  let tree = parsedBodyCache.get(body);
+  if (!tree) {
+    if (parsedBodyCache.size >= PARSED_BODY_CACHE_MAX) parsedBodyCache.clear();
+    tree = parseCustomUtilityBody(body);
+    parsedBodyCache.set(body, tree);
+  }
+  return tree;
+}
 var MAX_CUSTOM_APPLY_DEPTH = 5;
 var APPLY_CLASS_SPLIT_RE = /\s+/;
 function forEachApplyClass(body, visit) {
@@ -3039,7 +3251,7 @@ function resolveCustomUtility(utility, value, theme, resolve, visiting) {
   const map = getCustomUtilityMap(theme);
   const cu = value === null ? map.get(utility) : map.get(`${utility}-${value}`);
   if (!cu || cu.functional) return null;
-  const tree = parseCustomUtilityBody(cu.body);
+  const tree = getParsedBody(cu.body);
   let expansion = null;
   if (hasApplyLikeDirective(cu.body)) {
     const visited = visiting ?? /* @__PURE__ */ new Set();
@@ -3063,7 +3275,7 @@ function resolveCustomUtility(utility, value, theme, resolve, visiting) {
   return { declarations, nested };
 }
 function extractCustomUtilityRootInfo(body) {
-  const tree = parseCustomUtilityBody(body);
+  const tree = getParsedBody(body);
   const seen = /* @__PURE__ */ new Set();
   const properties = [];
   for (const d of tree.declarations) {
@@ -3072,7 +3284,7 @@ function extractCustomUtilityRootInfo(body) {
       properties.push(d.property);
     }
   }
-  return { properties, applyClasses: tree.applyClasses };
+  return { properties, applyClasses: [...tree.applyClasses] };
 }
 
 // src/utilities/helpers.ts
@@ -8424,6 +8636,48 @@ function createEmptyCompilationResult() {
     warnings: []
   };
 }
+var classCompileMemo = /* @__PURE__ */ new WeakMap();
+function compileClassEntry(raw, theme, customVariantMap, breakpointWeights, variantMemo) {
+  const scratch = createEmptyCompilationResult();
+  const parsed = parseUtility(raw);
+  const rule = compileUtility(
+    parsed,
+    theme,
+    scratch,
+    customVariantMap,
+    /* @__PURE__ */ new Set(),
+    breakpointWeights,
+    variantMemo
+  );
+  const support = new Array(SUPPORT_BLOCKS.length).fill(false);
+  if (rule) {
+    for (let i = 0; i < SUPPORT_BLOCKS.length; i++) {
+      const block = SUPPORT_BLOCKS[i];
+      if (block.test(rule.css) || block.utilities?.includes(parsed.utility)) {
+        support[i] = true;
+      }
+    }
+  } else if (parsed.arbitrary && parsed.value) {
+    const bracketContent = parsed.value.replace(/^\[|\]$/g, "");
+    if (shouldWarnUnresolvedArbitrary(bracketContent)) {
+      const truncated = parsed.raw.length > 100 ? `${parsed.raw.slice(0, 100)}...` : parsed.raw;
+      scratch.warnings.push(
+        `[RI-1002] Could not resolve arbitrary utility "${truncated}". Arbitrary utilities use \`[property:value]\` syntax \u2014 e.g. \`[padding:1rem]\` or \`[mask-type:luminance]\`. Check that the property name is a known CSS property and the value is well-formed (no stray spaces, quoted strings escaped). If you meant to set a CSS variable, use \`[--my-var:value]\`.`
+      );
+    }
+  }
+  return {
+    rule,
+    warnings: scratch.warnings,
+    usedColorStops: scratch.usedColorStops,
+    usedTextSizes: scratch.usedTextSizes,
+    usedFonts: scratch.usedFonts,
+    usedRounded: scratch.usedRounded,
+    usedShadows: scratch.usedShadows,
+    usedAnimations: scratch.usedAnimations,
+    support
+  };
+}
 function shouldWarnUnresolvedArbitrary(bracketContent) {
   if (/[=*]/.test(bracketContent)) return false;
   if (/\s/.test(bracketContent)) return false;
@@ -8476,42 +8730,39 @@ function compileInternal(classNames, theme, variantMapCache) {
   const variantMemo = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Set();
   const supportNeeded = new Array(SUPPORT_BLOCKS.length).fill(false);
+  let classMemo = classCompileMemo.get(theme);
+  if (!classMemo) {
+    classMemo = /* @__PURE__ */ new Map();
+    classCompileMemo.set(theme, classMemo);
+  }
   for (const raw of classNames) {
     if (seen.has(raw)) continue;
     seen.add(raw);
-    const parsed = parseUtility(raw);
-    const compiled = compileUtility(
-      parsed,
-      theme,
-      result,
-      customVariantMap,
-      warnSeen,
-      breakpointWeights,
-      variantMemo
-    );
-    if (!compiled) {
-      if (parsed.arbitrary && parsed.value) {
-        const bracketContent = parsed.value.replace(/^\[|\]$/g, "");
-        if (shouldWarnUnresolvedArbitrary(bracketContent)) {
-          const truncated = parsed.raw.length > 100 ? `${parsed.raw.slice(0, 100)}...` : parsed.raw;
-          pushWarningsDeduped(
-            result.warnings,
-            [
-              `[RI-1002] Could not resolve arbitrary utility "${truncated}". Arbitrary utilities use \`[property:value]\` syntax \u2014 e.g. \`[padding:1rem]\` or \`[mask-type:luminance]\`. Check that the property name is a known CSS property and the value is well-formed (no stray spaces, quoted strings escaped). If you meant to set a CSS variable, use \`[--my-var:value]\`.`
-            ],
-            warnSeen
-          );
-        }
+    let entry = classMemo.get(raw);
+    if (!entry) {
+      entry = compileClassEntry(raw, theme, customVariantMap, breakpointWeights, variantMemo);
+      classMemo.set(raw, entry);
+    }
+    if (entry.warnings.length > 0) {
+      pushWarningsDeduped(result.warnings, entry.warnings, warnSeen);
+    }
+    for (const [hue, stops] of entry.usedColorStops) {
+      let set = result.usedColorStops.get(hue);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        result.usedColorStops.set(hue, set);
       }
-      continue;
-    }
-    result.rules.push(compiled);
+      for (const stop of stops) set.add(stop);
+    }
+    for (const v of entry.usedTextSizes) result.usedTextSizes.add(v);
+    for (const v of entry.usedFonts) result.usedFonts.add(v);
+    for (const v of entry.usedRounded) result.usedRounded.add(v);
+    for (const v of entry.usedShadows) result.usedShadows.add(v);
+    for (const v of entry.usedAnimations) result.usedAnimations.add(v);
+    if (!entry.rule) continue;
+    result.rules.push(entry.rule);
     for (let i = 0; i < SUPPORT_BLOCKS.length; i++) {
-      if (supportNeeded[i]) continue;
-      const block = SUPPORT_BLOCKS[i];
-      if (block.test(compiled.css) || block.utilities?.includes(parsed.utility)) {
-        supportNeeded[i] = true;
-      }
+      if (entry.support[i]) supportNeeded[i] = true;
     }
   }
   result.rules.sort(
@@ -8961,7 +9212,8 @@ function readAssignedValue(source, start) {
     return {
       value: source.slice(i + 1, end2),
       end: end2,
-      valueStart: i + 1
+      valueStart: i + 1,
+      quoted: true
     };
   }
   if (ch === "`") {
@@ -8969,7 +9221,8 @@ function readAssignedValue(source, start) {
     return {
       value: source.slice(i + 1, end2),
       end: end2,
-      valueStart: i + 1
+      valueStart: i + 1,
+      quoted: false
     };
   }
   if (ch in BRACKET_PAIRS) {
@@ -8978,7 +9231,8 @@ function readAssignedValue(source, start) {
     return {
       value: source.slice(i + 1, end2),
       end: end2,
-      valueStart: i + 1
+      valueStart: i + 1,
+      quoted: false
     };
   }
   let end = i;
@@ -8986,7 +9240,8 @@ function readAssignedValue(source, start) {
   return {
     value: source.slice(i, end),
     end: end - 1,
-    valueStart: i
+    valueStart: i,
+    quoted: false
   };
 }
 function splitTopLevelArgs(source) {
@@ -9087,6 +9342,8 @@ var CandidateCollector = class {
   origin = "plain";
   helperName = null;
   byCandidate = /* @__PURE__ */ new Map();
+  /** value -> byCandidate keys, so delete() is O(occurrences of the value). */
+  keysByValue = /* @__PURE__ */ new Map();
   contexts = [];
   setOrigin(origin) {
     this.origin = origin;
@@ -9111,22 +9368,45 @@ var CandidateCollector = class {
     const candidate = { value, start, end, origin: "plain" };
     if (prefixStart >= 0) candidate.groupPrefix = { start: prefixStart, end: prefixEnd };
     this.byCandidate.set(key, candidate);
+    let keys = this.keysByValue.get(value);
+    if (!keys) {
+      keys = /* @__PURE__ */ new Set();
+      this.keysByValue.set(value, keys);
+    }
+    keys.add(key);
   }
   delete(value) {
-    for (const [key, candidate] of this.byCandidate) {
-      if (candidate.value === value) this.byCandidate.delete(key);
-    }
+    const keys = this.keysByValue.get(value);
+    if (!keys) return;
+    for (const key of keys) this.byCandidate.delete(key);
+    this.keysByValue.delete(value);
   }
   finish() {
     const candidates = [...this.byCandidate.values()].sort(
       (a, b) => a.start - b.start || a.end - b.end
     );
     if (this.contexts.length > 0) {
+      const byStart = [...this.contexts].sort((a, b) => a.start - b.start);
+      const live = [];
+      let next = 0;
       for (const candidate of candidates) {
+        while (next < byStart.length && byStart[next].start <= candidate.start) {
+          live.push(byStart[next]);
+          next++;
+        }
         let best = null;
-        for (const context of this.contexts) {
-          if (context.start <= candidate.start && candidate.end <= context.end) {
-            if (!best || context.end - context.start < best.end - best.start) {
+        for (let i = 0; i < live.length; i++) {
+          const context = live[i];
+          if (context.end < candidate.start) {
+            live[i] = live[live.length - 1];
+            live.pop();
+            i--;
+            continue;
+          }
+          if (candidate.end <= context.end) {
+            const width = context.end - context.start;
+            const bestWidth = best ? best.end - best.start : -1;
+            if (!best || width < bestWidth || width === bestWidth && context.id < best.id) {
               best = context;
             }
           }
@@ -9156,7 +9436,7 @@ var ARBITRARY_PROPERTY = /\[[a-z-][^\]]*:[^\]]+\](?:\/(?:[\w.]+|\[[^\]]*\]|\([^)
 var CLASS_RE_SOURCE = `${BOUNDARY}(${NEGATIVE}${VARIANT_PREFIX}(?:${UTILITY_VALUE}|${VARIANT_GROUP}|${ARBITRARY_PROPERTY})${IMPORTANT_SUFFIX})`;
 var CLASS_RE = new RegExp(CLASS_RE_SOURCE, "g");
 var VARIANT_STRIP_RE = new RegExp(`^(?:${VARIANT_SEGMENT})+`);
-var MAX_LINE_LENGTH = 2e3;
+var MAX_LINE_LENGTH = 1e4;
 var CLASS_HELPERS = [
   "clsx",
   "cn",
@@ -9359,12 +9639,11 @@ function collectAssignedValues(sink, source, regex, visitor = scanClassTokens, b
     const value = raw.trim();
     if (!value) continue;
     sink.markContext?.(base + parsed.valueStart, base + parsed.valueStart + raw.length);
-    visitor(
-      sink,
-      value,
-      base + parsed.valueStart + (raw.length - raw.trimStart().length),
-      warnings
-    );
+    const valueOffset = base + parsed.valueStart + (raw.length - raw.trimStart().length);
+    if (parsed.quoted && visitor !== scanClassTokens) {
+      scanClassTokens(sink, value, valueOffset, warnings);
+    }
+    visitor(sink, value, valueOffset, warnings);
     regex.lastIndex = Math.max(regex.lastIndex, parsed.end + 1);
   }
 }
@@ -9538,10 +9817,8 @@ var NOOP_VISITOR = () => void 0;
 function extractHTML(sink, context, warnings) {
   sink.setOrigin?.("plain");
   scanClassTokens(sink, context.content, 0, warnings);
-  if (sink.wantsPositions) {
-    sink.setOrigin?.("attribute");
-    collectAssignedValues(sink, context.content, /\bclass\s*=/g, NOOP_VISITOR, 0, warnings);
-  }
+  sink.setOrigin?.("attribute");
+  collectAssignedValues(sink, context.content, /\bclass\s*=/g, NOOP_VISITOR, 0, warnings);
 }
 function extractJSXTSX(sink, context, warnings) {
   const content = context.content;
@@ -9585,16 +9862,7 @@ function extractVue(sink, context, warnings) {
     0,
     warnings
   );
-  if (sink.wantsPositions) {
-    collectAssignedValues(
-      sink,
-      context.content,
-      /(?<![:\w-])class\s*=/g,
-      NOOP_VISITOR,
-      0,
-      warnings
-    );
-  }
+  collectAssignedValues(sink, context.content, /(?<![:\w-])class\s*=/g, NOOP_VISITOR, 0, warnings);
 }
 function extractSvelte(sink, context, warnings) {
   sink.setOrigin?.("plain");
@@ -9628,7 +9896,26 @@ var EXTRACTORS = [
     extract: extractJSXTSX
   }
 ];
+function warnOverLongLines(input, warnings) {
+  const content = input.content;
+  if (!warnings || content.length <= MAX_LINE_LENGTH) return;
+  if (input.path?.includes("node_modules")) return;
+  let count = 0;
+  let start = 0;
+  for (; ; ) {
+    const idx = content.indexOf("\n", start);
+    const end = idx === -1 ? content.length : idx;
+    if (end - start > MAX_LINE_LENGTH) count++;
+    if (idx === -1) break;
+    start = idx + 1;
+  }
+  if (count === 0) return;
+  warnings.push(
+    `[RI-1411] ${input.path ?? "<source>"}: ${count} line(s) longer than ${MAX_LINE_LENGTH} characters were skipped by the class scanner (minified-input guard). Quoted class attributes on those lines are still read; other class references there are not \u2014 split the long lines.`
+  );
+}
 function extractInto(sink, input, warnings) {
+  warnOverLongLines(input, warnings);
   let handled = false;
   for (const extractor of EXTRACTORS) {
     if (extractor.test(input)) {
@@ -9716,15 +10003,15 @@ function analyzeProjectCSS(css) {
 }
 
 export {
+  isRIDebug,
+  withTimeout,
+  isAtRuleBoundary,
+  codepointCompare,
   DIRECTIVE_TYPE_NAMES,
   findClosingBrace,
   APPLY_ALIASES,
   hasApplyLikeDirective,
   APPLY_LIKE_MATCH_RE,
-  isRIDebug,
-  withTimeout,
-  isAtRuleBoundary,
-  codepointCompare,
   DIRECTIVE_NAMES_SET,
   directiveAtRulePattern,
   isAtRuleNameChar,