@drskillissue/ganko 0.2.72 → 0.2.81

package/dist/eslint-plugin.cjs

@@ -225,7 +225,6 @@ var CHAR_DOUBLE_QUOTE = 34;
 var CHAR_SINGLE_QUOTE = 39;
 var CHAR_A = 97;
 var CHAR_E = 101;
-var CHAR_H = 104;
 var CHAR_I = 105;
 var CHAR_M = 109;
 var CHAR_N = 110;
@@ -596,7 +595,6 @@ var ID_STICKY = /#([a-zA-Z_-][a-zA-Z0-9_-]*)/y;
 var CLASS_STICKY = /\.([a-zA-Z_-][a-zA-Z0-9_-]*)/y;
 var ATTRIBUTE_STICKY = /\[([^\]]+)\]/y;
 var PSEUDO_ELEMENT_STICKY = /::([a-zA-Z-]+)(?:\([^)]*\))?/y;
-var PSEUDO_CLASS_STICKY = /:([a-zA-Z-]+)(?:\([^)]*\))?/y;
 var ELEMENT_STICKY = /([a-zA-Z][a-zA-Z0-9-]*)/y;
 var WHITESPACE_SPLIT = /\s+/;
 var FUNCTION_CALL_RE = /([a-zA-Z_][\w-]*)\s*\(/g;
@@ -3535,6 +3533,10 @@ function getStaticStringFromJSXValue(node) {
     if (import_typescript4.default.isTemplateExpression(expression) && expression.templateSpans.length === 0) {
       return expression.head.text;
     }
+    if (import_typescript4.default.isBinaryExpression(expression) && expression.operatorToken.kind === import_typescript4.default.SyntaxKind.QuestionQuestionToken) {
+      const fallback = getStaticStringFromJSXValue(expression.right);
+      if (fallback !== null) return fallback;
+    }
   }
   return null;
 }
@@ -22981,7 +22983,7 @@ function splitWhitespaceTokens(value2) {
   return out;
 }
 function parseQuadShorthand(raw) {
-  const parts = splitWhitespaceTokens(raw);
+  const parts = splitTopLevelWhitespace(raw);
   if (parts.length === 1) {
     const p0 = parts[0];
     if (!p0) return null;
@@ -23005,7 +23007,7 @@ function parseQuadShorthand(raw) {
   return null;
 }
 function parseBlockShorthand(raw) {
-  const parts = splitWhitespaceTokens(raw);
+  const parts = splitTopLevelWhitespace(raw);
   if (parts.length === 1) {
     const p0 = parts[0];
     if (!p0) return null;
@@ -23090,8 +23092,14 @@ var NUMERIC_VALUE = /^([0-9]*\.?[0-9]+)(px|rem|em|pt)?$/;
 function parsePxValue(raw, contextFontSize = 16) {
   const trimmed = raw.trim().toLowerCase();
   if (trimmed.length === 0) return null;
-  if (trimmed.includes("var(") || trimmed.includes("calc(") || trimmed.includes("%")) return null;
+  if (trimmed.includes("var(") || trimmed.includes("%")) return null;
   if (CSS_WIDE_KEYWORDS.has(trimmed)) return null;
+  if (trimmed.includes("calc(")) {
+    return tryEvalConstantCalc(trimmed, contextFontSize);
+  }
+  if (trimmed.startsWith("min(") || trimmed.startsWith("max(") || trimmed.startsWith("clamp(")) {
+    return tryEvalMathFunction(trimmed, contextFontSize);
+  }
   const match = NUMERIC_VALUE.exec(trimmed);
   if (!match) return null;
   const num = Number(match[1]);
@@ -23102,6 +23110,135 @@ function parsePxValue(raw, contextFontSize = 16) {
   if (unit === "pt") return num * 1.333;
   return null;
 }
+var CALC_CONSTANT_RE = /^calc\((.+)\)$/;
+var CALC_TOKEN_RE = /([0-9]*\.?[0-9]+)(px|rem|em|pt)?|([+\-*/])/g;
+function tryEvalConstantCalc(raw, contextFontSize) {
+  const match = CALC_CONSTANT_RE.exec(raw);
+  if (!match || !match[1]) return null;
+  const inner = match[1].trim();
+  if (inner.includes("var(") || inner.includes("%") || inner.includes("env(") || inner.includes("calc(")) return null;
+  const values = [];
+  const operators = [];
+  let lastWasValue = false;
+  CALC_TOKEN_RE.lastIndex = 0;
+  let tokenMatch;
+  while ((tokenMatch = CALC_TOKEN_RE.exec(inner)) !== null) {
+    const op = tokenMatch[3];
+    if (op !== void 0) {
+      if (!lastWasValue && op === "-") {
+        const nextToken = CALC_TOKEN_RE.exec(inner);
+        if (!nextToken || nextToken[3] !== void 0) return null;
+        const px2 = calcTokenToPx(nextToken, contextFontSize);
+        if (px2 === null) return null;
+        values.push(-px2);
+        lastWasValue = true;
+        continue;
+      }
+      if (!lastWasValue) return null;
+      operators.push(op);
+      lastWasValue = false;
+      continue;
+    }
+    const px = calcTokenToPx(tokenMatch, contextFontSize);
+    if (px === null) return null;
+    values.push(px);
+    lastWasValue = true;
+  }
+  if (values.length === 0 || values.length !== operators.length + 1) return null;
+  const firstValue = values[0];
+  if (firstValue === void 0) return null;
+  const reducedValues = [firstValue];
+  const reducedOps = [];
+  for (let i = 0; i < operators.length; i++) {
+    const op = operators[i];
+    const right = values[i + 1];
+    if (op === void 0 || right === void 0) return null;
+    if (op === "*") {
+      const last = reducedValues[reducedValues.length - 1];
+      if (last === void 0) return null;
+      reducedValues[reducedValues.length - 1] = last * right;
+    } else if (op === "/") {
+      if (right === 0) return null;
+      const last = reducedValues[reducedValues.length - 1];
+      if (last === void 0) return null;
+      reducedValues[reducedValues.length - 1] = last / right;
+    } else {
+      reducedValues.push(right);
+      reducedOps.push(op);
+    }
+  }
+  const base = reducedValues[0];
+  if (base === void 0) return null;
+  let result = base;
+  for (let i = 0; i < reducedOps.length; i++) {
+    const op = reducedOps[i];
+    const right = reducedValues[i + 1];
+    if (op === void 0 || right === void 0) return null;
+    if (op === "+") result += right;
+    else if (op === "-") result -= right;
+    else return null;
+  }
+  return Number.isFinite(result) ? result : null;
+}
+function calcTokenToPx(tokenMatch, contextFontSize) {
+  const num = Number(tokenMatch[1]);
+  if (Number.isNaN(num)) return null;
+  const unit = tokenMatch[2] ?? "";
+  if (unit === "px" || unit === "") return num;
+  if (unit === "rem") return num * 16;
+  if (unit === "em") return num * contextFontSize;
+  if (unit === "pt") return num * 1.333;
+  return null;
+}
+var MATH_FN_RE = /^(min|max|clamp)\((.+)\)$/;
+function tryEvalMathFunction(raw, contextFontSize) {
+  const match = MATH_FN_RE.exec(raw);
+  if (!match || !match[1] || !match[2]) return null;
+  const fn = match[1];
+  const inner = match[2];
+  const args = splitMathArgs(inner);
+  if (args === null) return null;
+  const values = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) return null;
+    const px = parsePxValue(arg.trim(), contextFontSize);
+    if (px === null) return null;
+    values.push(px);
+  }
+  if (values.length === 0) return null;
+  if (fn === "min") return Math.min(...values);
+  if (fn === "max") return Math.max(...values);
+  if (fn === "clamp") {
+    if (values.length !== 3) return null;
+    const [lo, val, hi] = values;
+    return Math.max(lo, Math.min(val, hi));
+  }
+  return null;
+}
+function splitMathArgs(inner) {
+  const args = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < inner.length; i++) {
+    const ch = inner[i];
+    if (ch === "(") depth++;
+    else if (ch === ")") {
+      if (depth > 0) depth--;
+      else return null;
+    } else if (ch === "," && depth === 0) {
+      const arg = inner.slice(start, i).trim();
+      if (arg.length === 0) return null;
+      args.push(arg);
+      start = i + 1;
+    }
+  }
+  if (depth !== 0) return null;
+  const tail = inner.slice(start).trim();
+  if (tail.length === 0) return null;
+  args.push(tail);
+  return args;
+}
 function parseUnitlessValue(raw) {
   const trimmed = raw.trim().toLowerCase();
   if (trimmed.length === 0) return null;
@@ -23503,19 +23640,6 @@ var FONT_GENERIC_FAMILY_SET = /* @__PURE__ */ new Set([
 ]);
 var FONT_LAYOUT_PROPERTIES = /* @__PURE__ */ new Set(["font-family"]);
 var WHITESPACE_RE2 = /\s+/;
-function classifyRuleElementKinds(rule) {
-  const kinds = rule.elementKinds;
-  for (let i = 0; i < rule.selectors.length; i++) {
-    const sel = rule.selectors[i];
-    if (!sel) continue;
-    const parts = sel.parts;
-    for (let j = 0; j < parts.length; j++) {
-      const part = parts[j];
-      if (!part) continue;
-      classifyPart(part, kinds);
-    }
-  }
-}
 function classifyPart(part, kinds) {
   if (part.type === "element") {
     const lower = part.value.toLowerCase();
@@ -23643,7 +23767,19 @@ var CSSGraph = class {
   parseErrors = [];
   failedFilePaths = [];
   tokenCategories = [];
-  filesWithLayers = /* @__PURE__ */ new Set();
+  _filesWithLayers = null;
+  get filesWithLayers() {
+    if (this._filesWithLayers === null) {
+      const result = /* @__PURE__ */ new Set();
+      for (let i = 0; i < this.layers.length; i++) {
+        const layer = this.layers[i];
+        if (!layer) continue;
+        result.add(layer.file.path);
+      }
+      this._filesWithLayers = result;
+    }
+    return this._filesWithLayers;
+  }
   selectorsByPseudoClass = /* @__PURE__ */ new Map();
   knownKeyframeNames = /* @__PURE__ */ new Set();
   unresolvedAnimationRefs = [];
@@ -23655,17 +23791,61 @@ var CSSGraph = class {
   multiDeclarationProperties = /* @__PURE__ */ new Map();
   /** Declarations whose parent rule is inside a @keyframes block. */
   keyframeDeclarations = [];
-  /** Rules with zero declarations and zero nested rules. */
-  emptyRules = [];
+  /** Rules with zero declarations, zero nested rules, and zero nested at-rules. */
+  _emptyRules = null;
+  get emptyRules() {
+    if (this._emptyRules === null) {
+      this._emptyRules = this.rules.filter((r) => r.declarations.length === 0 && r.nestedRules.length === 0 && r.nestedAtRules.length === 0);
+    }
+    return this._emptyRules;
+  }
   /** @keyframes at-rules with no effective keyframe declarations. */
-  emptyKeyframes = [];
-  colorDeclarations = [];
-  calcDeclarations = [];
-  varDeclarations = [];
-  urlDeclarations = [];
-  vendorPrefixedDeclarations = [];
-  hardcodedColorDeclarations = [];
-  overqualifiedSelectors = [];
+  _emptyKeyframes = null;
+  get emptyKeyframes() {
+    if (this._emptyKeyframes === null) {
+      const result = [];
+      for (let i = 0; i < this.keyframes.length; i++) {
+        const kf = this.keyframes[i];
+        if (!kf) continue;
+        if (!kf.parsedParams.animationName) continue;
+        if (kf.rules.length === 0) {
+          result.push(kf);
+          continue;
+        }
+        let hasDeclaration = false;
+        for (let j = 0; j < kf.rules.length; j++) {
+          const kfRule = kf.rules[j];
+          if (!kfRule) continue;
+          if (kfRule.declarations.length > 0) {
+            hasDeclaration = true;
+            break;
+          }
+        }
+        if (!hasDeclaration) result.push(kf);
+      }
+      this._emptyKeyframes = result;
+    }
+    return this._emptyKeyframes;
+  }
+  _overqualifiedSelectors = null;
+  get overqualifiedSelectors() {
+    if (this._overqualifiedSelectors === null) {
+      const result = [];
+      for (let i = 0, len = this.idSelectors.length; i < len; i++) {
+        const sel = this.idSelectors[i];
+        if (!sel) continue;
+        const compounds = sel.compounds;
+        if (compounds.length === 0) continue;
+        const subject = compounds[compounds.length - 1];
+        if (!subject) continue;
+        if (subject.idValue !== null && (subject.tagName !== null || subject.classes.length > 0 || subject.attributes.length > 0)) {
+          result.push(sel);
+        }
+      }
+      this._overqualifiedSelectors = result;
+    }
+    return this._overqualifiedSelectors;
+  }
   idSelectors = [];
   attributeSelectors = [];
   universalSelectors = [];
@@ -23681,7 +23861,13 @@ var CSSGraph = class {
   usedFontFamilies = /* @__PURE__ */ new Set();
   /** Tailwind validator for utility class lookup (null if not a Tailwind project). */
   tailwind;
-  deepNestedRules = [];
+  _deepNestedRules = null;
+  get deepNestedRules() {
+    if (this._deepNestedRules === null) {
+      this._deepNestedRules = this.rules.filter((r) => r.depth > 3);
+    }
+    return this._deepNestedRules;
+  }
   constructor(input) {
     this.options = input.options ?? {};
     this.tailwind = input.tailwind ?? null;
@@ -23746,13 +23932,57 @@ var CSSGraph = class {
   }
   addSelector(selector) {
     this.selectors.push(selector);
+    const anchor = selector.anchor;
+    if (anchor.subjectTag === null) {
+      this.selectorsWithoutSubjectTag.push(selector);
+    } else {
+      const existingByTag = this.selectorsBySubjectTag.get(anchor.subjectTag);
+      if (existingByTag) existingByTag.push(selector);
+      else this.selectorsBySubjectTag.set(anchor.subjectTag, [selector]);
+    }
+    if (anchor.targetsCheckbox) this.selectorsTargetingCheckbox.push(selector);
+    if (anchor.targetsTableCell) this.selectorsTargetingTableCell.push(selector);
+    const compounds = selector.compounds;
+    for (let ci = 0; ci < compounds.length; ci++) {
+      const compound = compounds[ci];
+      if (!compound) continue;
+      const cls = compound.classes;
+      for (let j = 0; j < cls.length; j++) {
+        const className = cls[j];
+        if (!className) continue;
+        const existing = this.classNameIndex.get(className);
+        if (existing) existing.push(selector);
+        else this.classNameIndex.set(className, [selector]);
+      }
+    }
+    const complexity = selector.complexity;
+    const flags = complexity._flags;
+    if (hasFlag(flags, SEL_HAS_ID)) this.idSelectors.push(selector);
+    if (hasFlag(flags, SEL_HAS_ATTRIBUTE)) this.attributeSelectors.push(selector);
+    if (hasFlag(flags, SEL_HAS_UNIVERSAL)) this.universalSelectors.push(selector);
+    const pseudoClasses = complexity.pseudoClasses;
+    for (let j = 0; j < pseudoClasses.length; j++) {
+      const pc = pseudoClasses[j];
+      if (!pc) continue;
+      const pcExisting = this.selectorsByPseudoClass.get(pc);
+      if (pcExisting) pcExisting.push(selector);
+      else this.selectorsByPseudoClass.set(pc, [selector]);
+    }
   }
   addDeclaration(decl) {
     this.declarations.push(decl);
-    const existing = this.declarationsByProperty.get(decl.property);
+    const property = decl.property;
+    const existing = this.declarationsByProperty.get(property);
     if (existing) existing.push(decl);
-    else this.declarationsByProperty.set(decl.property, [decl]);
+    else this.declarationsByProperty.set(property, [decl]);
     if (hasFlag(decl._flags, DECL_IS_IMPORTANT) || decl.node.important) this.importantDeclarations.push(decl);
+    if (decl.rule !== null) {
+      const p = property.toLowerCase();
+      const ruleIndex = decl.rule.declarationIndex;
+      const ruleExisting = ruleIndex.get(p);
+      if (ruleExisting) ruleExisting.push(decl);
+      else ruleIndex.set(p, [decl]);
+    }
   }
   addVariable(variable) {
     this.variables.push(variable);
@@ -23886,39 +24116,12 @@ var CSSGraph = class {
    * Called after all phases complete.
    */
   buildDerivedIndexes() {
-    this.buildRuleDeclarationIndexes();
     this.buildContainingMediaStacks();
-    this.buildKeyframeIndex();
+    this.buildKeyframeIndexes();
     this.buildContainerNameIndexes();
-    this.buildElementKinds();
-    this.buildFilesWithLayers();
-    this.buildSelectorPseudoClassIndex();
     this.buildMultiDeclarationProperties();
-    this.buildKeyframeDeclarations();
-    this.buildKeyframeLayoutMutationsByName();
-    this.buildEmptyRules();
-    this.buildEmptyKeyframes();
-    this.buildDeclarationDerivedIndexes();
-    this.buildSelectorDerivedIndexes();
     this.buildLayoutPropertiesByClassToken();
-    this.buildFontFamilyUsageByRule();
-    this.buildFontFaceDescriptorsByFamily();
-    this.buildRuleDerivedIndexes();
-  }
-  buildRuleDeclarationIndexes() {
-    for (let i = 0; i < this.rules.length; i++) {
-      const rule = this.rules[i];
-      if (!rule) continue;
-      const index = rule.declarationIndex;
-      for (let j = 0; j < rule.declarations.length; j++) {
-        const d = rule.declarations[j];
-        if (!d) continue;
-        const p = d.property.toLowerCase();
-        const existing = index.get(p);
-        if (existing) existing.push(d);
-        else index.set(p, [d]);
-      }
-    }
+    this.buildFontIndexes();
   }
   buildContainingMediaStacks() {
     for (let i = 0; i < this.rules.length; i++) {
@@ -23933,7 +24136,7 @@ var CSSGraph = class {
       rule.containingMediaStack = medias;
     }
   }
-  buildKeyframeIndex() {
+  buildKeyframeIndexes() {
     const IGNORED = /* @__PURE__ */ new Set([...CSS_WIDE_KEYWORDS, "none"]);
     for (let i = 0; i < this.keyframes.length; i++) {
       const kf = this.keyframes[i];
@@ -23955,6 +24158,47 @@ var CSSGraph = class {
         this.unresolvedAnimationRefs.push({ declaration: d, name });
       }
     }
+    const byAnimationByProperty = /* @__PURE__ */ new Map();
+    for (let i = 0; i < this.declarations.length; i++) {
+      const d = this.declarations[i];
+      if (!d) continue;
+      const rule = d.rule;
+      if (!rule) continue;
+      const parent = rule.parent;
+      if (!parent) continue;
+      if (parent.kind === "rule") continue;
+      if (parent.kind !== "keyframes") continue;
+      this.keyframeDeclarations.push(d);
+      const property = d.property.toLowerCase();
+      if (!LAYOUT_ANIMATION_MUTATION_PROPERTIES.has(property)) continue;
+      const animationName = normalizeAnimationName(parent.params);
+      if (!animationName) continue;
+      let byProperty = byAnimationByProperty.get(animationName);
+      if (!byProperty) {
+        byProperty = /* @__PURE__ */ new Map();
+        byAnimationByProperty.set(animationName, byProperty);
+      }
+      let bucket = byProperty.get(property);
+      if (!bucket) {
+        bucket = { values: /* @__PURE__ */ new Set(), declarations: [] };
+        byProperty.set(property, bucket);
+      }
+      bucket.values.add(normalizeCssValue(d.value));
+      bucket.declarations.push(d);
+    }
+    for (const [animationName, byProperty] of byAnimationByProperty) {
+      const mutations = [];
+      for (const [property, bucket] of byProperty) {
+        if (bucket.values.size <= 1) continue;
+        mutations.push({
+          property,
+          values: [...bucket.values],
+          declarations: bucket.declarations
+        });
+      }
+      if (mutations.length === 0) continue;
+      this.keyframeLayoutMutationsByName.set(animationName, mutations);
+    }
   }
   buildContainerNameIndexes() {
     for (let i = 0; i < this.declarations.length; i++) {
@@ -23998,34 +24242,6 @@ var CSSGraph = class {
       }
     }
   }
-  buildElementKinds() {
-    for (let i = 0; i < this.rules.length; i++) {
-      const rule = this.rules[i];
-      if (!rule) continue;
-      classifyRuleElementKinds(rule);
-    }
-  }
-  buildFilesWithLayers() {
-    for (let i = 0; i < this.layers.length; i++) {
-      const layer = this.layers[i];
-      if (!layer) continue;
-      this.filesWithLayers.add(layer.file.path);
-    }
-  }
-  buildSelectorPseudoClassIndex() {
-    for (let i = 0; i < this.selectors.length; i++) {
-      const sel = this.selectors[i];
-      if (!sel) continue;
-      const pseudoClasses = sel.complexity.pseudoClasses;
-      for (let j = 0; j < pseudoClasses.length; j++) {
-        const pc = pseudoClasses[j];
-        if (!pc) continue;
-        const existing = this.selectorsByPseudoClass.get(pc);
-        if (existing) existing.push(sel);
-        else this.selectorsByPseudoClass.set(pc, [sel]);
-      }
-    }
-  }
   /**
    * Sort each declarationsByProperty list by sourceOrder and populate
    * multiDeclarationProperties with only those having 2+ entries.
@@ -24038,162 +24254,6 @@ var CSSGraph = class {
       }
     }
   }
-  /**
-   * Collect declarations whose parent rule is inside a @keyframes block.
-   */
-  buildKeyframeDeclarations() {
-    for (let i = 0; i < this.declarations.length; i++) {
-      const d = this.declarations[i];
-      if (!d) continue;
-      const rule = d.rule;
-      if (!rule) continue;
-      const parent = rule.parent;
-      if (!parent) continue;
-      if (parent.kind === "rule") continue;
-      if (parent.kind !== "keyframes") continue;
-      this.keyframeDeclarations.push(d);
-    }
-  }
-  buildKeyframeLayoutMutationsByName() {
-    const byAnimationByProperty = /* @__PURE__ */ new Map();
-    for (let i = 0; i < this.keyframeDeclarations.length; i++) {
-      const declaration = this.keyframeDeclarations[i];
-      if (!declaration) continue;
-      const rule = declaration.rule;
-      if (!rule || rule.parent === null || rule.parent.kind !== "keyframes") continue;
-      const property = declaration.property.toLowerCase();
-      if (!LAYOUT_ANIMATION_MUTATION_PROPERTIES.has(property)) continue;
-      const animationName = normalizeAnimationName(rule.parent.params);
-      if (!animationName) continue;
-      let byProperty = byAnimationByProperty.get(animationName);
-      if (!byProperty) {
-        byProperty = /* @__PURE__ */ new Map();
-        byAnimationByProperty.set(animationName, byProperty);
-      }
-      let bucket = byProperty.get(property);
-      if (!bucket) {
-        bucket = { values: /* @__PURE__ */ new Set(), declarations: [] };
-        byProperty.set(property, bucket);
-      }
-      bucket.values.add(normalizeCssValue(declaration.value));
-      bucket.declarations.push(declaration);
-    }
-    for (const [animationName, byProperty] of byAnimationByProperty) {
-      const mutations = [];
-      for (const [property, bucket] of byProperty) {
-        if (bucket.values.size <= 1) continue;
-        mutations.push({
-          property,
-          values: [...bucket.values],
-          declarations: bucket.declarations
-        });
-      }
-      if (mutations.length === 0) continue;
-      this.keyframeLayoutMutationsByName.set(animationName, mutations);
-    }
-  }
-  /**
-   * Collect rules with no declarations and no nested rules.
-   */
-  buildEmptyRules() {
-    for (let i = 0; i < this.rules.length; i++) {
-      const rule = this.rules[i];
-      if (!rule) continue;
-      if (rule.declarations.length === 0 && rule.nestedRules.length === 0) {
-        this.emptyRules.push(rule);
-      }
-    }
-  }
-  /**
-   * Collect @keyframes with no effective keyframe declarations.
-   */
-  buildEmptyKeyframes() {
-    for (let i = 0; i < this.keyframes.length; i++) {
-      const kf = this.keyframes[i];
-      if (!kf) continue;
-      if (!kf.parsedParams.animationName) continue;
-      if (kf.rules.length === 0) {
-        this.emptyKeyframes.push(kf);
-        continue;
-      }
-      let hasDeclaration = false;
-      for (let j = 0; j < kf.rules.length; j++) {
-        const kfRule = kf.rules[j];
-        if (!kfRule) continue;
-        if (kfRule.declarations.length > 0) {
-          hasDeclaration = true;
-          break;
-        }
-      }
-      if (!hasDeclaration) this.emptyKeyframes.push(kf);
-    }
-  }
-  buildDeclarationDerivedIndexes() {
-    const HARDCODED_HEX = /^#[0-9a-f]{3,8}$/i;
-    for (let i = 0, len = this.declarations.length; i < len; i++) {
-      const d = this.declarations[i];
-      if (!d) continue;
-      const pv = d.parsedValue;
-      if (pv.colors.length > 0) this.colorDeclarations.push(d);
-      if (pv.hasCalc) this.calcDeclarations.push(d);
-      if (pv.hasVar) this.varDeclarations.push(d);
-      if (pv.hasUrl) this.urlDeclarations.push(d);
-      if (d.property.charCodeAt(0) === CHAR_HYPHEN && d.property.charCodeAt(1) !== CHAR_HYPHEN) {
-        this.vendorPrefixedDeclarations.push(d);
-      }
-      if (!pv.hasVar && pv.colors.length > 0) {
-        for (let j = 0, clen = pv.colors.length; j < clen; j++) {
-          const c = pv.colors[j];
-          if (!c) continue;
-          if (HARDCODED_HEX.test(c) || c.charCodeAt(0) === CHAR_R || c.charCodeAt(0) === CHAR_H) {
-            this.hardcodedColorDeclarations.push(d);
-            break;
-          }
-        }
-      }
-    }
-  }
-  buildSelectorDerivedIndexes() {
-    for (let i = 0, len = this.selectors.length; i < len; i++) {
-      const sel = this.selectors[i];
-      if (!sel) continue;
-      const parts = sel.parts;
-      const anchor = sel.anchor;
-      if (anchor.subjectTag === null) {
-        this.selectorsWithoutSubjectTag.push(sel);
-      } else {
-        const existingByTag = this.selectorsBySubjectTag.get(anchor.subjectTag);
-        if (existingByTag) existingByTag.push(sel);
-        else this.selectorsBySubjectTag.set(anchor.subjectTag, [sel]);
-      }
-      if (anchor.targetsCheckbox) this.selectorsTargetingCheckbox.push(sel);
-      if (anchor.targetsTableCell) this.selectorsTargetingTableCell.push(sel);
-      for (let j = 0, plen = parts.length; j < plen; j++) {
-        const part = parts[j];
-        if (!part) continue;
-        if (part.type === "class") {
-          const existing = this.classNameIndex.get(part.value);
-          if (existing) existing.push(sel);
-          else this.classNameIndex.set(part.value, [sel]);
-        }
-      }
-      const flags = sel.complexity._flags;
-      if (hasFlag(flags, SEL_HAS_ID)) {
-        this.idSelectors.push(sel);
-        for (let j = 0, plen = parts.length; j < plen; j++) {
-          const p = parts[j];
-          if (!p) continue;
-          const t = p.type;
-          if (t === "element" || t === "class" || t === "attribute") {
-            this.overqualifiedSelectors.push(sel);
-            break;
-          }
-        }
-      }
-      if (hasFlag(flags, SEL_HAS_ATTRIBUTE)) this.attributeSelectors.push(sel);
-      if (hasFlag(flags, SEL_HAS_UNIVERSAL)) this.universalSelectors.push(sel);
-    }
-  }
   buildLayoutPropertiesByClassToken() {
     const byClass = /* @__PURE__ */ new Map();
     for (let i = 0; i < this.selectors.length; i++) {
@@ -24224,7 +24284,7 @@ var CSSGraph = class {
       this.layoutPropertiesByClassToken.set(className, [...properties]);
     }
   }
-  buildFontFamilyUsageByRule() {
+  buildFontIndexes() {
     const declarations = this.declarationsForProperties(...FONT_LAYOUT_PROPERTIES);
     for (let i = 0; i < declarations.length; i++) {
       const declaration = declarations[i];
@@ -24251,8 +24311,6 @@ var CSSGraph = class {
       }
       this.usedFontFamiliesByRule.set(rule.id, [...merged]);
     }
-  }
-  buildFontFaceDescriptorsByFamily() {
     const byFamily = /* @__PURE__ */ new Map();
     for (let i = 0; i < this.fontFaces.length; i++) {
       const fontFace = this.fontFaces[i];
@@ -24284,13 +24342,6 @@ var CSSGraph = class {
       this.fontFaceDescriptorsByFamily.set(family, descriptors);
     }
   }
-  buildRuleDerivedIndexes() {
-    for (let i = 0, len = this.rules.length; i < len; i++) {
-      const rule = this.rules[i];
-      if (!rule) continue;
-      if (rule.depth > 3) this.deepNestedRules.push(rule);
-    }
-  }
   buildUnusedIndexes() {
     for (const v of this.variables) {
       if (!hasFlag(v._flags, VAR_IS_USED)) this.unusedVariables.push(v);
@@ -24604,102 +24655,6 @@ function buildComplexity(combinators, hasId, hasUniversal, hasAttribute, hasPseu
 }
 
 // src/css/parser/selector.ts
-function parseSelector(raw) {
-  let start = 0;
-  let end = raw.length;
-  while (start < end && isWhitespace(raw.charCodeAt(start))) start++;
-  while (end > start && isWhitespace(raw.charCodeAt(end - 1))) end--;
-  if (start === end) return [];
-  const input = start === 0 && end === raw.length ? raw : raw.substring(start, end);
-  const len = input.length;
-  const parts = [];
-  let pos = 0;
-  while (pos < len) {
-    const char = input.charCodeAt(pos);
-    if (isWhitespace(char) || isCombinator(char)) {
-      pos++;
-      continue;
-    }
-    if (char === CHAR_AMPERSAND) {
-      parts.push({ type: "nesting", value: "&", raw: "&" });
-      pos++;
-      continue;
-    }
-    if (char === CHAR_ASTERISK) {
-      parts.push({ type: "universal", value: "*", raw: "*" });
-      pos++;
-      continue;
-    }
-    if (char === CHAR_HASH) {
-      ID_STICKY.lastIndex = pos;
-      const match = ID_STICKY.exec(input);
-      if (match) {
-        const val = match[1];
-        if (!val) break;
-        parts.push({ type: "id", value: val, raw: match[0] });
-        pos = ID_STICKY.lastIndex;
-        continue;
-      }
-    }
-    if (char === CHAR_DOT) {
-      CLASS_STICKY.lastIndex = pos;
-      const match = CLASS_STICKY.exec(input);
-      if (match) {
-        const val = match[1];
-        if (!val) break;
-        parts.push({ type: "class", value: val, raw: match[0] });
-        pos = CLASS_STICKY.lastIndex;
-        continue;
-      }
-    }
-    if (char === CHAR_OPEN_BRACKET) {
-      ATTRIBUTE_STICKY.lastIndex = pos;
-      const match = ATTRIBUTE_STICKY.exec(input);
-      if (match) {
-        const val = match[1];
-        if (!val) break;
-        parts.push({ type: "attribute", value: val, raw: match[0] });
-        pos = ATTRIBUTE_STICKY.lastIndex;
-        continue;
-      }
-    }
-    if (char === CHAR_COLON) {
-      if (pos + 1 < len && input.charCodeAt(pos + 1) === CHAR_COLON) {
-        PSEUDO_ELEMENT_STICKY.lastIndex = pos;
-        const match2 = PSEUDO_ELEMENT_STICKY.exec(input);
-        if (match2) {
-          const val = match2[1];
-          if (!val) break;
-          parts.push({ type: "pseudo-element", value: val, raw: match2[0] });
-          pos = PSEUDO_ELEMENT_STICKY.lastIndex;
-          continue;
-        }
-      }
-      PSEUDO_CLASS_STICKY.lastIndex = pos;
-      const match = PSEUDO_CLASS_STICKY.exec(input);
-      if (match) {
-        const val = match[1];
-        if (!val) break;
-        parts.push({ type: "pseudo-class", value: val, raw: match[0] });
-        pos = PSEUDO_CLASS_STICKY.lastIndex;
-        continue;
-      }
-    }
-    if (isAlpha(char)) {
-      ELEMENT_STICKY.lastIndex = pos;
-      const match = ELEMENT_STICKY.exec(input);
-      if (match) {
-        const val = match[1];
-        if (!val) break;
-        parts.push({ type: "element", value: val, raw: match[0] });
-        pos = ELEMENT_STICKY.lastIndex;
-        continue;
-      }
-    }
-    pos++;
-  }
-  return parts;
-}
 function parseSelectorList(selectorText) {
   const len = selectorText.length;
   if (len === 0) return [];
@@ -24787,18 +24742,80 @@ function extractPseudoClasses(selector) {
   }
   return pseudoClasses;
 }
-function parseSelectorComplete(raw) {
+var CHAR_BACKSLASH = 92;
+function readCssIdentifier(input, start) {
+  const length = input.length;
+  let i = start;
+  let hasEscape = false;
+  while (i < length) {
+    const code = input.charCodeAt(i);
+    if (code === CHAR_BACKSLASH) {
+      if (i + 1 >= length) break;
+      hasEscape = true;
+      i = skipCssEscape(input, i + 1);
+      continue;
+    }
+    if (!isIdentChar(code)) break;
+    i++;
+  }
+  if (i === start) return null;
+  if (!hasEscape) {
+    return { value: input.slice(start, i), end: i };
+  }
+  const parts = [];
+  let j = start;
+  while (j < i) {
+    const code = input.charCodeAt(j);
+    if (code !== CHAR_BACKSLASH) {
+      parts.push(String.fromCharCode(code));
+      j++;
+      continue;
+    }
+    j++;
+    if (j >= i) break;
+    const first = input.charCodeAt(j);
+    if (!isHexDigit(first)) {
+      parts.push(String.fromCharCode(first));
+      j++;
+      continue;
+    }
+    const hexStart = j;
+    const maxHex = Math.min(j + 6, i);
+    while (j < maxHex && isHexDigit(input.charCodeAt(j))) j++;
+    const codePoint = Number.parseInt(input.slice(hexStart, j), 16);
+    if (codePoint > 0 && codePoint <= 1114111) parts.push(String.fromCodePoint(codePoint));
+    if (j < i && isWhitespace(input.charCodeAt(j))) j++;
+  }
+  return { value: parts.join(""), end: i };
+}
+function skipCssEscape(input, afterBackslash) {
+  const length = input.length;
+  if (afterBackslash >= length) return afterBackslash;
+  const first = input.charCodeAt(afterBackslash);
+  if (!isHexDigit(first)) return afterBackslash + 1;
+  let end = afterBackslash + 1;
+  const maxHex = Math.min(afterBackslash + 6, length);
+  while (end < maxHex && isHexDigit(input.charCodeAt(end))) end++;
+  if (end < length && isWhitespace(input.charCodeAt(end))) end++;
+  return end;
+}
+var ATTRIBUTE_EXISTS_RE = /^[-_a-zA-Z][-_a-zA-Z0-9]*$/;
+var ATTRIBUTE_CONSTRAINT_RE = /^([-_a-zA-Z][-_a-zA-Z0-9]*)\s*(=|~=|\|=|\^=|\$=|\*=)\s*(?:"([^"]*)"|'([^']*)'|([^\s"']+))(?:\s+([iIsS]))?$/;
+var MAX_PSEUDO_PARSE_DEPTH = 4;
+function parseSelectorComplete(raw, _depth) {
   let start = 0;
   let end = raw.length;
   while (start < end && isWhitespace(raw.charCodeAt(start))) start++;
   while (end > start && isWhitespace(raw.charCodeAt(end - 1))) end--;
   if (start === end) {
-    return { parts: [], combinators: [], specificity: [0, 0, 0, 0], complexity: MINIMAL_COMPLEXITY };
+    return { parts: [], compounds: [], combinators: [], specificity: [0, 0, 0, 0], complexity: MINIMAL_COMPLEXITY };
   }
   const input = start === 0 && end === raw.length ? raw : raw.substring(start, end);
   const len = input.length;
-  const parts = [];
+  const allParts = [];
+  let currentCompoundParts = [];
   const combinators = [];
+  const compounds = [];
   let ids = 0;
   let classes = 0;
   let elements = 0;
@@ -24808,10 +24825,11 @@ function parseSelectorComplete(raw) {
   let hasPseudoClassFlag = false;
   let hasPseudoElementFlag = false;
   let hasNesting = false;
-  const pseudoClasses = [];
-  const pseudoElements = [];
+  const pseudoClassNames = [];
+  const pseudoElementNames = [];
   let pos = 0;
   let inCompound = false;
+  const depth = _depth ?? 0;
   while (pos < len) {
     const char = input.charCodeAt(pos);
     if (isWhitespace(char) || isCombinator(char)) {
@@ -24836,6 +24854,8 @@ function parseSelectorComplete(raw) {
           }
         }
         if (scanPos < len) {
+          compounds.push(finalizeCompound(currentCompoundParts, depth));
+          currentCompoundParts = [];
           combinators.push(sawCombinator ?? "descendant");
           inCompound = false;
         }
@@ -24847,13 +24867,17 @@ function parseSelectorComplete(raw) {
     }
     inCompound = true;
     if (char === CHAR_AMPERSAND) {
-      parts.push({ type: "nesting", value: "&", raw: "&" });
+      const part = { type: "nesting", value: "&", raw: "&" };
+      allParts.push(part);
+      currentCompoundParts.push(part);
       hasNesting = true;
       pos++;
       continue;
     }
     if (char === CHAR_ASTERISK) {
-      parts.push({ type: "universal", value: "*", raw: "*" });
+      const part = { type: "universal", value: "*", raw: "*" };
+      allParts.push(part);
+      currentCompoundParts.push(part);
       hasUniversal = true;
       pos++;
       continue;
@@ -24864,10 +24888,26 @@ function parseSelectorComplete(raw) {
       if (match) {
         const val = match[1];
         if (!val) break;
-        parts.push({ type: "id", value: val, raw: match[0] });
+        const ident2 = readCssIdentifier(input, pos + 1);
+        const idVal = ident2 ? ident2.value : val;
+        const idRaw = ident2 ? input.slice(pos, ident2.end) : match[0];
+        const idEnd = ident2 ? ident2.end : ID_STICKY.lastIndex;
+        const part = { type: "id", value: idVal, raw: idRaw };
+        allParts.push(part);
+        currentCompoundParts.push(part);
         ids++;
         hasId = true;
-        pos = ID_STICKY.lastIndex;
+        pos = idEnd;
+        continue;
+      }
+      const ident = readCssIdentifier(input, pos + 1);
+      if (ident) {
+        const part = { type: "id", value: ident.value, raw: input.slice(pos, ident.end) };
+        allParts.push(part);
+        currentCompoundParts.push(part);
+        ids++;
+        hasId = true;
+        pos = ident.end;
         continue;
       }
     }
@@ -24877,9 +24917,24 @@ function parseSelectorComplete(raw) {
       if (match) {
         const val = match[1];
         if (!val) break;
-        parts.push({ type: "class", value: val, raw: match[0] });
+        const ident2 = readCssIdentifier(input, pos + 1);
+        const clsVal = ident2 ? ident2.value : val;
+        const clsRaw = ident2 ? input.slice(pos, ident2.end) : match[0];
+        const clsEnd = ident2 ? ident2.end : CLASS_STICKY.lastIndex;
+        const part = { type: "class", value: clsVal, raw: clsRaw };
+        allParts.push(part);
+        currentCompoundParts.push(part);
+        classes++;
+        pos = clsEnd;
+        continue;
+      }
+      const ident = readCssIdentifier(input, pos + 1);
+      if (ident) {
+        const part = { type: "class", value: ident.value, raw: input.slice(pos, ident.end) };
+        allParts.push(part);
+        currentCompoundParts.push(part);
         classes++;
-        pos = CLASS_STICKY.lastIndex;
+        pos = ident.end;
         continue;
       }
     }
@@ -24889,7 +24944,9 @@ function parseSelectorComplete(raw) {
       if (match) {
         const val = match[1];
         if (!val) break;
-        parts.push({ type: "attribute", value: val, raw: match[0] });
+        const part = { type: "attribute", value: val, raw: match[0] };
+        allParts.push(part);
+        currentCompoundParts.push(part);
         classes++;
         hasAttribute = true;
         pos = ATTRIBUTE_STICKY.lastIndex;
@@ -24903,10 +24960,12 @@ function parseSelectorComplete(raw) {
         if (match) {
           const val = match[1];
           if (!val) break;
-          parts.push({ type: "pseudo-element", value: val, raw: match[0] });
+          const part = { type: "pseudo-element", value: val, raw: match[0] };
+          allParts.push(part);
+          currentCompoundParts.push(part);
           elements++;
           hasPseudoElementFlag = true;
-          pseudoElements.push(val);
+          pseudoElementNames.push(val);
           pos = PSEUDO_ELEMENT_STICKY.lastIndex;
           continue;
         }
@@ -24932,19 +24991,25 @@ function parseSelectorComplete(raw) {
           const fullMatch = input.substring(pseudoStart, argEnd);
           const argContent = input.substring(nameEnd + 1, argEnd - 1);
           if (pseudoName === "where") {
-            parts.push({ type: "pseudo-class", value: pseudoName, raw: fullMatch });
+            const part2 = { type: "pseudo-class", value: pseudoName, raw: fullMatch };
+            allParts.push(part2);
+            currentCompoundParts.push(part2);
             hasPseudoClassFlag = true;
-            pseudoClasses.push(pseudoName);
+            pseudoClassNames.push(pseudoName);
           } else if (pseudoName === "is" || pseudoName === "not" || pseudoName === "has") {
-            parts.push({ type: "pseudo-class", value: pseudoName, raw: fullMatch });
+            const part2 = { type: "pseudo-class", value: pseudoName, raw: fullMatch };
+            allParts.push(part2);
+            currentCompoundParts.push(part2);
             hasPseudoClassFlag = true;
-            pseudoClasses.push(pseudoName);
+            pseudoClassNames.push(pseudoName);
             const args = splitPseudoArgs(argContent);
             let maxIds = 0, maxClasses = 0, maxElements = 0;
-            for (const arg of args) {
+            for (let ai = 0; ai < args.length; ai++) {
+              const arg = args[ai];
+              if (!arg) continue;
               const trimmed = arg.trim();
               if (trimmed) {
-                const { specificity: argSpec } = parseSelectorComplete(trimmed);
+                const { specificity: argSpec } = parseSelectorComplete(trimmed, depth + 1);
                 if (argSpec[1] > maxIds || argSpec[1] === maxIds && argSpec[2] > maxClasses || argSpec[1] === maxIds && argSpec[2] === maxClasses && argSpec[3] > maxElements) {
                   maxIds = argSpec[1];
                   maxClasses = argSpec[2];
@@ -24956,18 +25021,22 @@ function parseSelectorComplete(raw) {
             classes += maxClasses;
             elements += maxElements;
           } else {
-            parts.push({ type: "pseudo-class", value: pseudoName, raw: fullMatch });
+            const part2 = { type: "pseudo-class", value: pseudoName, raw: fullMatch };
+            allParts.push(part2);
+            currentCompoundParts.push(part2);
             hasPseudoClassFlag = true;
-            pseudoClasses.push(pseudoName);
+            pseudoClassNames.push(pseudoName);
             classes++;
           }
           pos = argEnd;
           continue;
         }
         const rawMatch = input.substring(pseudoStart, nameEnd);
-        parts.push({ type: "pseudo-class", value: pseudoName, raw: rawMatch });
+        const part = { type: "pseudo-class", value: pseudoName, raw: rawMatch };
+        allParts.push(part);
+        currentCompoundParts.push(part);
         hasPseudoClassFlag = true;
-        pseudoClasses.push(pseudoName);
+        pseudoClassNames.push(pseudoName);
         classes++;
         pos = nameEnd;
         continue;
@@ -24979,7 +25048,9 @@ function parseSelectorComplete(raw) {
       if (match) {
         const val = match[1];
         if (!val) break;
-        parts.push({ type: "element", value: val, raw: match[0] });
+        const part = { type: "element", value: val, raw: match[0] };
+        allParts.push(part);
+        currentCompoundParts.push(part);
         elements++;
         pos = ELEMENT_STICKY.lastIndex;
         continue;
@@ -24987,6 +25058,9 @@ function parseSelectorComplete(raw) {
     }
     pos++;
   }
+  if (currentCompoundParts.length > 0) {
+    compounds.push(finalizeCompound(currentCompoundParts, depth));
+  }
   const complexity = buildComplexity(
     combinators,
     hasId,
@@ -24995,16 +25069,157 @@ function parseSelectorComplete(raw) {
     hasPseudoClassFlag,
     hasPseudoElementFlag,
     hasNesting,
-    pseudoClasses,
-    pseudoElements
+    pseudoClassNames,
+    pseudoElementNames
   );
   return {
-    parts,
+    parts: allParts,
+    compounds,
     combinators,
     specificity: [0, ids, classes, elements],
     complexity
   };
 }
+function finalizeCompound(parts, depth) {
+  let tagName = null;
+  let idValue = null;
+  const classes = [];
+  const seenClasses = /* @__PURE__ */ new Set();
+  const attributes = [];
+  const pseudoClasses = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (!part) continue;
+    if (part.type === "element") {
+      tagName = part.value.toLowerCase();
+    } else if (part.type === "id") {
+      idValue = part.value;
+    } else if (part.type === "class") {
+      if (!seenClasses.has(part.value)) {
+        seenClasses.add(part.value);
+        classes.push(part.value);
+      }
+    } else if (part.type === "attribute") {
+      const constraint = parseAttributeConstraintFromRaw(part.value);
+      if (constraint) attributes.push(constraint);
+    } else if (part.type === "pseudo-class") {
+      const parsed = parsePseudoToParsedConstraint(part.value, part.raw, depth);
+      if (parsed) pseudoClasses.push(parsed);
+    }
+  }
+  return { parts, tagName, idValue, classes, attributes, pseudoClasses };
+}
+function parseAttributeConstraintFromRaw(raw) {
+  const trimmed = raw.trim();
+  const constrained = ATTRIBUTE_CONSTRAINT_RE.exec(trimmed);
+  if (constrained) {
+    const operatorToken = constrained[2];
+    if (!operatorToken) return null;
+    const operator = mapAttrOperator(operatorToken);
+    if (operator === null) return null;
+    const value2 = constrained[3] ?? constrained[4] ?? constrained[5] ?? null;
+    if (value2 === null) return null;
+    const nameToken = constrained[1];
+    if (!nameToken) return null;
+    return {
+      name: nameToken.toLowerCase(),
+      operator,
+      value: value2,
+      caseInsensitive: (constrained[6] ?? "").toLowerCase() === "i"
+    };
+  }
+  if (!ATTRIBUTE_EXISTS_RE.test(trimmed)) return null;
+  return { name: trimmed.toLowerCase(), operator: "exists", value: null, caseInsensitive: false };
+}
+function mapAttrOperator(op) {
+  if (op === "=") return "equals";
+  if (op === "~=") return "includes-word";
+  if (op === "|=") return "dash-prefix";
+  if (op === "^=") return "prefix";
+  if (op === "$=") return "suffix";
+  if (op === "*=") return "contains";
+  return null;
+}
+function parsePseudoToParsedConstraint(name, raw, depth) {
+  const lowerName = name.toLowerCase();
+  if (lowerName === "first-child") return { name: lowerName, raw, kind: 1 /* FirstChild */, nthPattern: null, nestedCompounds: null };
+  if (lowerName === "last-child") return { name: lowerName, raw, kind: 2 /* LastChild */, nthPattern: null, nestedCompounds: null };
+  if (lowerName === "only-child") return { name: lowerName, raw, kind: 3 /* OnlyChild */, nthPattern: null, nestedCompounds: null };
+  const parenIdx = raw.indexOf("(");
+  if (parenIdx === -1) {
+    return { name: lowerName, raw, kind: 0 /* Simple */, nthPattern: null, nestedCompounds: null };
+  }
+  const argContent = raw.substring(parenIdx + 1, raw.length - 1);
+  if (lowerName === "nth-child") {
+    const pattern = parseNthPatternFromArg(argContent);
+    return pattern ? { name: lowerName, raw, kind: 4 /* NthChild */, nthPattern: pattern, nestedCompounds: null } : null;
+  }
+  if (lowerName === "nth-last-child") {
+    const pattern = parseNthPatternFromArg(argContent);
+    return pattern ? { name: lowerName, raw, kind: 5 /* NthLastChild */, nthPattern: pattern, nestedCompounds: null } : null;
+  }
+  if (lowerName === "nth-of-type") {
+    const pattern = parseNthPatternFromArg(argContent);
+    return pattern ? { name: lowerName, raw, kind: 6 /* NthOfType */, nthPattern: pattern, nestedCompounds: null } : null;
+  }
+  if (lowerName === "nth-last-of-type") {
+    const pattern = parseNthPatternFromArg(argContent);
+    return pattern ? { name: lowerName, raw, kind: 7 /* NthLastOfType */, nthPattern: pattern, nestedCompounds: null } : null;
+  }
+  if (lowerName === "is" || lowerName === "where") {
+    if (depth >= MAX_PSEUDO_PARSE_DEPTH) return { name: lowerName, raw, kind: 8 /* MatchesAny */, nthPattern: null, nestedCompounds: null };
+    const nested = parseNestedCompoundGroups(argContent, depth + 1);
+    return { name: lowerName, raw, kind: 8 /* MatchesAny */, nthPattern: null, nestedCompounds: nested };
+  }
+  if (lowerName === "not") {
+    if (depth >= MAX_PSEUDO_PARSE_DEPTH) return { name: lowerName, raw, kind: 9 /* NoneOf */, nthPattern: null, nestedCompounds: null };
+    const nested = parseNestedCompoundGroups(argContent, depth + 1);
+    return { name: lowerName, raw, kind: 9 /* NoneOf */, nthPattern: null, nestedCompounds: nested };
+  }
+  return { name: lowerName, raw, kind: 0 /* Simple */, nthPattern: null, nestedCompounds: null };
+}
+function parseNestedCompoundGroups(argContent, depth) {
+  const args = splitPseudoArgs(argContent);
+  const groups = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) continue;
+    const trimmed = arg.trim();
+    if (!trimmed) continue;
+    const result = parseSelectorComplete(trimmed, depth);
+    if (result.compounds.length > 0) {
+      groups.push(result.compounds.slice());
+    }
+  }
+  return groups;
+}
+function parseNthPatternFromArg(raw) {
+  const normalized = raw.trim().toLowerCase().replaceAll(" ", "");
+  if (normalized.length === 0) return null;
+  if (normalized === "odd") return { step: 2, offset: 1 };
+  if (normalized === "even") return { step: 2, offset: 0 };
+  const nIndex = normalized.indexOf("n");
+  if (nIndex === -1) {
+    const value2 = Number.parseInt(normalized, 10);
+    if (Number.isNaN(value2)) return null;
+    return { step: 0, offset: value2 };
+  }
+  const stepPart = normalized.slice(0, nIndex);
+  const offsetPart = normalized.slice(nIndex + 1);
+  let step;
+  if (stepPart.length === 0 || stepPart === "+") step = 1;
+  else if (stepPart === "-") step = -1;
+  else {
+    step = Number.parseInt(stepPart, 10);
+    if (Number.isNaN(step)) return null;
+  }
+  let offset = 0;
+  if (offsetPart.length > 0) {
+    offset = Number.parseInt(offsetPart, 10);
+    if (Number.isNaN(offset)) return null;
+  }
+  return { step, offset };
+}
 function splitPseudoArgs(content) {
   const result = [];
   let start = 0;
@@ -25353,8 +25568,6 @@ function extractVarReferences(value2) {
 
 // src/css/phases/ast.ts
 var CSS_IDENT = /^[-_a-zA-Z][-_a-zA-Z0-9]*$/;
-var ATTRIBUTE_EXISTS_RE = /^[-_a-zA-Z][-_a-zA-Z0-9]*$/;
-var ATTRIBUTE_CONSTRAINT_RE = /^([-_a-zA-Z][-_a-zA-Z0-9]*)\s*(=|~=|\|=|\^=|\$=|\*=)\s*(?:"([^"]*)"|'([^']*)'|([^\s"']+))(?:\s+([iIsS]))?$/;
 var ROOT_CONTEXT = {
   parentRule: null,
   parentAtRule: null,
@@ -25821,142 +26034,6 @@ function getRuleBlockOffsets(file, startOffset, endOffset) {
     blockEndOffset: close
   };
 }
-function extractSubjectCompound(raw) {
-  const len = raw.length;
-  if (len === 0) return "";
-  let end = len - 1;
-  while (end >= 0 && isWhitespace(raw.charCodeAt(end))) end--;
-  if (end < 0) return "";
-  let parenDepth = 0;
-  let bracketDepth = 0;
-  for (let i = end; i >= 0; i--) {
-    const code = raw.charCodeAt(i);
-    if (code === CHAR_CLOSE_PAREN) {
-      parenDepth++;
-      continue;
-    }
-    if (code === CHAR_OPEN_PAREN) {
-      if (parenDepth > 0) parenDepth--;
-      continue;
-    }
-    if (code === CHAR_CLOSE_BRACKET) {
-      bracketDepth++;
-      continue;
-    }
-    if (code === CHAR_OPEN_BRACKET) {
-      if (bracketDepth > 0) bracketDepth--;
-      continue;
-    }
-    if (parenDepth > 0 || bracketDepth > 0) continue;
-    if (code === CHAR_GT || code === CHAR_PLUS || code === CHAR_TILDE) {
-      return raw.slice(i + 1, end + 1).trim();
-    }
-    if (!isWhitespace(code)) continue;
-    return raw.slice(i + 1, end + 1).trim();
-  }
-  return raw.slice(0, end + 1).trim();
-}
-function parseAnchorAttributes(parts) {
-  const out = [];
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
-    if (!part) continue;
-    if (part.type !== "attribute") continue;
-    const trimmed = part.value.trim();
-    const constrained = ATTRIBUTE_CONSTRAINT_RE.exec(trimmed);
-    if (constrained) {
-      const opToken = constrained[2];
-      if (!opToken) continue;
-      const operator = mapAttributeOperatorFromToken(opToken);
-      if (operator === null) continue;
-      const value2 = constrained[3] ?? constrained[4] ?? constrained[5] ?? null;
-      if (value2 === null) continue;
-      const attrName = constrained[1];
-      if (!attrName) continue;
-      out.push({
-        name: attrName.toLowerCase(),
-        operator,
-        value: value2,
-        caseInsensitive: (constrained[6] ?? "").toLowerCase() === "i"
-      });
-      continue;
-    }
-    if (!ATTRIBUTE_EXISTS_RE.test(trimmed)) continue;
-    out.push({
-      name: trimmed.toLowerCase(),
-      operator: "exists",
-      value: null,
-      caseInsensitive: false
-    });
-  }
-  return out;
-}
-function mapAttributeOperatorFromToken(operator) {
-  if (operator === "=") return "equals";
-  if (operator === "~=") return "includes-word";
-  if (operator === "|=") return "dash-prefix";
-  if (operator === "^=") return "prefix";
-  if (operator === "$=") return "suffix";
-  if (operator === "*=") return "contains";
-  return null;
-}
-function buildSelectorAnchor(raw, parts, combinators) {
-  const subjectCompound = extractSubjectCompound(raw);
-  const subjectParts = parseSelector(subjectCompound);
-  let subjectTag = null;
-  const classes = [];
-  const seenClasses = /* @__PURE__ */ new Set();
-  for (let i = 0; i < subjectParts.length; i++) {
-    const part = subjectParts[i];
-    if (!part) continue;
-    if (part.type === "element") {
-      subjectTag = part.value.toLowerCase();
-      continue;
-    }
-    if (part.type !== "class") continue;
-    const cls = part.value;
-    if (seenClasses.has(cls)) continue;
-    seenClasses.add(cls);
-    classes.push(cls);
-  }
-  const attributes = parseAnchorAttributes(subjectParts);
-  const includesDescendantCombinator = combinators.includes("descendant");
-  let includesPseudoSelector = false;
-  let includesNesting = false;
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
-    if (!part) continue;
-    if (part.type === "pseudo-class" || part.type === "pseudo-element") {
-      includesPseudoSelector = true;
-      continue;
-    }
-    if (part.type === "nesting") includesNesting = true;
-  }
-  let hasCheckboxAttribute = false;
-  for (let i = 0; i < attributes.length; i++) {
-    const a = attributes[i];
-    if (!a) continue;
-    if (a.name !== "type") continue;
-    if (a.operator !== "equals") continue;
-    if (a.value === null) continue;
-    const normalized = a.caseInsensitive ? a.value.toLowerCase() : a.value;
-    if (normalized !== "checkbox") continue;
-    hasCheckboxAttribute = true;
-    break;
-  }
-  const targetsCheckbox = (subjectTag === "input" || subjectTag === null) && hasCheckboxAttribute;
-  const targetsTableCell = subjectTag === "td" || subjectTag === "th";
-  return {
-    subjectTag,
-    classes,
-    attributes,
-    includesDescendantCombinator,
-    includesPseudoSelector,
-    dynamic: includesPseudoSelector || includesNesting,
-    targetsCheckbox,
-    targetsTableCell
-  };
-}
 function createRuleEntity(graph, node, file, context) {
   const { parentRule, parentAtRule, containingMedia, containingLayer, depth } = context;
   const id = graph.nextRuleId();
@@ -26003,9 +26080,55 @@ function createRuleEntity(graph, node, file, context) {
 }
 function createSelectorEntity(graph, raw, rule) {
   const id = graph.nextSelectorId();
-  const { parts, specificity, complexity } = parseSelectorComplete(raw);
+  const { parts, compounds, combinators, specificity, complexity } = parseSelectorComplete(raw);
   const specificityScore = specificityToScore(specificity);
-  const anchor = buildSelectorAnchor(raw, parts, complexity.combinators);
+  const kinds = rule.elementKinds;
+  for (let k = 0; k < parts.length; k++) {
+    const part = parts[k];
+    if (part) classifyPart(part, kinds);
+  }
+  const subject = compounds.length > 0 ? compounds[compounds.length - 1] : null;
+  let includesPseudoSelector = false;
+  let includesNesting = false;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (!part) continue;
+    if (part.type === "pseudo-class" || part.type === "pseudo-element") {
+      includesPseudoSelector = true;
+      continue;
+    }
+    if (part.type === "nesting") includesNesting = true;
+  }
+  const subjectTag = subject?.tagName ?? null;
+  const subjectIdValue = subject?.idValue ?? null;
+  const subjectClasses = subject?.classes ?? [];
+  const subjectAttributes = subject?.attributes ?? [];
+  const includesDescendantCombinator = combinators.includes("descendant");
+  let hasCheckboxAttribute = false;
+  for (let i = 0; i < subjectAttributes.length; i++) {
+    const a = subjectAttributes[i];
+    if (!a) continue;
+    if (a.name !== "type") continue;
+    if (a.operator !== "equals") continue;
+    if (a.value === null) continue;
+    const normalized = a.caseInsensitive ? a.value.toLowerCase() : a.value;
+    if (normalized !== "checkbox") continue;
+    hasCheckboxAttribute = true;
+    break;
+  }
+  const targetsCheckbox = (subjectTag === "input" || subjectTag === null) && hasCheckboxAttribute;
+  const targetsTableCell = subjectTag === "td" || subjectTag === "th";
+  const anchor = {
+    subjectTag,
+    idValue: subjectIdValue,
+    classes: subjectClasses,
+    attributes: subjectAttributes,
+    includesDescendantCombinator,
+    includesPseudoSelector,
+    dynamic: includesPseudoSelector || includesNesting,
+    targetsCheckbox,
+    targetsTableCell
+  };
   return {
     id,
     raw,
@@ -26013,6 +26136,8 @@ function createSelectorEntity(graph, raw, rule) {
     specificity,
     specificityScore,
     complexity,
+    compounds,
+    combinators,
     parts: parts.length > 0 ? parts : [],
     anchor,
     overrides: [],
@@ -27673,57 +27798,31 @@ var mediaQueryOverlapConflict = defineCSSRule({
 var messages101 = {
   descendingSpecificity: "Lower-specificity selector `{{laterSelector}}` appears after `{{earlierSelector}}` for `{{property}}`, creating brittle cascade behavior."
 };
-var UNSUPPORTED_TYPES = /* @__PURE__ */ new Set(["attribute", "pseudo-class", "pseudo-element", "universal", "nesting"]);
 function extractCompounds(selector) {
-  const parts = selector.parts;
-  if (parts.length === 0) return null;
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
-    if (!part) continue;
-    if (UNSUPPORTED_TYPES.has(part.type)) return null;
+  const selectorCompounds = selector.compounds;
+  if (selectorCompounds.length === 0) return null;
+  for (let i = 0; i < selectorCompounds.length; i++) {
+    const sc = selectorCompounds[i];
+    if (!sc) continue;
+    const parts = sc.parts;
+    for (let j = 0; j < parts.length; j++) {
+      const part = parts[j];
+      if (!part) continue;
+      const t = part.type;
+      if (t === "attribute" || t === "pseudo-class" || t === "pseudo-element" || t === "universal" || t === "nesting") return null;
+    }
   }
-  return splitIntoCompounds(selector);
-}
-function splitIntoCompounds(selector) {
-  const raw = selector.raw;
-  const combinators = selector.complexity.combinators;
-  const segments = splitRawByCombinators(raw);
-  if (!segments || segments.length !== combinators.length + 1) return null;
   const compounds = [];
-  for (let i = 0; i < segments.length; i++) {
-    const seg = segments[i];
-    if (!seg) continue;
-    const compound = parseCompoundFromParts(seg);
-    if (!compound) return null;
-    compounds.push(compound);
+  for (let i = 0; i < selectorCompounds.length; i++) {
+    const sc = selectorCompounds[i];
+    if (!sc) continue;
+    const ids = [];
+    if (sc.idValue !== null) ids.push(sc.idValue);
+    if (!sc.tagName && sc.classes.length === 0 && ids.length === 0) return null;
+    compounds.push({ tag: sc.tagName, classes: sc.classes, ids });
   }
   return compounds;
 }
-var COMBINATOR_SPLIT = /\s*[>+~]\s*|\s+/;
-function splitRawByCombinators(raw) {
-  const trimmed = raw.trim();
-  if (trimmed.length === 0) return null;
-  const segments = trimmed.split(COMBINATOR_SPLIT).filter((s) => s.length > 0);
-  return segments.length > 0 ? segments : null;
-}
-var COMPOUND_TOKEN = /([.#]?)([_a-zA-Z][_a-zA-Z0-9-]*)/g;
-function parseCompoundFromParts(segment) {
-  let tag = null;
-  const classes = [];
-  const ids = [];
-  COMPOUND_TOKEN.lastIndex = 0;
-  let match;
-  while ((match = COMPOUND_TOKEN.exec(segment)) !== null) {
-    const prefix = match[1];
-    const value2 = match[2];
-    if (!value2) continue;
-    if (prefix === ".") classes.push(value2);
-    else if (prefix === "#") ids.push(value2);
-    else tag = value2;
-  }
-  if (!tag && classes.length === 0 && ids.length === 0) return null;
-  return { tag, classes, ids };
-}
 function hasToken(list, token) {
   for (let i = 0; i < list.length; i++) {
     if (list[i] === token) return true;
@@ -27765,8 +27864,8 @@ function isProvableDescendingPair(earlier, later) {
   if (!earlierCompounds) return false;
   const laterCompounds = extractCompounds(later);
   if (!laterCompounds) return false;
-  const earlierCombinators = earlier.complexity.combinators;
-  const laterCombinators = later.complexity.combinators;
+  const earlierCombinators = earlier.combinators;
+  const laterCombinators = later.combinators;
   if (earlierCompounds.length !== laterCompounds.length) return false;
   if (earlierCombinators.length !== laterCombinators.length) return false;
   for (let i = 0; i < earlierCombinators.length; i++) {
@@ -30069,6 +30168,8 @@ var layoutSignalNames = [
   "min-width",
   "min-block-size",
   "min-height",
+  "max-width",
+  "max-height",
   "aspect-ratio",
   "vertical-align",
   "display",
@@ -30087,6 +30188,7 @@ var layoutSignalNames = [
   "place-items",
   "place-self",
   "flex-direction",
+  "flex-basis",
   "grid-auto-flow",
   "appearance",
   "box-sizing",
@@ -30174,80 +30276,6 @@ function parseSignedPxValue(raw) {
   return parsePxValue(trimmed);
 }
 
-// src/cross-file/layout/shorthand-expansion.ts
-var QUAD_EXPANSIONS = /* @__PURE__ */ new Map([
-  ["padding", ["padding-top", "padding-right", "padding-bottom", "padding-left"]],
-  ["border-width", ["border-top-width", "border-right-width", "border-bottom-width", "border-left-width"]],
-  ["margin", ["margin-top", "margin-right", "margin-bottom", "margin-left"]],
-  ["inset", ["top", "right", "bottom", "left"]]
-]);
-var BLOCK_EXPANSIONS = /* @__PURE__ */ new Map([
-  ["margin-block", ["margin-top", "margin-bottom"]],
-  ["padding-block", ["padding-top", "padding-bottom"]],
-  ["inset-block", ["inset-block-start", "inset-block-end"]]
-]);
-function expandShorthand(property, value2) {
-  const quadTarget = QUAD_EXPANSIONS.get(property);
-  if (quadTarget !== void 0) {
-    const parsed = parseQuadShorthand(value2);
-    if (parsed === null) return null;
-    return [
-      { name: quadTarget[0], value: parsed.top },
-      { name: quadTarget[1], value: parsed.right },
-      { name: quadTarget[2], value: parsed.bottom },
-      { name: quadTarget[3], value: parsed.left }
-    ];
-  }
-  const blockTarget = BLOCK_EXPANSIONS.get(property);
-  if (blockTarget !== void 0) {
-    const parsed = parseBlockShorthand(value2);
-    if (parsed === null) return null;
-    return [
-      { name: blockTarget[0], value: parsed.start },
-      { name: blockTarget[1], value: parsed.end }
-    ];
-  }
-  if (property === "flex-flow") {
-    return expandFlexFlow(value2);
-  }
-  return void 0;
-}
-var FLEX_DIRECTION_VALUES = /* @__PURE__ */ new Set(["row", "row-reverse", "column", "column-reverse"]);
-function expandFlexFlow(value2) {
-  const tokens = splitWhitespaceTokens(value2.trim().toLowerCase());
-  if (tokens.length === 0) return null;
-  if (tokens.length > 2) return null;
-  let direction = null;
-  let wrap = null;
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i];
-    if (!token) continue;
-    if (FLEX_DIRECTION_VALUES.has(token)) {
-      if (direction !== null) return null;
-      direction = token;
-    } else {
-      if (wrap !== null) return null;
-      wrap = token;
-    }
-  }
-  const out = [];
-  if (direction !== null) {
-    out.push({ name: "flex-direction", value: direction });
-  }
-  if (wrap !== null) {
-    out.push({ name: "flex-wrap", value: wrap });
-  }
-  return out.length > 0 ? out : null;
-}
-function getShorthandLonghandNames(property) {
-  const quad = QUAD_EXPANSIONS.get(property);
-  if (quad !== void 0) return [...quad];
-  const block = BLOCK_EXPANSIONS.get(property);
-  if (block !== void 0) return [...block];
-  if (property === "flex-flow") return ["flex-direction", "flex-wrap"];
-  return null;
-}
-
 // src/cross-file/layout/util.ts
 var CONTROL_ELEMENT_TAGS = /* @__PURE__ */ new Set([
   "input",
@@ -30352,6 +30380,7 @@ var MONITORED_SHORTHAND_SET = /* @__PURE__ */ new Set([
   "border-width",
   "margin-block",
   "padding-block",
+  "padding-inline",
   "inset-block",
   "flex-flow"
 ]);
@@ -30364,6 +30393,9 @@ var LENGTH_SIGNAL_SET = /* @__PURE__ */ new Set([
   "min-width",
   "min-block-size",
   "min-height",
+  "max-width",
+  "max-height",
+  "flex-basis",
   "top",
   "bottom",
   "margin-top",
@@ -30417,11 +30449,11 @@ function isMonitoredSignal(property) {
 }
 function isControlTag(tag) {
   if (tag === null) return false;
-  return CONTROL_ELEMENT_TAGS.has(tag.toLowerCase());
+  return CONTROL_ELEMENT_TAGS.has(tag);
 }
 function isReplacedTag(tag) {
   if (tag === null) return false;
-  return REPLACED_ELEMENT_TAGS.has(tag.toLowerCase());
+  return REPLACED_ELEMENT_TAGS.has(tag);
 }
 function normalizeSignalMapWithCounts(values) {
   const out = /* @__PURE__ */ new Map();
@@ -30436,16 +30468,12 @@ function normalizeSignalMapWithCounts(values) {
       null
     );
     out.set("font-size", parsedFontSize);
-    if (parsedFontSize.kind === "known" && parsedFontSize.guard.kind === 0 /* Unconditional */) {
+    if (parsedFontSize.kind === 0 /* Known */ && parsedFontSize.guard.kind === 0 /* Unconditional */) {
       fontSizePx = parsedFontSize.px;
     }
   }
   for (const [property, declaration] of values) {
     if (property === "font-size") continue;
-    if (MONITORED_SHORTHAND_SET.has(property)) {
-      applyExpandedShorthand(out, property, declaration, fontSizePx);
-      continue;
-    }
     const name = toMonitoredSignalName(property);
     if (!name) continue;
     const normalized = normalizeSignal(
@@ -30465,7 +30493,7 @@ function normalizeSignalMapWithCounts(values) {
       conditionalSignalCount++;
       continue;
     }
-    if (value2.kind === "known") {
+    if (value2.kind === 0 /* Known */) {
       knownSignalCount++;
       continue;
     }
@@ -30478,30 +30506,6 @@ function normalizeSignalMapWithCounts(values) {
     conditionalSignalCount
   };
 }
-function applyExpandedShorthand(out, property, declaration, fontSizePx) {
-  const expanded = expandShorthand(property, declaration.value);
-  if (expanded === null) {
-    const reason = `${property} value is not statically parseable`;
-    const longhandNames = getShorthandLonghandNames(property);
-    if (longhandNames === null) return;
-    for (let i = 0; i < longhandNames.length; i++) {
-      const longhand = longhandNames[i];
-      if (!longhand) continue;
-      const name = MONITORED_SIGNAL_NAME_MAP.get(longhand);
-      if (name === void 0) continue;
-      out.set(name, createUnknown(name, declaration.source, declaration.guardProvenance, reason));
-    }
-    return;
-  }
-  if (expanded === void 0) return;
-  for (let i = 0; i < expanded.length; i++) {
-    const entry = expanded[i];
-    if (!entry) continue;
-    const name = MONITORED_SIGNAL_NAME_MAP.get(entry.name);
-    if (name === void 0) continue;
-    out.set(name, normalizeSignal(name, entry.value, declaration.source, declaration.guardProvenance, fontSizePx));
-  }
-}
 function toMonitoredSignalName(property) {
   return MONITORED_SIGNAL_NAME_MAP.get(property) ?? null;
 }
@@ -30542,13 +30546,13 @@ function parseAspectRatio(name, raw, source, guard) {
     if (!Number.isFinite(left) || !Number.isFinite(right) || left <= 0 || right <= 0) {
       return createUnknown(name, source, guard, "aspect-ratio ratio is invalid");
     }
-    return createKnown(name, raw, source, guard, null, 1 /* Unitless */, "exact");
+    return createKnown(name, trimmed, source, guard, null, 1 /* Unitless */, 0 /* Exact */);
   }
   const ratio = Number(trimmed);
   if (!Number.isFinite(ratio) || ratio <= 0) {
     return createUnknown(name, source, guard, "aspect-ratio is not statically parseable");
   }
-  return createKnown(name, raw, source, guard, null, 1 /* Unitless */, "exact");
+  return createKnown(name, trimmed, source, guard, null, 1 /* Unitless */, 0 /* Exact */);
 }
 function parseContainIntrinsicSize(name, raw, source, guard) {
   const trimmed = raw.trim().toLowerCase();
@@ -30566,18 +30570,19 @@ function parseContainIntrinsicSize(name, raw, source, guard) {
     const part = parts[i];
     if (!part) continue;
     const px = parseSignedPxValue(part);
-    if (px !== null) return createKnown(name, raw, source, guard, px, 0 /* Px */, "exact");
+    if (px !== null) return createKnown(name, trimmed, source, guard, px, 0 /* Px */, 0 /* Exact */);
   }
   return createUnknown(name, source, guard, "contain-intrinsic-size is not statically parseable in px");
 }
 function parseLineHeight(name, raw, source, guard, fontSizePx) {
+  const normalized = raw.trim().toLowerCase();
   const unitless = parseUnitlessValue(raw);
   if (unitless !== null) {
     const base = fontSizePx === null ? 16 : fontSizePx;
-    return createKnown(name, raw, source, guard, unitless * base, 1 /* Unitless */, "estimated");
+    return createKnown(name, normalized, source, guard, unitless * base, 1 /* Unitless */, 1 /* Estimated */);
   }
   const px = parseSignedPxValue(raw);
-  if (px !== null) return createKnown(name, raw, source, guard, px, 0 /* Px */, "exact");
+  if (px !== null) return createKnown(name, normalized, source, guard, px, 0 /* Px */, 0 /* Exact */);
   return createUnknown(name, source, guard, "line-height is not statically parseable");
 }
 var DIMENSION_KEYWORD_SET = /* @__PURE__ */ new Set([
@@ -30586,16 +30591,21 @@ var DIMENSION_KEYWORD_SET = /* @__PURE__ */ new Set([
   "fit-content",
   "min-content",
   "max-content",
-  "stretch"
+  "stretch",
+  "inherit",
+  "initial",
+  "unset",
+  "revert",
+  "revert-layer"
 ]);
 function parseLength(name, raw, source, guard) {
   const px = parseSignedPxValue(raw);
+  const normalized = raw.trim().toLowerCase();
   if (px !== null) {
-    return createKnown(name, raw, source, guard, px, 0 /* Px */, "exact");
+    return createKnown(name, normalized, source, guard, px, 0 /* Px */, 0 /* Exact */);
   }
-  const normalized = raw.trim().toLowerCase();
   if (DIMENSION_KEYWORD_SET.has(normalized) || normalized.startsWith("fit-content(")) {
-    return createKnown(name, raw, source, guard, null, 2 /* Keyword */, "exact");
+    return createKnown(name, normalized, source, guard, null, 2 /* Keyword */, 0 /* Exact */);
   }
   return createUnknown(name, source, guard, "length is not statically parseable in px");
 }
@@ -30607,7 +30617,7 @@ function parseKeyword(name, raw, source, guard) {
   if (hasDynamicExpression(normalized)) {
     return createUnknown(name, source, guard, "keyword uses runtime-dependent function");
   }
-  return createKnown(name, raw, source, guard, null, 2 /* Keyword */, "exact");
+  return createKnown(name, normalized, source, guard, null, 2 /* Keyword */, 0 /* Exact */);
 }
 function parseTransform(name, raw, source, guard) {
   const normalized = raw.trim().toLowerCase();
@@ -30618,7 +30628,7 @@ function parseTransform(name, raw, source, guard) {
     return createUnknown(name, source, guard, "transform uses runtime-dependent function");
   }
   const y = extractTransformYPx(normalized);
-  if (y !== null) return createKnown(name, raw, source, guard, y, 0 /* Px */, "exact");
+  if (y !== null) return createKnown(name, normalized, source, guard, y, 0 /* Px */, 0 /* Exact */);
   return createUnknown(name, source, guard, "transform has non-translational or non-px functions");
 }
 function parseTranslateProperty(name, raw, source, guard) {
@@ -30630,24 +30640,20 @@ function parseTranslateProperty(name, raw, source, guard) {
     return createUnknown(name, source, guard, "translate uses runtime-dependent function");
   }
   const y = extractTranslatePropertyYPx(trimmed);
-  if (y !== null) return createKnown(name, raw, source, guard, y, 0 /* Px */, "exact");
+  if (y !== null) return createKnown(name, trimmed, source, guard, y, 0 /* Px */, 0 /* Exact */);
   return createUnknown(name, source, guard, "translate property vertical component is not px");
 }
 function hasDynamicExpression(raw) {
   if (raw.includes("var(")) return true;
-  if (raw.includes("calc(")) return true;
   if (raw.includes("env(")) return true;
   if (raw.includes("attr(")) return true;
-  if (raw.includes("min(")) return true;
-  if (raw.includes("max(")) return true;
-  if (raw.includes("clamp(")) return true;
   return false;
 }
-function createKnown(name, raw, source, guard, px, unit, quality) {
+function createKnown(name, normalized, source, guard, px, unit, quality) {
   return {
-    kind: "known",
+    kind: 0 /* Known */,
     name,
-    normalized: raw.trim().toLowerCase(),
+    normalized,
     source,
     guard,
     unit,
@@ -30657,7 +30663,7 @@ function createKnown(name, raw, source, guard, px, unit, quality) {
 }
 function createUnknown(name, source, guard, reason) {
   return {
-    kind: "unknown",
+    kind: 1 /* Unknown */,
     name,
     source,
     guard,
@@ -30673,49 +30679,23 @@ var INHERITED_SIGNAL_NAMES = [
   "direction"
 ];
 function collectSignalSnapshot(context, node) {
-  const existing = context.layout.snapshotByElementNode.get(node);
-  if (existing) {
+  const record = context.layout.records.get(node);
+  if (record) {
     context.layout.perf.signalSnapshotCacheHits++;
-    return existing;
-  }
-  throw new Error(`missing precomputed layout snapshot for ${node.key}`);
-}
-function buildSignalSnapshotIndex(elements, cascadeByElementNode, perf) {
-  const snapshotByElementNode = /* @__PURE__ */ new WeakMap();
-  for (let i = 0; i < elements.length; i++) {
-    const element = elements[i];
-    if (!element) continue;
-    buildSnapshotForNode(element, cascadeByElementNode, snapshotByElementNode, perf);
+    return record.snapshot;
   }
-  return snapshotByElementNode;
+  throw new Error(`missing precomputed layout record for ${node.key}`);
 }
-function buildSnapshotForNode(node, cascadeByElementNode, snapshotByElementNode, perf) {
-  const existing = snapshotByElementNode.get(node);
-  if (existing) {
-    perf.signalSnapshotCacheHits++;
-    return existing;
-  }
-  const raw = cascadeByElementNode.get(node);
-  if (!raw) {
-    throw new Error(`missing cascade map for ${node.key}`);
-  }
-  const normalized = normalizeSignalMapWithCounts(raw);
-  const parent = node.parentElementNode;
-  const parentSnapshot = parent ? buildSnapshotForNode(parent, cascadeByElementNode, snapshotByElementNode, perf) : null;
+function buildSnapshotFromCascade(node, cascade, parentSnapshot) {
+  const normalized = normalizeSignalMapWithCounts(cascade);
   const inherited = inheritSignalsFromParent(parentSnapshot, normalized.signals);
-  const knownSignalCount = normalized.knownSignalCount + inherited.knownDelta;
-  const unknownSignalCount = normalized.unknownSignalCount + inherited.unknownDelta;
-  const conditionalSignalCount = normalized.conditionalSignalCount + inherited.conditionalDelta;
-  const snapshot = {
+  return {
     node,
     signals: inherited.signals,
-    knownSignalCount,
-    unknownSignalCount,
-    conditionalSignalCount
+    knownSignalCount: normalized.knownSignalCount + inherited.knownDelta,
+    unknownSignalCount: normalized.unknownSignalCount + inherited.unknownDelta,
+    conditionalSignalCount: normalized.conditionalSignalCount + inherited.conditionalDelta
   };
-  snapshotByElementNode.set(node, snapshot);
-  perf.signalSnapshotsBuilt++;
-  return snapshot;
 }
 function inheritSignalsFromParent(parentSnapshot, local) {
   if (!parentSnapshot) {
@@ -30742,7 +30722,7 @@ function inheritSignalsFromParent(parentSnapshot, local) {
       conditionalDelta++;
       continue;
     }
-    if (inheritedValue.kind === "known") {
+    if (inheritedValue.kind === 0 /* Known */) {
       knownDelta++;
       continue;
     }
@@ -30775,10 +30755,10 @@ var EMPTY_STATEFUL_BASE_VALUE_INDEX = /* @__PURE__ */ new Map();
 var EMPTY_LAYOUT_RESERVED_SPACE_FACT = Object.freeze({
   hasReservedSpace: false,
   reasons: EMPTY_RESERVED_SPACE_REASONS,
-  hasUsableInlineDimension: false,
-  hasUsableBlockDimension: false,
   hasContainIntrinsicSize: false,
-  hasUsableAspectRatio: false
+  hasUsableAspectRatio: false,
+  hasDeclaredInlineDimension: false,
+  hasDeclaredBlockDimension: false
 });
 var EMPTY_LAYOUT_SCROLL_CONTAINER_FACT = Object.freeze({
   isScrollContainer: false,
@@ -30811,12 +30791,12 @@ var EMPTY_LAYOUT_CONDITIONAL_DELTA_FACT = Object.freeze({
 function readKnownSignalWithGuard(snapshot, name) {
   const value2 = snapshot.signals.get(name);
   if (!value2) return null;
-  if (value2.kind !== "known") return null;
+  if (value2.kind !== 0 /* Known */) return null;
   return value2;
 }
 function toEvidenceKind(value2) {
   if (value2.guard.kind === 1 /* Conditional */) return 2 /* Conditional */;
-  if (value2.quality === "estimated") return 1 /* Interval */;
+  if (value2.quality === 1 /* Estimated */) return 1 /* Interval */;
   return 0 /* Exact */;
 }
 function readNormalizedSignalEvidence(snapshot, name) {
@@ -30827,7 +30807,7 @@ function readNormalizedSignalEvidence(snapshot, name) {
       kind: 3 /* Unknown */
     };
   }
-  if (value2.kind !== "known") {
+  if (value2.kind !== 0 /* Known */) {
     if (value2.guard.kind === 1 /* Conditional */) {
       return {
         value: null,
@@ -30881,19 +30861,19 @@ function hasEffectivePosition(snapshot) {
   return position !== "static";
 }
 function readReservedSpaceFact(graph, node) {
-  return graph.reservedSpaceFactsByNode.get(node) ?? EMPTY_LAYOUT_RESERVED_SPACE_FACT;
+  return graph.records.get(node)?.reservedSpace ?? EMPTY_LAYOUT_RESERVED_SPACE_FACT;
 }
 function readScrollContainerFact(graph, node) {
-  return graph.scrollContainerFactsByNode.get(node) ?? EMPTY_LAYOUT_SCROLL_CONTAINER_FACT;
+  return graph.records.get(node)?.scrollContainer ?? EMPTY_LAYOUT_SCROLL_CONTAINER_FACT;
 }
 function readFlowParticipationFact(graph, node) {
-  return graph.flowParticipationFactsByNode.get(node) ?? EMPTY_LAYOUT_FLOW_PARTICIPATION_FACT;
+  return graph.records.get(node)?.flowParticipation ?? EMPTY_LAYOUT_FLOW_PARTICIPATION_FACT;
 }
 function readContainingBlockFact(graph, node) {
-  return graph.containingBlockFactsByNode.get(node) ?? EMPTY_LAYOUT_CONTAINING_BLOCK_FACT;
+  return graph.records.get(node)?.containingBlock ?? EMPTY_LAYOUT_CONTAINING_BLOCK_FACT;
 }
 function readConditionalSignalDeltaFact(graph, node, name) {
-  const byProperty = graph.conditionalSignalDeltaFactsByNode.get(node);
+  const byProperty = graph.records.get(node)?.conditionalDelta;
   if (!byProperty) return EMPTY_LAYOUT_CONDITIONAL_DELTA_FACT;
   return byProperty.get(name) ?? EMPTY_LAYOUT_CONDITIONAL_DELTA_FACT;
 }
@@ -30921,7 +30901,7 @@ function readScrollContainerElements(graph) {
   return graph.scrollContainerElements;
 }
 function readBaselineOffsetFacts(graph, node) {
-  return graph.baselineOffsetFactsByNode.get(node) ?? EMPTY_BASELINE_FACTS;
+  return graph.records.get(node)?.baselineOffsets ?? EMPTY_BASELINE_FACTS;
 }
 function readElementRef(graph, node) {
   return readElementRefById(graph, node.solidFile, node.elementId);
@@ -31775,23 +31755,44 @@ function collectCSSScopeBySolidFile(solids, css, moduleResolver) {
       if (!imp) continue;
       if (imp.isTypeOnly) continue;
       const resolvedCssPath = resolver.resolveCss(solid.file, imp.source);
-      if (resolvedCssPath === null) continue;
-      const transitiveScope = getOrCollectTransitiveScope(
-        resolvedCssPath,
-        resolver,
-        cssFilesByNormalizedPath,
-        transitiveScopeByEntryPath
-      );
-      for (let k = 0; k < transitiveScope.length; k++) {
-        const ts137 = transitiveScope[k];
-        if (!ts137) continue;
-        scope.add(ts137);
+      if (resolvedCssPath !== null) {
+        const transitiveScope = getOrCollectTransitiveScope(
+          resolvedCssPath,
+          resolver,
+          cssFilesByNormalizedPath,
+          transitiveScopeByEntryPath
+        );
+        for (let k = 0; k < transitiveScope.length; k++) {
+          const ts137 = transitiveScope[k];
+          if (!ts137) continue;
+          scope.add(ts137);
+        }
+        if (imp.specifiers.length === 0) {
+          for (let k = 0; k < transitiveScope.length; k++) {
+            const ts137 = transitiveScope[k];
+            if (!ts137) continue;
+            globalSideEffectScope.add(ts137);
+          }
+        }
       }
-      if (imp.specifiers.length !== 0) continue;
-      for (let k = 0; k < transitiveScope.length; k++) {
-        const ts137 = transitiveScope[k];
-        if (!ts137) continue;
-        globalSideEffectScope.add(ts137);
+      if (imp.specifiers.length !== 0) {
+        const resolvedSolidPath = resolver.resolveSolid(solid.file, imp.source);
+        if (resolvedSolidPath !== null) {
+          const componentCssPath = resolveColocatedCss(resolvedSolidPath, cssFilesByNormalizedPath);
+          if (componentCssPath !== null) {
+            const componentCssScope = getOrCollectTransitiveScope(
+              componentCssPath,
+              resolver,
+              cssFilesByNormalizedPath,
+              transitiveScopeByEntryPath
+            );
+            for (let k = 0; k < componentCssScope.length; k++) {
+              const cs = componentCssScope[k];
+              if (!cs) continue;
+              scope.add(cs);
+            }
+          }
+        }
       }
     }
     localScopeBySolidFile.set(solid.file, scope);
@@ -32030,6 +32031,7 @@ function createSolidInput(filePath, program, logger) {
 
 // src/cross-file/layout/component-host.ts
 var EMPTY_ATTRIBUTES = /* @__PURE__ */ new Map();
+var EMPTY_PROP_BINDINGS = /* @__PURE__ */ new Map();
 var TRANSPARENT_SOLID_PRIMITIVES = /* @__PURE__ */ new Set([
   "For",
   "Index",
@@ -32098,9 +32100,10 @@ function createLayoutComponentHostResolver(solids, moduleResolver, logger = noop
     const staticAttributes = innerHost !== null ? mergeStaticAttributes(entry.staticAttributes, innerHost.descriptor.staticAttributes) : entry.staticAttributes;
     const staticClassTokens = innerHost !== null ? mergeStaticClassTokens(entry.staticClassTokens, innerHost.descriptor.staticClassTokens) : entry.staticClassTokens;
     const forwardsChildren = entry.forwardsChildren || innerHost !== null && innerHost.descriptor.forwardsChildren;
+    const attributePropBindings = innerHost !== null ? mergePropBindings(entry.attributePropBindings, innerHost.descriptor.attributePropBindings) : entry.attributePropBindings;
     if (logger.isLevelEnabled(Level.Trace)) logger.trace(`[component-host]   resolved: tagName=${tagName}, attrs=[${[...staticAttributes.keys()]}], classes=[${staticClassTokens}]`);
     return {
-      descriptor: { tagName, staticAttributes, staticClassTokens, forwardsChildren },
+      descriptor: { tagName, staticAttributes, staticClassTokens, forwardsChildren, attributePropBindings },
       hostElementRef: innerHost?.hostElementRef ?? null
     };
   }
@@ -32527,7 +32530,8 @@ function resolveHostEntryFromJSXElement(graph, node) {
         tagName: element.tagName,
         staticAttributes: collectStaticAttributes(element),
         staticClassTokens: getStaticClassTokensForElementEntity(graph, element),
-        forwardsChildren: detectChildrenForwarding(element)
+        forwardsChildren: detectChildrenForwarding(element),
+        attributePropBindings: collectAttributePropBindings(element)
       },
       hostElementRef: { solid: graph, element }
     };
@@ -32542,7 +32546,8 @@ function resolveHostEntryFromJSXElement(graph, node) {
     filePath: graph.file,
     staticAttributes: collectStaticAttributes(element),
     staticClassTokens: getStaticClassTokensForElementEntity(graph, element),
-    forwardsChildren: detectChildrenForwarding(element)
+    forwardsChildren: detectChildrenForwarding(element),
+    attributePropBindings: collectAttributePropBindings(element)
   };
 }
 function isContextProviderTag(tag) {
@@ -32730,6 +32735,41 @@ function collectStaticAttributes(element) {
   if (out === null) return EMPTY_ATTRIBUTES;
   return out;
 }
+function extractPropMemberName(node) {
+  if (!import_typescript125.default.isJsxExpression(node)) return null;
+  const expression = node.expression;
+  if (!expression) return null;
+  return extractMemberNameFromExpression(expression);
+}
+function extractMemberNameFromExpression(expression) {
+  if (import_typescript125.default.isPropertyAccessExpression(expression)) {
+    return expression.name.text;
+  }
+  if (import_typescript125.default.isCallExpression(expression) && import_typescript125.default.isPropertyAccessExpression(expression.expression) && expression.arguments.length === 0) {
+    return expression.expression.name.text;
+  }
+  if (import_typescript125.default.isBinaryExpression(expression) && expression.operatorToken.kind === import_typescript125.default.SyntaxKind.QuestionQuestionToken) {
+    return extractMemberNameFromExpression(expression.left);
+  }
+  return null;
+}
+function collectAttributePropBindings(element) {
+  let out = null;
+  for (let i = 0; i < element.attributes.length; i++) {
+    const attribute = element.attributes[i];
+    if (!attribute) continue;
+    if (!import_typescript125.default.isJsxAttribute(attribute.node)) continue;
+    if (!attribute.name) continue;
+    if (attribute.valueNode === null) continue;
+    const propName = extractPropMemberName(attribute.valueNode);
+    if (propName === null) continue;
+    const attrName = attribute.name.toLowerCase();
+    if (out === null) out = /* @__PURE__ */ new Map();
+    out.set(attrName, propName);
+  }
+  if (out === null) return EMPTY_PROP_BINDINGS;
+  return out;
+}
 function collectTopLevelVariableInitializers(graph) {
   const out = /* @__PURE__ */ new Map();
   for (let i = 0; i < graph.variables.length; i++) {
@@ -32855,7 +32895,12 @@ function areHostDescriptorsEqual(left, right) {
   if (left.tagName !== right.tagName) return false;
   if (left.forwardsChildren !== right.forwardsChildren) return false;
   if (!areStringListsEqual(left.staticClassTokens, right.staticClassTokens)) return false;
-  return areAttributeMapsEqual(left.staticAttributes, right.staticAttributes);
+  if (!areAttributeMapsEqual(left.staticAttributes, right.staticAttributes)) return false;
+  if (left.attributePropBindings.size !== right.attributePropBindings.size) return false;
+  for (const [key, value2] of left.attributePropBindings) {
+    if (right.attributePropBindings.get(key) !== value2) return false;
+  }
+  return true;
 }
 function areComponentHostEntriesEqual(left, right) {
   if (left.resolution !== right.resolution) return false;
@@ -32898,6 +32943,18 @@ function mergeStaticAttributes(outer, inner) {
   }
   return out;
 }
+function mergePropBindings(outer, inner) {
+  if (inner.size === 0) return outer;
+  if (outer.size === 0) return inner;
+  const out = /* @__PURE__ */ new Map();
+  for (const [name, value2] of inner) {
+    out.set(name, value2);
+  }
+  for (const [name, value2] of outer) {
+    out.set(name, value2);
+  }
+  return out;
+}
 var HTML_TAG_NAMES = /* @__PURE__ */ new Set([
   "a",
   "abbr",
@@ -33042,9 +33099,6 @@ function mergeStaticClassTokens(outer, inner) {
 }
 
 // src/cross-file/layout/selector-match.ts
-var ATTRIBUTE_EXISTS_RE2 = /^[-_a-zA-Z][-_a-zA-Z0-9]*$/;
-var ATTRIBUTE_CONSTRAINT_RE2 = /^([-_a-zA-Z][-_a-zA-Z0-9]*)\s*(=|~=|\|=|\^=|\$=|\*=)\s*(?:"([^"]*)"|'([^']*)'|([^\s"']+))(?:\s+([iIsS]))?$/;
-var MAX_PSEUDO_COMPILE_DEPTH = 4;
 var STATEFUL_PSEUDO_CLASSES = /* @__PURE__ */ new Set([
   "active",
   "checked",
@@ -33068,14 +33122,25 @@ var STATEFUL_PSEUDO_CLASSES = /* @__PURE__ */ new Set([
   "valid",
   "visited"
 ]);
+var EMPTY_PSEUDO = {
+  firstChild: false,
+  lastChild: false,
+  onlyChild: false,
+  nthChild: null,
+  nthLastChild: null,
+  nthOfType: null,
+  nthLastOfType: null,
+  anyOfGroups: [],
+  noneOfGroups: []
+};
 function compileSelectorMatcher(selector) {
-  const parsed = parseSelectorPattern(selector.raw);
-  if (parsed === null) return null;
+  const selectorCompounds = selector.compounds;
+  if (selectorCompounds.length === 0) return null;
   const compoundsLeftToRight = [];
-  for (let i = 0; i < parsed.compounds.length; i++) {
-    const compoundRaw = parsed.compounds[i];
-    if (compoundRaw === void 0) continue;
-    const compiled = compileCompound(compoundRaw, 0);
+  for (let i = 0; i < selectorCompounds.length; i++) {
+    const sc = selectorCompounds[i];
+    if (sc === void 0) continue;
+    const compiled = buildCompiledCompound(sc);
     if (compiled === null) return null;
     compoundsLeftToRight.push(compiled);
   }
@@ -33092,9 +33157,125 @@ function compileSelectorMatcher(selector) {
     },
     requirements: resolveFeatureRequirements(compoundsLeftToRight),
     compoundsRightToLeft: compoundsLeftToRight.toReversed(),
-    combinatorsRightToLeft: parsed.combinators.toReversed()
+    combinatorsRightToLeft: selector.combinators.toReversed()
   };
 }
+function buildCompiledCompound(sc) {
+  const parts = sc.parts;
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (!part) continue;
+    if (part.type === "pseudo-element") return null;
+  }
+  const pseudoConstraints = sc.pseudoClasses;
+  if (pseudoConstraints.length === 0) {
+    return {
+      tagName: sc.tagName,
+      idValue: sc.idValue,
+      classes: sc.classes,
+      attributes: sc.attributes,
+      pseudo: EMPTY_PSEUDO
+    };
+  }
+  let firstChild = false;
+  let lastChild = false;
+  let onlyChild = false;
+  let nthChild = null;
+  let nthLastChild = null;
+  let nthOfType = null;
+  let nthLastOfType = null;
+  const anyOfGroups = [];
+  const noneOfGroups = [];
+  for (let i = 0; i < pseudoConstraints.length; i++) {
+    const pc = pseudoConstraints[i];
+    if (!pc) continue;
+    if (pc.kind === 0 /* Simple */) {
+      if (STATEFUL_PSEUDO_CLASSES.has(pc.name)) return null;
+      continue;
+    }
+    if (pc.kind === 1 /* FirstChild */) {
+      firstChild = true;
+      continue;
+    }
+    if (pc.kind === 2 /* LastChild */) {
+      lastChild = true;
+      continue;
+    }
+    if (pc.kind === 3 /* OnlyChild */) {
+      firstChild = true;
+      lastChild = true;
+      onlyChild = true;
+      continue;
+    }
+    if (pc.kind === 4 /* NthChild */) {
+      if (!pc.nthPattern) return null;
+      nthChild = pc.nthPattern;
+      continue;
+    }
+    if (pc.kind === 5 /* NthLastChild */) {
+      if (!pc.nthPattern) return null;
+      nthLastChild = pc.nthPattern;
+      continue;
+    }
+    if (pc.kind === 6 /* NthOfType */) {
+      if (!pc.nthPattern) return null;
+      nthOfType = pc.nthPattern;
+      continue;
+    }
+    if (pc.kind === 7 /* NthLastOfType */) {
+      if (!pc.nthPattern) return null;
+      nthLastOfType = pc.nthPattern;
+      continue;
+    }
+    if (pc.kind === 8 /* MatchesAny */) {
+      if (pc.nestedCompounds && pc.nestedCompounds.length > 0) {
+        const group = buildNestedGroup(pc.nestedCompounds);
+        if (group === null) return null;
+        if (group.length > 0) anyOfGroups.push(group);
+      }
+      continue;
+    }
+    if (pc.kind === 9 /* NoneOf */) {
+      if (pc.nestedCompounds && pc.nestedCompounds.length > 0) {
+        const group = buildNestedGroup(pc.nestedCompounds);
+        if (group === null) return null;
+        if (group.length > 0) noneOfGroups.push(group);
+      }
+      continue;
+    }
+  }
+  return {
+    tagName: sc.tagName,
+    idValue: sc.idValue,
+    classes: sc.classes,
+    attributes: sc.attributes,
+    pseudo: {
+      firstChild,
+      lastChild,
+      onlyChild,
+      nthChild,
+      nthLastChild,
+      nthOfType,
+      nthLastOfType,
+      anyOfGroups,
+      noneOfGroups
+    }
+  };
+}
+function buildNestedGroup(nestedCompounds) {
+  const out = [];
+  for (let i = 0; i < nestedCompounds.length; i++) {
+    const compoundGroup = nestedCompounds[i];
+    if (!compoundGroup) continue;
+    if (compoundGroup.length !== 1) continue;
+    const sc = compoundGroup[0];
+    if (!sc) continue;
+    const compiled = buildCompiledCompound(sc);
+    if (compiled === null) return null;
+    out.push(compiled);
+  }
+  return out;
+}
 function collectSubjectAttributeNames(subject) {
   if (subject.attributes.length === 0) return [];
   const names = /* @__PURE__ */ new Set();
@@ -33170,42 +33351,42 @@ function compoundGroupNeedsAttributes(groups) {
   }
   return false;
 }
-function selectorMatchesLayoutElement(matcher, node, perf, fileRootElements = null, logger = noopLogger) {
+function selectorMatchesLayoutElement(matcher, node, perf, fileRootElements = null, logger = noopLogger, fileElementIndex = null) {
   const firstCompound = matcher.compoundsRightToLeft[0];
-  if (firstCompound === void 0) return "no-match";
+  if (firstCompound === void 0) return 1 /* NoMatch */;
   const subjectResult = matchesCompound(node, firstCompound);
-  if (subjectResult === "no-match") return "no-match";
+  if (subjectResult === 1 /* NoMatch */) return 1 /* NoMatch */;
   if (matcher.compoundsRightToLeft.length === 1) return subjectResult;
-  const chainResult = matchesChain(matcher, node, 0, perf, fileRootElements, logger);
-  if (chainResult === "no-match") return "no-match";
-  if (subjectResult === "conditional" || chainResult === "conditional") return "conditional";
-  return "match";
+  const chainResult = matchesChain(matcher, node, 0, perf, fileRootElements, logger, fileElementIndex);
+  if (chainResult === 1 /* NoMatch */) return 1 /* NoMatch */;
+  if (subjectResult === 2 /* Conditional */ || chainResult === 2 /* Conditional */) return 2 /* Conditional */;
+  return 0 /* Match */;
 }
-function matchesChain(matcher, node, index, perf, fileRootElements, logger) {
+function matchesChain(matcher, node, index, perf, fileRootElements, logger, fileElementIndex = null) {
   const combinator = matcher.combinatorsRightToLeft[index];
-  if (combinator === void 0) return "no-match";
+  if (combinator === void 0) return 1 /* NoMatch */;
   const nextIndex = index + 1;
   const targetCompound = matcher.compoundsRightToLeft[nextIndex];
-  if (targetCompound === void 0) return "no-match";
+  if (targetCompound === void 0) return 1 /* NoMatch */;
   const isFinal = nextIndex === matcher.compoundsRightToLeft.length - 1;
   if (combinator === "child") {
     const parent = node.parentElementNode;
-    if (parent === null) return "no-match";
+    if (parent === null) return 1 /* NoMatch */;
     perf.ancestryChecks++;
     const compoundResult = matchesCompound(parent, targetCompound);
-    if (compoundResult === "no-match") return "no-match";
+    if (compoundResult === 1 /* NoMatch */) return 1 /* NoMatch */;
     if (isFinal) return compoundResult;
-    const chainResult = matchesChain(matcher, parent, nextIndex, perf, fileRootElements, logger);
+    const chainResult = matchesChain(matcher, parent, nextIndex, perf, fileRootElements, logger, fileElementIndex);
     return mergeMatchResults(compoundResult, chainResult);
   }
   if (combinator === "adjacent") {
     const sibling = node.previousSiblingNode;
-    if (sibling === null) return "no-match";
+    if (sibling === null) return 1 /* NoMatch */;
     perf.ancestryChecks++;
     const compoundResult = matchesCompound(sibling, targetCompound);
-    if (compoundResult === "no-match") return "no-match";
+    if (compoundResult === 1 /* NoMatch */) return 1 /* NoMatch */;
     if (isFinal) return compoundResult;
-    const chainResult = matchesChain(matcher, sibling, nextIndex, perf, fileRootElements, logger);
+    const chainResult = matchesChain(matcher, sibling, nextIndex, perf, fileRootElements, logger, fileElementIndex);
     return mergeMatchResults(compoundResult, chainResult);
   }
   if (combinator === "sibling") {
@@ -33213,26 +33394,26 @@ function matchesChain(matcher, node, index, perf, fileRootElements, logger) {
     while (sibling !== null) {
       perf.ancestryChecks++;
       const compoundResult = matchesCompound(sibling, targetCompound);
-      if (compoundResult !== "no-match") {
+      if (compoundResult !== 1 /* NoMatch */) {
         if (isFinal) return compoundResult;
-        const chainResult = matchesChain(matcher, sibling, nextIndex, perf, fileRootElements, logger);
-        if (chainResult !== "no-match") return mergeMatchResults(compoundResult, chainResult);
+        const chainResult = matchesChain(matcher, sibling, nextIndex, perf, fileRootElements, logger, fileElementIndex);
+        if (chainResult !== 1 /* NoMatch */) return mergeMatchResults(compoundResult, chainResult);
       }
       sibling = sibling.previousSiblingNode;
     }
-    return "no-match";
+    return 1 /* NoMatch */;
   }
-  let bestResult = "no-match";
+  let bestResult = 1 /* NoMatch */;
   let ancestor = node.parentElementNode;
   while (ancestor !== null) {
     perf.ancestryChecks++;
     const compoundResult = matchesCompound(ancestor, targetCompound);
-    if (compoundResult !== "no-match") {
+    if (compoundResult !== 1 /* NoMatch */) {
       if (isFinal) return compoundResult;
-      const chainResult = matchesChain(matcher, ancestor, nextIndex, perf, fileRootElements, logger);
-      if (chainResult !== "no-match") {
+      const chainResult = matchesChain(matcher, ancestor, nextIndex, perf, fileRootElements, logger, fileElementIndex);
+      if (chainResult !== 1 /* NoMatch */) {
         const merged = mergeMatchResults(compoundResult, chainResult);
-        if (merged === "match") return "match";
+        if (merged === 0 /* Match */) return 0 /* Match */;
         bestResult = merged;
       }
     }
@@ -33250,30 +33431,50 @@ function matchesChain(matcher, node, index, perf, fileRootElements, logger) {
       if (root.solidFile !== node.solidFile) continue;
       perf.ancestryChecks++;
       const compoundResult = matchesCompound(root, targetCompound);
-      if (logger.isLevelEnabled(Level.Trace) && compoundResult === "no-match") {
+      if (logger.isLevelEnabled(Level.Trace) && compoundResult === 1 /* NoMatch */) {
         logger.trace(`[selector-match] fallback MISS: root=${root.key} tag=${root.tagName} attrs=[${[...root.attributes.entries()].map(([k, v]) => `${k}=${v}`).join(",")}]`);
       }
-      if (compoundResult !== "no-match") {
+      if (compoundResult !== 1 /* NoMatch */) {
         if (logger.isLevelEnabled(Level.Debug)) {
           const compoundDesc = describeCompound(targetCompound);
           logger.debug(`[selector-match] fallback HIT: node=${node.key} tag=${node.tagName} matched root=${root.key} tag=${root.tagName} compound=${compoundDesc} isFinal=${isFinal}`);
         }
         if (isFinal) return compoundResult;
-        const chainResult = matchesChain(matcher, root, nextIndex, perf, fileRootElements, logger);
-        if (chainResult !== "no-match") {
+        const chainResult = matchesChain(matcher, root, nextIndex, perf, fileRootElements, logger, fileElementIndex);
+        if (chainResult !== 1 /* NoMatch */) {
           const merged = mergeMatchResults(compoundResult, chainResult);
-          if (merged === "match") return "match";
+          if (merged === 0 /* Match */) return 0 /* Match */;
           bestResult = merged;
         }
       }
     }
   }
+  if (fileElementIndex !== null && bestResult === 1 /* NoMatch */) {
+    const candidates = resolveCompoundCandidates(fileElementIndex, targetCompound);
+    if (candidates !== null) {
+      for (let r = 0; r < candidates.length; r++) {
+        const elem = candidates[r];
+        if (elem === void 0) continue;
+        if (elem === node) continue;
+        perf.ancestryChecks++;
+        const compoundResult = matchesCompound(elem, targetCompound);
+        if (compoundResult !== 1 /* NoMatch */) {
+          if (logger.isLevelEnabled(Level.Debug)) {
+            const compoundDesc = describeCompound(targetCompound);
+            logger.debug(`[selector-match] indexed fallback HIT: node=${node.key} tag=${node.tagName} matched elem=${elem.key} tag=${elem.tagName} compound=${compoundDesc}`);
+          }
+          bestResult = 2 /* Conditional */;
+          break;
+        }
+      }
+    }
+  }
   return bestResult;
 }
 function mergeMatchResults(a, b) {
-  if (a === "no-match" || b === "no-match") return "no-match";
-  if (a === "conditional" || b === "conditional") return "conditional";
-  return "match";
+  if (a === 1 /* NoMatch */ || b === 1 /* NoMatch */) return 1 /* NoMatch */;
+  if (a === 2 /* Conditional */ || b === 2 /* Conditional */) return 2 /* Conditional */;
+  return 0 /* Match */;
 }
 function describeCompound(compound) {
   const parts = [];
@@ -33292,16 +33493,31 @@ function describeCompound(compound) {
   if (compound.idValue !== null) parts.push(`#${compound.idValue}`);
   return parts.join("") || "*";
 }
+function resolveCompoundCandidates(index, compound) {
+  if (compound.idValue !== null) {
+    return index.byDispatchKey.get(`id:${compound.idValue}`) ?? null;
+  }
+  if (compound.classes.length > 0 && compound.classes[0] !== void 0) {
+    return index.byDispatchKey.get(`class:${compound.classes[0]}`) ?? null;
+  }
+  if (compound.attributes.length > 0 && compound.attributes[0] !== void 0) {
+    return index.byDispatchKey.get(`attr:${compound.attributes[0].name}`) ?? null;
+  }
+  if (compound.tagName !== null) {
+    return index.byTagName.get(compound.tagName) ?? null;
+  }
+  return null;
+}
 function matchesCompound(node, compound) {
-  if (compound.tagName !== null && node.tagName !== compound.tagName) return "no-match";
+  if (compound.tagName !== null && node.tagName !== compound.tagName) return 1 /* NoMatch */;
   if (compound.idValue !== null) {
     const id = node.attributes.get("id");
-    if (id !== compound.idValue) return "no-match";
+    if (id !== compound.idValue) return 1 /* NoMatch */;
   }
-  if (!matchesRequiredClasses(compound.classes, node.classTokenSet)) return "no-match";
+  if (!matchesRequiredClasses(compound.classes, node.classTokenSet)) return 1 /* NoMatch */;
   const attrResult = matchesRequiredAttributes(compound.attributes, node.attributes);
-  if (attrResult === "no-match") return "no-match";
-  if (!matchesPseudoConstraints(node, compound.pseudo)) return "no-match";
+  if (attrResult === 1 /* NoMatch */) return 1 /* NoMatch */;
+  if (!matchesPseudoConstraints(node, compound.pseudo)) return 1 /* NoMatch */;
   return attrResult;
 }
 function matchesPseudoConstraints(node, pseudo) {
@@ -33327,7 +33543,7 @@ function matchesPseudoConstraints(node, pseudo) {
     for (let j = 0; j < group.length; j++) {
       const compound = group[j];
       if (compound === void 0) continue;
-      if (matchesCompound(node, compound) === "no-match") continue;
+      if (matchesCompound(node, compound) === 1 /* NoMatch */) continue;
       matched = true;
       break;
     }
@@ -33339,607 +33555,12 @@ function matchesPseudoConstraints(node, pseudo) {
     for (let j = 0; j < group.length; j++) {
       const compound = group[j];
       if (compound === void 0) continue;
-      if (matchesCompound(node, compound) === "no-match") continue;
+      if (matchesCompound(node, compound) === 1 /* NoMatch */) continue;
       return false;
     }
   }
   return true;
 }
-function parseSelectorPattern(raw) {
-  const compounds = [];
-  const combinators = [];
-  const length = raw.length;
-  let start = 0;
-  let bracketDepth = 0;
-  let parenDepth = 0;
-  let i = 0;
-  while (i < length) {
-    const code = raw.charCodeAt(i);
-    if (code === CHAR_OPEN_BRACKET) {
-      bracketDepth++;
-      i++;
-      continue;
-    }
-    if (code === CHAR_CLOSE_BRACKET) {
-      if (bracketDepth > 0) bracketDepth--;
-      i++;
-      continue;
-    }
-    if (code === CHAR_OPEN_PAREN) {
-      parenDepth++;
-      i++;
-      continue;
-    }
-    if (code === CHAR_CLOSE_PAREN) {
-      if (parenDepth > 0) parenDepth--;
-      i++;
-      continue;
-    }
-    if (bracketDepth === 0 && parenDepth === 0) {
-      if (code === CHAR_GT || code === CHAR_PLUS || code === CHAR_TILDE) {
-        const compound = raw.slice(start, i).trim();
-        if (compound.length === 0) return null;
-        compounds.push(compound);
-        combinators.push(combinatorFromCode(code));
-        i++;
-        while (i < length && isWhitespace(raw.charCodeAt(i))) i++;
-        start = i;
-        continue;
-      }
-      if (isWhitespace(code)) {
-        const compound = raw.slice(start, i).trim();
-        if (compound.length > 0) compounds.push(compound);
-        while (i < length && isWhitespace(raw.charCodeAt(i))) i++;
-        if (i >= length) break;
-        const next = raw.charCodeAt(i);
-        if (next === CHAR_GT || next === CHAR_PLUS || next === CHAR_TILDE) {
-          if (compound.length === 0) return null;
-          combinators.push(combinatorFromCode(next));
-          i++;
-          while (i < length && isWhitespace(raw.charCodeAt(i))) i++;
-          start = i;
-          continue;
-        }
-        if (compound.length > 0) combinators.push("descendant");
-        start = i;
-        continue;
-      }
-    }
-    i++;
-  }
-  const trailing = raw.slice(start).trim();
-  if (trailing.length > 0) compounds.push(trailing);
-  if (compounds.length === 0) return null;
-  if (combinators.length !== compounds.length - 1) return null;
-  return { compounds, combinators };
-}
-function combinatorFromCode(code) {
-  if (code === CHAR_GT) return "child";
-  if (code === CHAR_PLUS) return "adjacent";
-  return "sibling";
-}
-function compileCompound(raw, depth) {
-  if (depth > MAX_PSEUDO_COMPILE_DEPTH) return null;
-  const parts = parseCompoundParts(raw);
-  if (parts.length === 0) return null;
-  let tagName = null;
-  let idValue = null;
-  const classes = [];
-  const seenClasses = /* @__PURE__ */ new Set();
-  const attributes = [];
-  let firstChild = false;
-  let lastChild = false;
-  let onlyChild = false;
-  let nthChild = null;
-  let nthLastChild = null;
-  let nthOfType = null;
-  let nthLastOfType = null;
-  const anyOfGroups = [];
-  const noneOfGroups = [];
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
-    if (part === void 0) continue;
-    if (part.type === "element") {
-      tagName = part.value.toLowerCase();
-      continue;
-    }
-    if (part.type === "universal") continue;
-    if (part.type === "id") {
-      idValue = part.value;
-      continue;
-    }
-    if (part.type === "class") {
-      if (seenClasses.has(part.value)) continue;
-      seenClasses.add(part.value);
-      classes.push(part.value);
-      continue;
-    }
-    if (part.type === "attribute") {
-      const attribute = parseAttributeConstraint(part.value);
-      if (attribute === null) return null;
-      attributes.push(attribute);
-      continue;
-    }
-    if (part.type === "pseudo-class") {
-      const pseudo = parsePseudoConstraint(part.raw, depth);
-      if (pseudo === null) return null;
-      if (pseudo.kind === "first-child") {
-        firstChild = true;
-        continue;
-      }
-      if (pseudo.kind === "last-child") {
-        lastChild = true;
-        continue;
-      }
-      if (pseudo.kind === "only-child") {
-        firstChild = true;
-        lastChild = true;
-        onlyChild = true;
-        continue;
-      }
-      if (pseudo.kind === "nth-child") {
-        if (nthChild !== null && !isSameNthPattern(nthChild, pseudo.value)) return null;
-        nthChild = pseudo.value;
-        continue;
-      }
-      if (pseudo.kind === "nth-last-child") {
-        if (nthLastChild !== null && !isSameNthPattern(nthLastChild, pseudo.value)) return null;
-        nthLastChild = pseudo.value;
-        continue;
-      }
-      if (pseudo.kind === "nth-of-type") {
-        if (nthOfType !== null && !isSameNthPattern(nthOfType, pseudo.value)) return null;
-        nthOfType = pseudo.value;
-        continue;
-      }
-      if (pseudo.kind === "nth-last-of-type") {
-        if (nthLastOfType !== null && !isSameNthPattern(nthLastOfType, pseudo.value)) return null;
-        nthLastOfType = pseudo.value;
-        continue;
-      }
-      if (pseudo.kind === "ignore") continue;
-      if (pseudo.kind === "matches-any") {
-        anyOfGroups.push(pseudo.selectors);
-        continue;
-      }
-      noneOfGroups.push(pseudo.selectors);
-      continue;
-    }
-    return null;
-  }
-  if (firstChild && nthChild !== null && !matchesNthPattern(1, nthChild)) return null;
-  if (lastChild && nthLastChild !== null && !matchesNthPattern(1, nthLastChild)) return null;
-  return {
-    tagName,
-    idValue,
-    classes,
-    attributes,
-    pseudo: {
-      firstChild,
-      lastChild,
-      onlyChild,
-      nthChild,
-      nthLastChild,
-      nthOfType,
-      nthLastOfType,
-      anyOfGroups,
-      noneOfGroups
-    }
-  };
-}
-function parseAttributeConstraint(raw) {
-  const trimmed = raw.trim();
-  const constrained = ATTRIBUTE_CONSTRAINT_RE2.exec(trimmed);
-  if (constrained) {
-    const operatorToken = constrained[2];
-    if (operatorToken === void 0) return null;
-    const operator = mapAttributeOperatorFromToken2(operatorToken);
-    if (operator === null) return null;
-    const value2 = constrained[3] ?? constrained[4] ?? constrained[5] ?? null;
-    if (value2 === null) return null;
-    const nameToken = constrained[1];
-    if (nameToken === void 0) return null;
-    return {
-      name: nameToken.toLowerCase(),
-      operator,
-      value: value2,
-      caseInsensitive: (constrained[6] ?? "").toLowerCase() === "i"
-    };
-  }
-  if (!ATTRIBUTE_EXISTS_RE2.test(trimmed)) return null;
-  return {
-    name: trimmed.toLowerCase(),
-    operator: "exists",
-    value: null,
-    caseInsensitive: false
-  };
-}
-function mapAttributeOperatorFromToken2(operator) {
-  if (operator === "=") return "equals";
-  if (operator === "~=") return "includes-word";
-  if (operator === "|=") return "dash-prefix";
-  if (operator === "^=") return "prefix";
-  if (operator === "$=") return "suffix";
-  if (operator === "*=") return "contains";
-  return null;
-}
-function parsePseudoConstraint(raw, depth) {
-  const trimmed = raw.trim();
-  const normalized = trimmed.toLowerCase();
-  if (normalized === ":first-child") return { kind: "first-child" };
-  if (normalized === ":last-child") return { kind: "last-child" };
-  if (normalized === ":only-child") return { kind: "only-child" };
-  const nthChild = parseNthPseudoArgument(trimmed, "nth-child");
-  if (nthChild !== void 0) {
-    if (nthChild === null) return null;
-    return { kind: "nth-child", value: nthChild };
-  }
-  const nthLastChild = parseNthPseudoArgument(trimmed, "nth-last-child");
-  if (nthLastChild !== void 0) {
-    if (nthLastChild === null) return null;
-    return { kind: "nth-last-child", value: nthLastChild };
-  }
-  const nthOfType = parseNthPseudoArgument(trimmed, "nth-of-type");
-  if (nthOfType !== void 0) {
-    if (nthOfType === null) return null;
-    return { kind: "nth-of-type", value: nthOfType };
-  }
-  const nthLastOfType = parseNthPseudoArgument(trimmed, "nth-last-of-type");
-  if (nthLastOfType !== void 0) {
-    if (nthLastOfType === null) return null;
-    return { kind: "nth-last-of-type", value: nthLastOfType };
-  }
-  const name = readPseudoName(normalized);
-  if (name === null) return null;
-  if (STATEFUL_PSEUDO_CLASSES.has(name)) return null;
-  if (name !== "is" && name !== "where" && name !== "not") {
-    return { kind: "ignore" };
-  }
-  const content = extractFunctionalPseudoContent(trimmed, name);
-  if (content === null) return null;
-  const selectors = compileFunctionalPseudoArguments(content, depth + 1);
-  if (selectors === null || selectors.length === 0) return null;
-  if (name === "not") {
-    return {
-      kind: "matches-none",
-      selectors
-    };
-  }
-  return {
-    kind: "matches-any",
-    selectors
-  };
-}
-function parseNthPseudoArgument(raw, name) {
-  const content = extractFunctionalPseudoContent(raw, name);
-  if (content === null) return void 0;
-  return parseNthPattern(content);
-}
-function parseNthPattern(raw) {
-  const normalized = raw.trim().toLowerCase().replaceAll(" ", "");
-  if (normalized.length === 0) return null;
-  if (normalized === "odd") {
-    return { step: 2, offset: 1 };
-  }
-  if (normalized === "even") {
-    return { step: 2, offset: 0 };
-  }
-  const nIndex = normalized.indexOf("n");
-  if (nIndex === -1) {
-    const value2 = Number.parseInt(normalized, 10);
-    if (Number.isNaN(value2)) return null;
-    return { step: 0, offset: value2 };
-  }
-  const stepPart = normalized.slice(0, nIndex);
-  const offsetPart = normalized.slice(nIndex + 1);
-  let step;
-  if (stepPart.length === 0 || stepPart === "+") {
-    step = 1;
-  } else if (stepPart === "-") {
-    step = -1;
-  } else {
-    step = Number.parseInt(stepPart, 10);
-    if (Number.isNaN(step)) return null;
-  }
-  let offset = 0;
-  if (offsetPart.length > 0) {
-    offset = Number.parseInt(offsetPart, 10);
-    if (Number.isNaN(offset)) return null;
-  }
-  return {
-    step,
-    offset
-  };
-}
-function extractFunctionalPseudoContent(raw, name) {
-  const prefix = `:${name}(`;
-  if (!raw.toLowerCase().startsWith(prefix)) return null;
-  if (!raw.endsWith(")")) return null;
-  return raw.slice(prefix.length, -1);
-}
-function compileFunctionalPseudoArguments(content, depth) {
-  if (depth > MAX_PSEUDO_COMPILE_DEPTH) return null;
-  const args = splitTopLevelSelectorArguments(content);
-  if (args.length === 0) return null;
-  const out = [];
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === void 0) return null;
-    const raw = arg.trim();
-    if (raw.length === 0) return null;
-    const parsed = parseSelectorPattern(raw);
-    if (parsed === null) return null;
-    if (parsed.combinators.length !== 0) return null;
-    if (parsed.compounds.length !== 1) return null;
-    const compoundRaw = parsed.compounds[0];
-    if (compoundRaw === void 0) return null;
-    const compiled = compileCompound(compoundRaw, depth);
-    if (compiled === null) return null;
-    out.push(compiled);
-  }
-  return out;
-}
-function splitTopLevelSelectorArguments(content) {
-  const out = [];
-  let start = 0;
-  let parenDepth = 0;
-  let bracketDepth = 0;
-  let quote = null;
-  for (let i = 0; i < content.length; i++) {
-    const code = content.charCodeAt(i);
-    if (quote !== null) {
-      if (code === quote) quote = null;
-      continue;
-    }
-    if (code === CHAR_SINGLE_QUOTE || code === CHAR_DOUBLE_QUOTE) {
-      quote = code;
-      continue;
-    }
-    if (code === CHAR_OPEN_PAREN) {
-      parenDepth++;
-      continue;
-    }
-    if (code === CHAR_CLOSE_PAREN) {
-      if (parenDepth > 0) parenDepth--;
-      continue;
-    }
-    if (code === CHAR_OPEN_BRACKET) {
-      bracketDepth++;
-      continue;
-    }
-    if (code === CHAR_CLOSE_BRACKET) {
-      if (bracketDepth > 0) bracketDepth--;
-      continue;
-    }
-    if (code !== CHAR_COMMA) continue;
-    if (parenDepth !== 0) continue;
-    if (bracketDepth !== 0) continue;
-    out.push(content.slice(start, i));
-    start = i + 1;
-  }
-  out.push(content.slice(start));
-  return out;
-}
-function parseCompoundParts(raw) {
-  const trimmed = raw.trim();
-  if (trimmed.length === 0) return [];
-  const out = [];
-  const length = trimmed.length;
-  let i = 0;
-  let allowsElement = true;
-  while (i < length) {
-    const code = trimmed.charCodeAt(i);
-    if (code === CHAR_OPEN_BRACKET) {
-      const end = readBracketed(trimmed, i);
-      if (end === null) return [];
-      const inner = trimmed.slice(i + 1, end - 1);
-      out.push({
-        type: "attribute",
-        value: inner,
-        raw: trimmed.slice(i, end)
-      });
-      i = end;
-      allowsElement = false;
-      continue;
-    }
-    if (code === 35) {
-      const ident2 = readIdentifier(trimmed, i + 1);
-      if (ident2.consumed === 0) return [];
-      out.push({
-        type: "id",
-        value: ident2.value,
-        raw: trimmed.slice(i, i + 1 + ident2.consumed)
-      });
-      i += 1 + ident2.consumed;
-      allowsElement = false;
-      continue;
-    }
-    if (code === 46) {
-      const ident2 = readIdentifier(trimmed, i + 1);
-      if (ident2.consumed === 0) return [];
-      out.push({
-        type: "class",
-        value: ident2.value,
-        raw: trimmed.slice(i, i + 1 + ident2.consumed)
-      });
-      i += 1 + ident2.consumed;
-      allowsElement = false;
-      continue;
-    }
-    if (code === 58) {
-      const pseudo = readPseudo(trimmed, i);
-      if (pseudo === null) return [];
-      out.push(pseudo);
-      i += pseudo.raw.length;
-      allowsElement = false;
-      continue;
-    }
-    if (code === 42) {
-      out.push({
-        type: "universal",
-        value: "*",
-        raw: "*"
-      });
-      i++;
-      allowsElement = false;
-      continue;
-    }
-    if (!allowsElement) return [];
-    const ident = readIdentifier(trimmed, i);
-    if (ident.consumed === 0) return [];
-    out.push({
-      type: "element",
-      value: ident.value,
-      raw: trimmed.slice(i, i + ident.consumed)
-    });
-    i += ident.consumed;
-    allowsElement = false;
-  }
-  return out;
-}
-function readPseudo(input, start) {
-  const second = input.charCodeAt(start + 1);
-  if (second === 58) return null;
-  let i = start + 1;
-  while (i < input.length) {
-    const code = input.charCodeAt(i);
-    if (!isIdentChar(code)) break;
-    i++;
-  }
-  if (i === start + 1) return null;
-  const value2 = input.slice(start + 1, i);
-  if (input.charCodeAt(i) !== CHAR_OPEN_PAREN) {
-    return {
-      type: "pseudo-class",
-      value: value2,
-      raw: input.slice(start, i)
-    };
-  }
-  const end = readParenthesized(input, i);
-  if (end === null) return null;
-  return {
-    type: "pseudo-class",
-    value: value2,
-    raw: input.slice(start, end)
-  };
-}
-function readBracketed(input, start) {
-  let quote = null;
-  let depth = 0;
-  for (let i = start; i < input.length; i++) {
-    const code = input.charCodeAt(i);
-    if (quote !== null) {
-      if (code === quote) quote = null;
-      continue;
-    }
-    if (code === CHAR_SINGLE_QUOTE || code === CHAR_DOUBLE_QUOTE) {
-      quote = code;
-      continue;
-    }
-    if (code === CHAR_OPEN_BRACKET) {
-      depth++;
-      continue;
-    }
-    if (code !== CHAR_CLOSE_BRACKET) continue;
-    depth--;
-    if (depth === 0) return i + 1;
-    if (depth < 0) return null;
-  }
-  return null;
-}
-function readParenthesized(input, start) {
-  let quote = null;
-  let depth = 0;
-  for (let i = start; i < input.length; i++) {
-    const code = input.charCodeAt(i);
-    if (quote !== null) {
-      if (code === quote) quote = null;
-      continue;
-    }
-    if (code === CHAR_SINGLE_QUOTE || code === CHAR_DOUBLE_QUOTE) {
-      quote = code;
-      continue;
-    }
-    if (code === CHAR_OPEN_PAREN) {
-      depth++;
-      continue;
-    }
-    if (code !== CHAR_CLOSE_PAREN) continue;
-    depth--;
-    if (depth === 0) return i + 1;
-    if (depth < 0) return null;
-  }
-  return null;
-}
-var EMPTY_IDENTIFIER = { value: "", consumed: 0 };
-function readIdentifier(input, start) {
-  const length = input.length;
-  let i = start;
-  let hasEscape = false;
-  while (i < length) {
-    const code = input.charCodeAt(i);
-    if (code === CHAR_BACKSLASH) {
-      if (i + 1 >= length) break;
-      hasEscape = true;
-      i = skipCssEscapeSequence(input, i + 1);
-      continue;
-    }
-    if (!isIdentChar(code)) break;
-    i++;
-  }
-  const consumed = i - start;
-  if (consumed === 0) return EMPTY_IDENTIFIER;
-  if (!hasEscape) {
-    const value2 = input.slice(start, i);
-    return { value: value2, consumed };
-  }
-  return { value: decodeCssEscapes(input, start, i), consumed };
-}
-var CHAR_BACKSLASH = 92;
-function skipCssEscapeSequence(input, afterBackslash) {
-  const length = input.length;
-  if (afterBackslash >= length) return afterBackslash;
-  const first = input.charCodeAt(afterBackslash);
-  if (!isHexDigit(first)) return afterBackslash + 1;
-  let end = afterBackslash + 1;
-  const maxHex = Math.min(afterBackslash + 6, length);
-  while (end < maxHex && isHexDigit(input.charCodeAt(end))) end++;
-  if (end < length && isWhitespace(input.charCodeAt(end))) end++;
-  return end;
-}
-function decodeCssEscapes(input, start, end) {
-  const parts = [];
-  let i = start;
-  while (i < end) {
-    const code = input.charCodeAt(i);
-    if (code !== CHAR_BACKSLASH) {
-      parts.push(String.fromCharCode(code));
-      i++;
-      continue;
-    }
-    i++;
-    if (i >= end) break;
-    const first = input.charCodeAt(i);
-    if (!isHexDigit(first)) {
-      parts.push(String.fromCharCode(first));
-      i++;
-      continue;
-    }
-    const hexStart = i;
-    const maxHex = Math.min(i + 6, end);
-    while (i < maxHex && isHexDigit(input.charCodeAt(i))) i++;
-    const codePoint = Number.parseInt(input.slice(hexStart, i), 16);
-    if (codePoint > 0 && codePoint <= 1114111) {
-      parts.push(String.fromCodePoint(codePoint));
-    }
-    if (i < end && isWhitespace(input.charCodeAt(i))) i++;
-  }
-  return parts.join("");
-}
-function isSameNthPattern(left, right) {
-  if (left.step !== right.step) return false;
-  return left.offset === right.offset;
-}
 function matchesNthPattern(index, pattern) {
   if (index < 1) return false;
   const step = pattern.step;
@@ -33958,20 +33579,6 @@ function matchesNthPattern(index, pattern) {
   if (delta < 0) return false;
   return delta % positiveStep === 0;
 }
-function readPseudoName(raw) {
-  if (!raw.startsWith(":")) return null;
-  let index = 1;
-  while (index < raw.length) {
-    const code = raw.charCodeAt(index);
-    const isUpper = code >= 65 && code <= 90;
-    const isLower = code >= 97 && code <= 122;
-    const isDash = code === 45;
-    if (!isUpper && !isLower && !isDash) break;
-    index++;
-  }
-  if (index <= 1) return null;
-  return raw.slice(1, index);
-}
 function matchesRequiredClasses(required, actual) {
   if (required.length === 0) return true;
   if (actual.size === 0) return false;
@@ -33984,24 +33591,24 @@ function matchesRequiredClasses(required, actual) {
   return true;
 }
 function matchesRequiredAttributes(required, actual) {
-  if (required.length === 0) return "match";
+  if (required.length === 0) return 0 /* Match */;
   let hasConditional = false;
   for (let i = 0; i < required.length; i++) {
     const constraint = required[i];
     if (constraint === void 0) continue;
-    if (!actual.has(constraint.name)) return "no-match";
+    if (!actual.has(constraint.name)) return 1 /* NoMatch */;
     if (constraint.operator === "exists") continue;
     const actualValue = actual.get(constraint.name);
-    if (actualValue === void 0) return "no-match";
+    if (actualValue === void 0) return 1 /* NoMatch */;
     if (actualValue === null) {
       hasConditional = true;
       continue;
     }
-    if (constraint.value === null) return "no-match";
+    if (constraint.value === null) return 1 /* NoMatch */;
     if (matchesAttributeValue(actualValue, constraint)) continue;
-    return "no-match";
+    return 1 /* NoMatch */;
   }
-  return hasConditional ? "conditional" : "match";
+  return hasConditional ? 2 /* Conditional */ : 0 /* Match */;
 }
 function matchesAttributeValue(actualValue, constraint) {
   const expectedValue = constraint.value;
@@ -34175,11 +33782,11 @@ function accumulateSnapshotFacts(snapshot, sink) {
       sink.addConditional();
       continue;
     }
-    if (value2.kind === "unknown") {
+    if (value2.kind === 1 /* Unknown */) {
       sink.addUnknown();
       continue;
     }
-    if (value2.quality === "estimated" && value2.px !== null) {
+    if (value2.quality === 1 /* Estimated */ && value2.px !== null) {
       sink.addInterval();
       continue;
     }
@@ -34521,7 +34128,7 @@ function checkHeightContributions(snapshot, state) {
     if (!signalName) continue;
     const signal = snapshot.signals.get(signalName);
     if (!signal) continue;
-    if (signal.kind !== "known") continue;
+    if (signal.kind !== 0 /* Known */) continue;
     if (signal.px !== null && signal.px > 0) {
       state.hasHeightContributingDescendant = true;
       return;
@@ -34531,7 +34138,7 @@ function checkHeightContributions(snapshot, state) {
 function checkVerticalAlignMitigation(snapshot, state) {
   const verticalAlign = snapshot.signals.get("vertical-align");
   if (!verticalAlign) return;
-  if (verticalAlign.kind !== "known") return;
+  if (verticalAlign.kind !== 0 /* Known */) return;
   if (VERTICAL_ALIGN_MITIGATIONS.has(verticalAlign.normalized)) {
     state.hasVerticalAlignMitigation = true;
   }
@@ -35717,16 +35324,16 @@ function establishesFormattingContext2(node, snapshotByElementNode) {
   const snapshot = snapshotByElementNode.get(node);
   if (snapshot) {
     const displaySignal = snapshot.signals.get("display");
-    if (displaySignal && displaySignal.kind === "known") {
+    if (displaySignal && displaySignal.kind === 0 /* Known */) {
       return !isInlineLevelDisplay(displaySignal.normalized);
     }
     const overflowSignal = snapshot.signals.get("overflow");
-    if (overflowSignal && overflowSignal.kind === "known") {
+    if (overflowSignal && overflowSignal.kind === 0 /* Known */) {
       const ov = overflowSignal.normalized;
       if (ov !== "visible" && ov !== "clip") return true;
     }
     const overflowYSignal = snapshot.signals.get("overflow-y");
-    if (overflowYSignal && overflowYSignal.kind === "known") {
+    if (overflowYSignal && overflowYSignal.kind === 0 /* Known */) {
       const ov = overflowYSignal.normalized;
       if (ov !== "visible" && ov !== "clip") return true;
     }
@@ -35919,18 +35526,21 @@ function buildSelectorCandidatesByNode(elements, scopedSelectorsBySolidFile, per
   }
   return out;
 }
+function buildDispatchKeys(idValue, classTokens, attributeNames) {
+  const out = [];
+  if (idValue !== null) out.push(`id:${idValue}`);
+  for (let i = 0; i < classTokens.length; i++) out.push(`class:${classTokens[i]}`);
+  for (let i = 0; i < attributeNames.length; i++) out.push(`attr:${attributeNames[i]}`);
+  if (out.length <= 1) return out;
+  out.sort();
+  return dedupeSorted(out);
+}
 function buildSelectorDispatchKeys(attributes, classTokens) {
   const out = [];
   const idValue = attributes.get("id");
-  if (idValue !== null && idValue !== void 0) {
-    out.push(`id:${idValue}`);
-  }
-  for (let i = 0; i < classTokens.length; i++) {
-    out.push(`class:${classTokens[i]}`);
-  }
-  for (const attributeName of attributes.keys()) {
-    out.push(`attr:${attributeName}`);
-  }
+  if (idValue !== null && idValue !== void 0) out.push(`id:${idValue}`);
+  for (let i = 0; i < classTokens.length; i++) out.push(`class:${classTokens[i]}`);
+  for (const attributeName of attributes.keys()) out.push(`attr:${attributeName}`);
   if (out.length <= 1) return out;
   out.sort();
   return dedupeSorted(out);
@@ -36074,19 +35684,11 @@ function selectorMatchesDispatchKeys(candidate, dispatchKeys) {
   return subjectIndex === candidate.subjectDispatchKeys.length;
 }
 function resolveSubjectDispatchKeys(matcher) {
-  const out = [];
-  if (matcher.subject.idValue !== null) {
-    out.push(`id:${matcher.subject.idValue}`);
-  }
-  for (let i = 0; i < matcher.subject.classes.length; i++) {
-    out.push(`class:${matcher.subject.classes[i]}`);
-  }
-  for (let i = 0; i < matcher.subject.attributeNames.length; i++) {
-    out.push(`attr:${matcher.subject.attributeNames[i]}`);
-  }
-  if (out.length <= 1) return out;
-  out.sort();
-  return dedupeSorted(out);
+  return buildDispatchKeys(
+    matcher.subject.idValue,
+    matcher.subject.classes,
+    matcher.subject.attributeNames
+  );
 }
 function dedupeSorted(values) {
   if (values.length <= 1) return values;
@@ -36156,6 +35758,94 @@ function normalizeWithCache(cache, path) {
   return normalized;
 }
 
+// src/cross-file/layout/shorthand-expansion.ts
+var QUAD_EXPANSIONS = /* @__PURE__ */ new Map([
+  ["padding", ["padding-top", "padding-right", "padding-bottom", "padding-left"]],
+  ["border-width", ["border-top-width", "border-right-width", "border-bottom-width", "border-left-width"]],
+  ["margin", ["margin-top", "margin-right", "margin-bottom", "margin-left"]],
+  ["inset", ["top", "right", "bottom", "left"]]
+]);
+var BLOCK_EXPANSIONS = /* @__PURE__ */ new Map([
+  ["margin-block", ["margin-top", "margin-bottom"]],
+  ["padding-block", ["padding-top", "padding-bottom"]],
+  ["inset-block", ["inset-block-start", "inset-block-end"]]
+]);
+var INLINE_EXPANSIONS = /* @__PURE__ */ new Map([
+  ["padding-inline", ["padding-left", "padding-right"]]
+]);
+function expandShorthand(property, value2) {
+  const quadTarget = QUAD_EXPANSIONS.get(property);
+  if (quadTarget !== void 0) {
+    const parsed = parseQuadShorthand(value2);
+    if (parsed === null) return null;
+    return [
+      { name: quadTarget[0], value: parsed.top },
+      { name: quadTarget[1], value: parsed.right },
+      { name: quadTarget[2], value: parsed.bottom },
+      { name: quadTarget[3], value: parsed.left }
+    ];
+  }
+  const blockTarget = BLOCK_EXPANSIONS.get(property);
+  if (blockTarget !== void 0) {
+    const parsed = parseBlockShorthand(value2);
+    if (parsed === null) return null;
+    return [
+      { name: blockTarget[0], value: parsed.start },
+      { name: blockTarget[1], value: parsed.end }
+    ];
+  }
+  const inlineTarget = INLINE_EXPANSIONS.get(property);
+  if (inlineTarget !== void 0) {
+    const parsed = parseBlockShorthand(value2);
+    if (parsed === null) return null;
+    return [
+      { name: inlineTarget[0], value: parsed.start },
+      { name: inlineTarget[1], value: parsed.end }
+    ];
+  }
+  if (property === "flex-flow") {
+    return expandFlexFlow(value2);
+  }
+  return void 0;
+}
+var FLEX_DIRECTION_VALUES = /* @__PURE__ */ new Set(["row", "row-reverse", "column", "column-reverse"]);
+function expandFlexFlow(value2) {
+  const tokens = splitWhitespaceTokens(value2.trim().toLowerCase());
+  if (tokens.length === 0) return null;
+  if (tokens.length > 2) return null;
+  let direction = null;
+  let wrap = null;
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (!token) continue;
+    if (FLEX_DIRECTION_VALUES.has(token)) {
+      if (direction !== null) return null;
+      direction = token;
+    } else {
+      if (wrap !== null) return null;
+      wrap = token;
+    }
+  }
+  const out = [];
+  if (direction !== null) {
+    out.push({ name: "flex-direction", value: direction });
+  }
+  if (wrap !== null) {
+    out.push({ name: "flex-wrap", value: wrap });
+  }
+  return out.length > 0 ? out : null;
+}
+function getShorthandLonghandNames(property) {
+  const quad = QUAD_EXPANSIONS.get(property);
+  if (quad !== void 0) return [...quad];
+  const block = BLOCK_EXPANSIONS.get(property);
+  if (block !== void 0) return [...block];
+  const inline = INLINE_EXPANSIONS.get(property);
+  if (inline !== void 0) return [...inline];
+  if (property === "flex-flow") return ["flex-direction", "flex-wrap"];
+  return null;
+}
+
 // src/cross-file/layout/stateful-rule-index.ts
 var EMPTY_STATEFUL_SELECTOR_ENTRY_LIST = [];
 var EMPTY_LAYOUT_NORMALIZED_DECLARATION_LIST = [];
@@ -36373,7 +36063,6 @@ var DYNAMIC_ATTRIBUTE_GUARD = {
   key: "dynamic-attribute:*"
 };
 var SCROLLABLE_VALUES = /* @__PURE__ */ new Set(["auto", "scroll"]);
-var EMPTY_EXPANSION_RESULT = [];
 function collectMonitoredDeclarations(selector, layerOrder, guard) {
   const out = [];
   const declarations = selector.rule.declarations;
@@ -36382,59 +36071,50 @@ function collectMonitoredDeclarations(selector, layerOrder, guard) {
     if (!declaration) continue;
     const property = declaration.property.toLowerCase();
     if (!isMonitoredSignal(property)) continue;
-    const monitored = toMonitoredSignalKey(property);
-    if (!monitored) continue;
-    out.push({
-      property: monitored,
-      value: declaration.value,
-      guardProvenance: guard,
-      position: {
-        layer: declaration.cascadePosition.layer,
-        layerOrder,
-        sourceOrder: declaration.sourceOrder,
-        specificity: selector.specificity,
-        specificityScore: selector.specificityScore,
-        isImportant: declaration.cascadePosition.isImportant || declaration.node.important
+    const position = {
+      layer: declaration.cascadePosition.layer,
+      layerOrder,
+      sourceOrder: declaration.sourceOrder,
+      specificity: selector.specificity,
+      specificityScore: selector.specificityScore,
+      isImportant: declaration.cascadePosition.isImportant || declaration.node.important
+    };
+    const directSignal = MONITORED_SIGNAL_NAME_MAP.get(property);
+    if (directSignal !== void 0) {
+      out.push({ property: directSignal, value: declaration.value, guardProvenance: guard, position });
+      continue;
+    }
+    const value2 = declaration.value.trim().toLowerCase();
+    const expanded = expandShorthand(property, value2);
+    if (expanded === void 0) continue;
+    if (expanded === null) {
+      const longhandNames = getShorthandLonghandNames(property);
+      if (longhandNames === null) continue;
+      for (let j = 0; j < longhandNames.length; j++) {
+        const longhand = longhandNames[j];
+        if (!longhand) continue;
+        const signal = MONITORED_SIGNAL_NAME_MAP.get(longhand);
+        if (signal === void 0) continue;
+        out.push({ property: signal, value: declaration.value, guardProvenance: guard, position });
       }
-    });
+      continue;
+    }
+    for (let j = 0; j < expanded.length; j++) {
+      const entry = expanded[j];
+      if (!entry) continue;
+      const signal = MONITORED_SIGNAL_NAME_MAP.get(entry.name);
+      if (signal === void 0) continue;
+      out.push({ property: signal, value: entry.value, guardProvenance: guard, position });
+    }
   }
   return out;
 }
-function toMonitoredSignalKey(property) {
-  const signal = MONITORED_SIGNAL_NAME_MAP.get(property);
-  if (signal) return signal;
-  switch (property) {
-    case "padding":
-    case "border-width":
-    case "margin-block":
-    case "padding-block":
-    case "inset-block":
-    case "flex-flow":
-      return property;
-    default:
-      return null;
-  }
-}
 function expandMonitoredDeclarationForDelta(declaration) {
-  const value2 = declaration.value.trim().toLowerCase();
-  const expanded = expandShorthand(declaration.property, value2);
-  if (expanded !== void 0) {
-    if (expanded === null) return EMPTY_EXPANSION_RESULT;
-    const filtered = [];
-    for (let i = 0; i < expanded.length; i++) {
-      const entry = expanded[i];
-      if (!entry) continue;
-      const signalName2 = MONITORED_SIGNAL_NAME_MAP.get(entry.name);
-      if (signalName2 !== void 0) filtered.push({ name: signalName2, value: entry.value });
-    }
-    return filtered;
-  }
-  const signalName = MONITORED_SIGNAL_NAME_MAP.get(declaration.property);
-  if (signalName === void 0) return EMPTY_EXPANSION_RESULT;
-  return [{ name: signalName, value: value2 }];
+  return [{ name: declaration.property, value: declaration.value.trim().toLowerCase() }];
 }
 function appendMatchingEdgesFromSelectorIds(ctx, selectorIds, node, applies, appliesByElementNodeMutable) {
   const fileRoots = ctx.rootElementsByFile.get(node.solidFile) ?? null;
+  const fileElementIndex = ctx.fileElementIndexByFile.get(node.solidFile) ?? null;
   for (let i = 0; i < selectorIds.length; i++) {
     const selectorId = selectorIds[i];
     if (selectorId === void 0) continue;
@@ -36446,13 +36126,13 @@ function appendMatchingEdgesFromSelectorIds(ctx, selectorIds, node, applies, app
     if (!selector) {
       throw new Error(`missing selector ${selectorId}`);
     }
-    const matchResult = selectorMatchesLayoutElement(metadata.matcher, node, ctx.perf, fileRoots, ctx.logger);
-    if (matchResult === "no-match") continue;
+    const matchResult = selectorMatchesLayoutElement(metadata.matcher, node, ctx.perf, fileRoots, ctx.logger, fileElementIndex);
+    if (matchResult === 1 /* NoMatch */) continue;
     const edge = {
       selectorId: selector.id,
       specificityScore: selector.specificityScore,
       sourceOrder: selector.rule.sourceOrder,
-      conditionalMatch: matchResult === "conditional"
+      conditionalMatch: matchResult === 2 /* Conditional */
     };
     applies.push(edge);
     ctx.perf.matchEdgesCreated++;
@@ -36509,7 +36189,54 @@ function augmentCascadeWithTailwind(cascade, node, tailwind) {
     }
   }
 }
-function buildCascadeMapForElement(node, edges, monitoredDeclarationsBySelectorId, tailwind) {
+var MAX_VAR_SUBSTITUTION_DEPTH = 10;
+function resolveVarReferencesInCascade(cascade, variablesByName) {
+  for (const [property, declaration] of cascade) {
+    if (!declaration.value.includes("var(")) continue;
+    const resolved = substituteVarReferences(declaration.value, variablesByName, 0);
+    if (resolved !== declaration.value) {
+      cascade.set(property, {
+        value: resolved,
+        source: declaration.source,
+        guardProvenance: declaration.guardProvenance
+      });
+    }
+  }
+}
+function substituteVarReferences(value2, variablesByName, depth) {
+  if (depth >= MAX_VAR_SUBSTITUTION_DEPTH) return value2;
+  const refs = extractVarReferences(value2);
+  if (refs.length === 0) return value2;
+  let result = value2;
+  for (let i = refs.length - 1; i >= 0; i--) {
+    const ref = refs[i];
+    if (!ref) continue;
+    const candidates = variablesByName.get(ref.name);
+    const resolvedValue = candidates !== void 0 && candidates.length > 0 ? selectBestVariableValue(candidates) : ref.fallback;
+    if (resolvedValue === null) continue;
+    result = result.slice(0, ref.sourceIndex) + resolvedValue + result.slice(ref.sourceIndex + ref.raw.length);
+  }
+  if (result !== value2 && result.includes("var(")) {
+    return substituteVarReferences(result, variablesByName, depth + 1);
+  }
+  return result;
+}
+function selectBestVariableValue(candidates) {
+  let bestGlobal = null;
+  for (let i = 0; i < candidates.length; i++) {
+    const candidate = candidates[i];
+    if (!candidate) continue;
+    if (candidate.scope.type === "global") {
+      if (bestGlobal === null || candidate.declaration.sourceOrder > bestGlobal.declaration.sourceOrder) {
+        bestGlobal = candidate;
+      }
+    }
+  }
+  if (bestGlobal !== null) return bestGlobal.value;
+  const first = candidates[0];
+  return first ? first.value : null;
+}
+function buildCascadeMapForElement(node, edges, monitoredDeclarationsBySelectorId, tailwind, variablesByName) {
   const out = /* @__PURE__ */ new Map();
   const positions = /* @__PURE__ */ new Map();
   for (let i = 0; i < edges.length; i++) {
@@ -36567,6 +36294,9 @@ function buildCascadeMapForElement(node, edges, monitoredDeclarationsBySelectorI
   if (tailwind !== null) {
     augmentCascadeWithTailwind(out, node, tailwind);
   }
+  if (variablesByName !== null) {
+    resolveVarReferencesInCascade(out, variablesByName);
+  }
   return out;
 }
 function compareLayoutEdge(a, b) {
@@ -36607,14 +36337,14 @@ function resolveRuleLayerOrder(rule, css) {
   if (!name) return 0;
   return css.layerOrder.get(name) ?? 0;
 }
-function buildConditionalDeltaIndex(elements, appliesByNode, monitoredDeclarationsBySelectorId, selectorsById) {
+function buildConditionalDeltaIndex(elements, records, monitoredDeclarationsBySelectorId, selectorsById) {
   const conditionalSignalDeltaFactsByNode = /* @__PURE__ */ new Map();
   const elementsWithConditionalDeltaBySignal = /* @__PURE__ */ new Map();
   const baselineOffsetFactsByNode = /* @__PURE__ */ new Map();
   for (let i = 0; i < elements.length; i++) {
     const node = elements[i];
     if (!node) continue;
-    const edges = appliesByNode.get(node);
+    const edges = records.get(node)?.edges;
     let factByProperty = null;
     if (edges !== void 0 && edges.length > 0) {
       const byProperty = /* @__PURE__ */ new Map();
@@ -36969,7 +36699,7 @@ function collectLayoutElementRecordsForSolid(solid, selectorRequirements, inline
     const classTokenSet = classTokens.length === 0 ? EMPTY_CLASS_TOKEN_SET : createClassTokenSet(classTokens);
     const inlineStyleKeys = getStaticStyleKeysForElement(solid, element.id);
     const localAttributes = selectorRequirements.needsAttributes ? collectStaticAttributes(element) : EMPTY_ATTRIBUTES2;
-    const attributes = mergeAttributes(localAttributes, meta.resolvedHost?.descriptor.staticAttributes);
+    const attributes = mergeAttributes(localAttributes, meta.resolvedHost?.descriptor.staticAttributes, meta.resolvedHost?.descriptor.attributePropBindings);
     const selectorDispatchKeys = buildSelectorDispatchKeys(attributes, classTokens);
     const inlineStyleValues = inlineStyleValuesByElementId.get(element.id) ?? EMPTY_INLINE_STYLE_VALUES;
     const textualContent = getTextualContentState(element, textContentMemo, compositionMetaByElementId, logger);
@@ -37025,7 +36755,63 @@ function collectCompositionMetaByElementId(solid, componentHostResolver) {
 function resolveHostForElement(componentHostResolver, solidFile, element) {
   if (element.tag === null) return null;
   if (element.isDomElement) return null;
-  return componentHostResolver.resolveHost(solidFile, element.tag);
+  const defaultHost = componentHostResolver.resolveHost(solidFile, element.tag);
+  const asTag = extractPolymorphicAsTag(element);
+  if (asTag !== null) {
+    const asHost = componentHostResolver.resolveHost(solidFile, asTag);
+    if (asHost !== null) return composePolymorphicHost(defaultHost, asHost);
+  }
+  return defaultHost;
+}
+function extractPolymorphicAsTag(element) {
+  for (let i = 0; i < element.attributes.length; i++) {
+    const attr = element.attributes[i];
+    if (!attr) continue;
+    if (attr.name !== "as") continue;
+    if (attr.valueNode === null) continue;
+    if (!import_typescript126.default.isJsxExpression(attr.valueNode)) continue;
+    const expression = attr.valueNode.expression;
+    if (!expression) continue;
+    if (import_typescript126.default.isIdentifier(expression)) return expression.text;
+    if (import_typescript126.default.isPropertyAccessExpression(expression)) return expression.getText();
+    return null;
+  }
+  return null;
+}
+function composePolymorphicHost(outerHost, asHost) {
+  if (outerHost === null) return asHost;
+  const outerDesc = outerHost.descriptor;
+  const asDesc = asHost.descriptor;
+  const staticAttributes = /* @__PURE__ */ new Map();
+  for (const [name, value2] of outerDesc.staticAttributes) staticAttributes.set(name, value2);
+  for (const [name, value2] of asDesc.staticAttributes) staticAttributes.set(name, value2);
+  const classTokenSet = /* @__PURE__ */ new Set();
+  const staticClassTokens = [];
+  for (const token of outerDesc.staticClassTokens) {
+    if (!classTokenSet.has(token)) {
+      classTokenSet.add(token);
+      staticClassTokens.push(token);
+    }
+  }
+  for (const token of asDesc.staticClassTokens) {
+    if (!classTokenSet.has(token)) {
+      classTokenSet.add(token);
+      staticClassTokens.push(token);
+    }
+  }
+  const attributePropBindings = /* @__PURE__ */ new Map();
+  for (const [name, value2] of outerDesc.attributePropBindings) attributePropBindings.set(name, value2);
+  for (const [name, value2] of asDesc.attributePropBindings) attributePropBindings.set(name, value2);
+  return {
+    descriptor: {
+      tagName: asDesc.tagName ?? outerDesc.tagName,
+      staticAttributes,
+      staticClassTokens,
+      forwardsChildren: asDesc.forwardsChildren || outerDesc.forwardsChildren,
+      attributePropBindings
+    },
+    hostElementRef: asHost.hostElementRef ?? outerHost.hostElementRef
+  };
 }
 function resolveTransparentPrimitiveStatus(componentHostResolver, solidFile, element, resolvedHost) {
   if (element.tag === null) return false;
@@ -37068,11 +36854,21 @@ function mergeClassTokens(localTokens, hostTokens) {
   }
   return out;
 }
-function mergeAttributes(localAttributes, hostAttributes) {
+function mergeAttributes(localAttributes, hostAttributes, propBindings) {
   if (hostAttributes === void 0 || hostAttributes.size === 0) return localAttributes;
-  if (localAttributes.size === 0) return hostAttributes;
+  if (localAttributes.size === 0 && (propBindings === void 0 || propBindings.size === 0)) return hostAttributes;
   const out = /* @__PURE__ */ new Map();
   for (const [name, value2] of hostAttributes) {
+    if (propBindings !== void 0) {
+      const propName = propBindings.get(name);
+      if (propName !== void 0) {
+        const callSiteValue = localAttributes.get(propName);
+        if (callSiteValue !== void 0 && callSiteValue !== null) {
+          out.set(name, callSiteValue);
+          continue;
+        }
+      }
+    }
     out.set(name, value2);
   }
   for (const [name, value2] of localAttributes) {
@@ -37138,7 +36934,9 @@ function resolveSiblingTypeCount(totalsByParentId, parentElementId, tagName, sib
 
 // src/cross-file/layout/build.ts
 var EMPTY_NUMBER_LIST2 = [];
-var NON_RESERVING_DIMENSION_KEYWORDS = /* @__PURE__ */ new Set(["auto", "none", "fit-content", "min-content", "max-content", "stretch"]);
+var EMPTY_EDGE_LIST = Object.freeze([]);
+var NON_RESERVING_DIMENSION_KEYWORDS = /* @__PURE__ */ new Set(["auto", "none", "fit-content", "min-content", "max-content", "stretch", "inherit", "initial", "unset", "revert", "revert-layer"]);
+var BLOCK_LEVEL_DISPLAY_VALUES = /* @__PURE__ */ new Set(["block", "flex", "grid", "table", "list-item", "flow-root", "table-row", "table-cell", "table-caption", "table-row-group", "table-header-group", "table-footer-group", "table-column", "table-column-group"]);
 function buildLayoutGraph(solids, css, logger = noopLogger) {
   const perf = createLayoutPerfStats();
   const startedAt = performance.now();
@@ -37153,7 +36951,6 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
   const selectorsById = /* @__PURE__ */ new Map();
   const monitoredDeclarationsBySelectorId = /* @__PURE__ */ new Map();
   const selectorMetadataById = /* @__PURE__ */ new Map();
-  const cascadeByElementNode = /* @__PURE__ */ new WeakMap();
   for (let i = 0; i < css.selectors.length; i++) {
     const selector = css.selectors[i];
     if (!selector) continue;
@@ -37226,7 +37023,7 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
     };
     const textContentMemo = /* @__PURE__ */ new Map();
     const inlineStyleValuesByElementId = collectInlineStyleValuesByElementId(solid);
-    const records = collectLayoutElementRecordsForSolid(
+    const records2 = collectLayoutElementRecordsForSolid(
       solid,
       selectorRequirements,
       inlineStyleValuesByElementId,
@@ -37234,12 +37031,12 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
       componentHostResolver,
       logger
     );
-    const siblingTotals = collectSiblingTotals(records);
+    const siblingTotals = collectSiblingTotals(records2);
     const nodeByElementId = /* @__PURE__ */ new Map();
     const lastChildByParentId = /* @__PURE__ */ new Map();
     const siblingTypeSeenByParentId = /* @__PURE__ */ new Map();
-    for (let i = 0; i < records.length; i++) {
-      const record = records[i];
+    for (let i = 0; i < records2.length; i++) {
+      const record = records2[i];
       if (!record) continue;
       const parentElementId = record.parentElementId;
       const parentNode = parentElementId === null ? null : nodeByElementId.get(parentElementId) ?? null;
@@ -37304,6 +37101,7 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
       }
     }
   }
+  const fileElementIndexByFile = buildFileElementIndexByFile(elements);
   if (logger.isLevelEnabled(Level.Debug)) {
     for (const [file, roots] of rootElementsByFile) {
       const descs = roots.map((r) => `${r.key}(tag=${r.tagName}, attrs=[${[...r.attributes.entries()].map(([k, v]) => `${k}=${v}`).join(",")}])`);
@@ -37315,63 +37113,138 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
     selectorMetadataById,
     selectorsById,
     rootElementsByFile,
+    fileElementIndexByFile,
     perf,
     logger
   };
-  for (let i = 0; i < elements.length; i++) {
-    const node = elements[i];
-    if (!node) continue;
-    const selectorIds = selectorCandidatesByNode.get(node) ?? EMPTY_NUMBER_LIST2;
-    if (selectorIds.length === 0) continue;
-    appendMatchingEdgesFromSelectorIds(
-      selectorMatchCtx,
-      selectorIds,
-      node,
-      applies,
-      appliesByElementNodeMutable
-    );
-  }
-  perf.selectorMatchMs = performance.now() - selectorMatchStartedAt;
-  const cascadeStartedAt = performance.now();
-  for (const edges of appliesByElementNodeMutable.values()) {
-    edges.sort(compareLayoutEdge);
-  }
-  const appliesByNode = /* @__PURE__ */ new Map();
   const tailwind = css.tailwind;
+  const records = /* @__PURE__ */ new Map();
+  const snapshotByElementNode = /* @__PURE__ */ new WeakMap();
+  const snapshotHotSignalsByNode = /* @__PURE__ */ new Map();
+  const elementsByTagName = /* @__PURE__ */ new Map();
+  const elementsByKnownSignalValue = /* @__PURE__ */ new Map();
+  const dynamicSlotCandidateElements = [];
+  const scrollContainerElements = [];
+  const positionedAncestorByKey = /* @__PURE__ */ new Map();
+  const trace = logger.isLevelEnabled(Level.Trace);
   for (let i = 0; i < elements.length; i++) {
     const node = elements[i];
     if (!node) continue;
-    const edges = appliesByElementNodeMutable.get(node) ?? [];
-    const cascade = buildCascadeMapForElement(node, edges, monitoredDeclarationsBySelectorId, tailwind);
-    cascadeByElementNode.set(node, cascade);
-    appliesByNode.set(node, edges);
-  }
-  perf.cascadeBuildMs = performance.now() - cascadeStartedAt;
-  if (logger.isLevelEnabled(Level.Trace)) {
-    for (let i = 0; i < elements.length; i++) {
-      const node = elements[i];
-      if (!node) continue;
-      const cascade = cascadeByElementNode.get(node);
-      if (!cascade || cascade.size === 0) continue;
+    const selectorIds = selectorCandidatesByNode.get(node) ?? EMPTY_NUMBER_LIST2;
+    if (selectorIds.length > 0) {
+      appendMatchingEdgesFromSelectorIds(
+        selectorMatchCtx,
+        selectorIds,
+        node,
+        applies,
+        appliesByElementNodeMutable
+      );
+    }
+    const mutableEdges = appliesByElementNodeMutable.get(node);
+    if (mutableEdges) mutableEdges.sort(compareLayoutEdge);
+    const edges = mutableEdges ?? EMPTY_EDGE_LIST;
+    const cascade = buildCascadeMapForElement(node, edges, monitoredDeclarationsBySelectorId, tailwind, css.variablesByName);
+    if (trace && cascade.size > 0) {
       const displayDecl = cascade.get("display");
       const flexDirDecl = cascade.get("flex-direction");
-      if (!displayDecl && !flexDirDecl) continue;
-      const displayGuard = displayDecl?.guardProvenance.kind === 1 /* Conditional */ ? "conditional" : "unconditional";
-      const flexDirGuard = flexDirDecl?.guardProvenance.kind === 1 /* Conditional */ ? "conditional" : "unconditional";
-      logger.trace(
-        `[cascade] node=${node.key} tag=${node.tagName ?? "null"} display=${displayDecl ? `${displayDecl.value}(${displayGuard})` : "absent"} flex-direction=${flexDirDecl ? `${flexDirDecl.value}(${flexDirGuard})` : "absent"} edges=${(appliesByNode.get(node) ?? []).length} attrs=[${[...node.attributes.keys()].join(",")}]`
-      );
+      if (displayDecl || flexDirDecl) {
+        const displayGuard = displayDecl?.guardProvenance.kind === 1 /* Conditional */ ? "conditional" : "unconditional";
+        const flexDirGuard = flexDirDecl?.guardProvenance.kind === 1 /* Conditional */ ? "conditional" : "unconditional";
+        logger.trace(
+          `[cascade] node=${node.key} tag=${node.tagName ?? "null"} display=${displayDecl ? `${displayDecl.value}(${displayGuard})` : "absent"} flex-direction=${flexDirDecl ? `${flexDirDecl.value}(${flexDirGuard})` : "absent"} edges=${edges.length} attrs=[${[...node.attributes.keys()].join(",")}]`
+        );
+      }
+    }
+    const parentSnapshot = node.parentElementNode ? records.get(node.parentElementNode)?.snapshot ?? null : null;
+    const snapshot = buildSnapshotFromCascade(node, cascade, parentSnapshot);
+    snapshotByElementNode.set(node, snapshot);
+    perf.signalSnapshotsBuilt++;
+    if (node.textualContent === 2 /* Unknown */ && node.siblingCount >= 2) {
+      dynamicSlotCandidateElements.push(node);
+    }
+    if (node.tagName) {
+      const existing = elementsByTagName.get(node.tagName);
+      if (existing) existing.push(node);
+      else elementsByTagName.set(node.tagName, [node]);
+    }
+    for (const [signal, value2] of snapshot.signals) {
+      if (value2.kind !== 0 /* Known */) continue;
+      let byValue = elementsByKnownSignalValue.get(signal);
+      if (!byValue) {
+        byValue = /* @__PURE__ */ new Map();
+        elementsByKnownSignalValue.set(signal, byValue);
+      }
+      const existingNodes = byValue.get(value2.normalized);
+      if (existingNodes) existingNodes.push(node);
+      else byValue.set(value2.normalized, [node]);
     }
+    const parentKey = node.parentElementNode?.key ?? null;
+    let nearestPositionedAncestorKey = null;
+    let nearestPositionedAncestorHasReservedSpace = false;
+    if (parentKey !== null) {
+      const parentPositioned = positionedAncestorByKey.get(parentKey);
+      if (parentPositioned !== void 0) {
+        nearestPositionedAncestorKey = parentPositioned.key;
+        nearestPositionedAncestorHasReservedSpace = parentPositioned.hasReservedSpace;
+      }
+    }
+    const containingBlock = {
+      nearestPositionedAncestorKey,
+      nearestPositionedAncestorHasReservedSpace
+    };
+    const reservedSpace = computeReservedSpaceFact(snapshot);
+    const scrollContainer = computeScrollContainerFact(snapshot);
+    if (scrollContainer.isScrollContainer) scrollContainerElements.push(node);
+    const flowParticipation = computeFlowParticipationFact(snapshot);
+    const hotSignals = computeHotSignals(snapshot);
+    snapshotHotSignalsByNode.set(node, hotSignals);
+    const positionSignal = snapshot.signals.get("position");
+    const isPositioned = positionSignal !== void 0 && positionSignal.kind === 0 /* Known */ && positionSignal.normalized !== "static";
+    if (isPositioned) {
+      positionedAncestorByKey.set(node.key, { key: node.key, hasReservedSpace: reservedSpace.hasReservedSpace });
+    } else if (parentKey !== null) {
+      const inherited = positionedAncestorByKey.get(parentKey);
+      if (inherited !== void 0) positionedAncestorByKey.set(node.key, inherited);
+    }
+    records.set(node, {
+      ref: elementRefsBySolidFileAndIdMutable.get(node.solidFile)?.get(node.elementId) ?? null,
+      edges,
+      cascade,
+      snapshot,
+      hotSignals,
+      reservedSpace,
+      scrollContainer,
+      flowParticipation,
+      containingBlock,
+      conditionalDelta: null,
+      baselineOffsets: null
+    });
   }
-  const snapshotByElementNode = buildSignalSnapshotIndex(elements, cascadeByElementNode, perf);
-  const measurementNodeByRootKey = buildMeasurementNodeIndex(elements, childrenByParentNodeMutable, snapshotByElementNode);
-  const factIndex = buildElementFactIndex(elements, snapshotByElementNode);
+  perf.selectorMatchMs = performance.now() - selectorMatchStartedAt;
   const conditionalDeltaIndex = buildConditionalDeltaIndex(
     elements,
-    appliesByNode,
+    records,
     monitoredDeclarationsBySelectorId,
     selectorsById
   );
+  for (const [node, deltaByProperty] of conditionalDeltaIndex.conditionalSignalDeltaFactsByNode) {
+    const record = records.get(node);
+    if (!record) continue;
+    const baselineOffsets = conditionalDeltaIndex.baselineOffsetFactsByNode.get(node) ?? null;
+    records.set(node, {
+      ref: record.ref,
+      edges: record.edges,
+      cascade: record.cascade,
+      snapshot: record.snapshot,
+      hotSignals: record.hotSignals,
+      reservedSpace: record.reservedSpace,
+      scrollContainer: record.scrollContainer,
+      flowParticipation: record.flowParticipation,
+      containingBlock: record.containingBlock,
+      conditionalDelta: deltaByProperty,
+      baselineOffsets
+    });
+  }
   const elementsWithConditionalOverflowDelta = buildConditionalDeltaSignalGroupElements(
     conditionalDeltaIndex.elementsWithConditionalDeltaBySignal,
     ["overflow", "overflow-y"]
@@ -37380,6 +37253,7 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
     conditionalDeltaIndex.elementsWithConditionalDeltaBySignal,
     layoutOffsetSignals
   );
+  const measurementNodeByRootKey = buildMeasurementNodeIndex(elements, childrenByParentNodeMutable, snapshotByElementNode);
   const statefulRuleIndexes = buildStatefulRuleIndexes(css.rules);
   const contextByParentNode = buildContextIndex(childrenByParentNodeMutable, snapshotByElementNode, perf, logger);
   const cohortIndex = buildCohortIndex({
@@ -37387,7 +37261,7 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
     contextByParentNode,
     measurementNodeByRootKey,
     snapshotByElementNode,
-    snapshotHotSignalsByNode: factIndex.snapshotHotSignalsByNode
+    snapshotHotSignalsByNode
   });
   finalizeTableCellBaselineRelevance(contextByParentNode, cohortIndex.verticalAlignConsensusByParent);
   perf.conditionalSignals = cohortIndex.conditionalSignals;
@@ -37404,122 +37278,71 @@ function buildLayoutGraph(solids, css, logger = noopLogger) {
     elementBySolidFileAndId: elementBySolidFileAndIdMutable,
     elementRefsBySolidFileAndId: elementRefsBySolidFileAndIdMutable,
     hostElementRefsByNode: hostElementRefsByNodeMutable,
-    appliesByNode,
     selectorCandidatesByNode,
     selectorsById,
     measurementNodeByRootKey,
-    snapshotHotSignalsByNode: factIndex.snapshotHotSignalsByNode,
-    elementsByTagName: factIndex.elementsByTagName,
+    records,
+    elementsByTagName,
     elementsWithConditionalDeltaBySignal: conditionalDeltaIndex.elementsWithConditionalDeltaBySignal,
     elementsWithConditionalOverflowDelta,
     elementsWithConditionalOffsetDelta,
-    elementsByKnownSignalValue: factIndex.elementsByKnownSignalValue,
-    dynamicSlotCandidateElements: factIndex.dynamicSlotCandidateElements,
-    scrollContainerElements: factIndex.scrollContainerElements,
-    reservedSpaceFactsByNode: factIndex.reservedSpaceFactsByNode,
-    scrollContainerFactsByNode: factIndex.scrollContainerFactsByNode,
-    flowParticipationFactsByNode: factIndex.flowParticipationFactsByNode,
-    containingBlockFactsByNode: factIndex.containingBlockFactsByNode,
-    conditionalSignalDeltaFactsByNode: conditionalDeltaIndex.conditionalSignalDeltaFactsByNode,
-    baselineOffsetFactsByNode: conditionalDeltaIndex.baselineOffsetFactsByNode,
+    elementsByKnownSignalValue,
+    dynamicSlotCandidateElements,
+    scrollContainerElements,
     statefulSelectorEntriesByRuleId: statefulRuleIndexes.selectorEntriesByRuleId,
     statefulNormalizedDeclarationsByRuleId: statefulRuleIndexes.normalizedDeclarationsByRuleId,
     statefulBaseValueIndex: statefulRuleIndexes.baseValueIndex,
     cohortStatsByParentNode: cohortIndex.statsByParentNode,
-    cascadeByElementNode,
-    snapshotByElementNode,
     contextByParentNode,
     perf
   };
 }
-function buildElementFactIndex(elements, snapshotByElementNode) {
-  const reservedSpaceFactsByNode = /* @__PURE__ */ new Map();
-  const scrollContainerFactsByNode = /* @__PURE__ */ new Map();
-  const flowParticipationFactsByNode = /* @__PURE__ */ new Map();
-  const containingBlockFactsByNode = /* @__PURE__ */ new Map();
-  const snapshotHotSignalsByNode = /* @__PURE__ */ new Map();
-  const elementsByTagName = /* @__PURE__ */ new Map();
-  const elementsByKnownSignalValue = /* @__PURE__ */ new Map();
-  const dynamicSlotCandidateElements = [];
-  const scrollContainerElements = [];
-  const positionedAncestorByKey = /* @__PURE__ */ new Map();
+function buildFileElementIndexByFile(elements) {
+  const byFileDispatch = /* @__PURE__ */ new Map();
+  const byFileTag = /* @__PURE__ */ new Map();
   for (let i = 0; i < elements.length; i++) {
     const node = elements[i];
     if (!node) continue;
-    const snapshot = snapshotByElementNode.get(node);
-    if (node.textualContent === 2 /* Unknown */ && node.siblingCount >= 2) {
-      dynamicSlotCandidateElements.push(node);
-    }
-    if (node.tagName) {
-      const existing = elementsByTagName.get(node.tagName);
+    if (node.parentElementNode === null) continue;
+    const file = node.solidFile;
+    let dispatchMap = byFileDispatch.get(file);
+    if (!dispatchMap) {
+      dispatchMap = /* @__PURE__ */ new Map();
+      byFileDispatch.set(file, dispatchMap);
+    }
+    const keys = node.selectorDispatchKeys;
+    for (let j = 0; j < keys.length; j++) {
+      const key = keys[j];
+      if (!key) continue;
+      const existing = dispatchMap.get(key);
       if (existing) {
         existing.push(node);
       } else {
-        elementsByTagName.set(node.tagName, [node]);
+        dispatchMap.set(key, [node]);
       }
     }
-    const parentKey = node.parentElementNode?.key ?? null;
-    let nearestPositionedAncestorKey = null;
-    let nearestPositionedAncestorHasReservedSpace = false;
-    if (parentKey !== null) {
-      const parentPositioned = positionedAncestorByKey.get(parentKey);
-      if (parentPositioned !== void 0) {
-        nearestPositionedAncestorKey = parentPositioned.key;
-        nearestPositionedAncestorHasReservedSpace = parentPositioned.hasReservedSpace;
+    if (node.tagName !== null) {
+      let tagMap = byFileTag.get(file);
+      if (!tagMap) {
+        tagMap = /* @__PURE__ */ new Map();
+        byFileTag.set(file, tagMap);
       }
-    }
-    containingBlockFactsByNode.set(node, {
-      nearestPositionedAncestorKey,
-      nearestPositionedAncestorHasReservedSpace
-    });
-    if (!snapshot) continue;
-    const reservedSpaceFact = computeReservedSpaceFact(snapshot);
-    reservedSpaceFactsByNode.set(node, reservedSpaceFact);
-    const scrollFact = computeScrollContainerFact(snapshot);
-    scrollContainerFactsByNode.set(node, scrollFact);
-    if (scrollFact.isScrollContainer) scrollContainerElements.push(node);
-    flowParticipationFactsByNode.set(node, computeFlowParticipationFact(snapshot));
-    snapshotHotSignalsByNode.set(node, computeHotSignals(snapshot));
-    const positionSignal = snapshot.signals.get("position");
-    const isPositioned = positionSignal !== void 0 && positionSignal.kind === "known" && positionSignal.normalized !== "static";
-    if (isPositioned) {
-      positionedAncestorByKey.set(node.key, {
-        key: node.key,
-        hasReservedSpace: reservedSpaceFact.hasReservedSpace
-      });
-    } else if (parentKey !== null) {
-      const inherited = positionedAncestorByKey.get(parentKey);
-      if (inherited !== void 0) {
-        positionedAncestorByKey.set(node.key, inherited);
-      }
-    }
-    for (const [signal, value2] of snapshot.signals) {
-      if (value2.kind !== "known") continue;
-      const normalized = value2.normalized;
-      let byValue = elementsByKnownSignalValue.get(signal);
-      if (!byValue) {
-        byValue = /* @__PURE__ */ new Map();
-        elementsByKnownSignalValue.set(signal, byValue);
-      }
-      const existingNodes = byValue.get(normalized);
-      if (existingNodes) {
-        existingNodes.push(node);
+      const existing = tagMap.get(node.tagName);
+      if (existing) {
+        existing.push(node);
       } else {
-        byValue.set(normalized, [node]);
+        tagMap.set(node.tagName, [node]);
       }
     }
   }
-  return {
-    reservedSpaceFactsByNode,
-    scrollContainerFactsByNode,
-    scrollContainerElements,
-    flowParticipationFactsByNode,
-    containingBlockFactsByNode,
-    snapshotHotSignalsByNode,
-    elementsByTagName,
-    elementsByKnownSignalValue,
-    dynamicSlotCandidateElements
-  };
+  const out = /* @__PURE__ */ new Map();
+  for (const [file, dispatchMap] of byFileDispatch) {
+    out.set(file, {
+      byDispatchKey: dispatchMap,
+      byTagName: byFileTag.get(file) ?? /* @__PURE__ */ new Map()
+    });
+  }
+  return out;
 }
 var ABSENT_NUMERIC = Object.freeze({
   present: false,
@@ -37532,7 +37355,7 @@ var ABSENT_NORMALIZED = Object.freeze({
   kind: 3 /* Unknown */
 });
 function toHotNumeric(signal) {
-  if (signal.kind !== "known") {
+  if (signal.kind !== 0 /* Known */) {
     return {
       present: true,
       value: null,
@@ -37542,11 +37365,11 @@ function toHotNumeric(signal) {
   return {
     present: true,
     value: signal.px,
-    kind: signal.guard.kind === 1 /* Conditional */ ? 2 /* Conditional */ : signal.quality === "estimated" ? 1 /* Interval */ : 0 /* Exact */
+    kind: signal.guard.kind === 1 /* Conditional */ ? 2 /* Conditional */ : signal.quality === 1 /* Estimated */ ? 1 /* Interval */ : 0 /* Exact */
   };
 }
 function toHotNormalized(signal) {
-  if (signal.kind !== "known") {
+  if (signal.kind !== 0 /* Known */) {
     return {
       present: true,
       value: null,
@@ -37556,7 +37379,7 @@ function toHotNormalized(signal) {
   return {
     present: true,
     value: signal.normalized,
-    kind: signal.guard.kind === 1 /* Conditional */ ? 2 /* Conditional */ : signal.quality === "estimated" ? 1 /* Interval */ : 0 /* Exact */
+    kind: signal.guard.kind === 1 /* Conditional */ ? 2 /* Conditional */ : signal.quality === 1 /* Estimated */ ? 1 /* Interval */ : 0 /* Exact */
   };
 }
 function computeHotSignals(snapshot) {
@@ -37671,62 +37494,61 @@ function computeHotSignals(snapshot) {
 }
 function computeReservedSpaceFact(snapshot) {
   const reasons = [];
-  const hasHeight = hasPositiveOrDeclaredDimension(snapshot, "height");
+  const hasHeight = hasDeclaredDimension(snapshot, "height");
   if (hasHeight) reasons.push("height");
-  const hasBlockSize = hasPositiveOrDeclaredDimension(snapshot, "block-size");
+  const hasBlockSize = hasDeclaredDimension(snapshot, "block-size");
   if (hasBlockSize) reasons.push("block-size");
-  const hasMinHeight = hasPositiveOrDeclaredDimension(snapshot, "min-height");
+  const hasMinHeight = hasDeclaredDimension(snapshot, "min-height");
   if (hasMinHeight) reasons.push("min-height");
-  const hasMinBlockSize = hasPositiveOrDeclaredDimension(snapshot, "min-block-size");
+  const hasMinBlockSize = hasDeclaredDimension(snapshot, "min-block-size");
   if (hasMinBlockSize) reasons.push("min-block-size");
-  const hasContainIntrinsic = hasPositiveOrDeclaredDimension(snapshot, "contain-intrinsic-size");
+  const hasContainIntrinsic = hasDeclaredDimension(snapshot, "contain-intrinsic-size");
   if (hasContainIntrinsic) reasons.push("contain-intrinsic-size");
   const hasAspectRatio = hasUsableAspectRatio(snapshot);
   if (hasAspectRatio) {
-    if (hasPositiveOrDeclaredDimension(snapshot, "width")) reasons.push("aspect-ratio+width");
-    if (hasPositiveOrDeclaredDimension(snapshot, "inline-size")) reasons.push("aspect-ratio+inline-size");
-    if (hasPositiveOrDeclaredDimension(snapshot, "min-width")) reasons.push("aspect-ratio+min-width");
+    if (hasDeclaredDimension(snapshot, "width")) reasons.push("aspect-ratio+width");
+    if (hasDeclaredDimension(snapshot, "inline-size")) reasons.push("aspect-ratio+inline-size");
+    if (hasDeclaredDimension(snapshot, "min-width")) reasons.push("aspect-ratio+min-width");
     if (hasMinBlockSize) reasons.push("aspect-ratio+min-block-size");
     if (hasMinHeight) reasons.push("aspect-ratio+min-height");
   }
   return {
     hasReservedSpace: reasons.length > 0,
     reasons,
-    hasUsableInlineDimension: hasPositiveOrDeclaredDimension(snapshot, "width") || hasPositiveOrDeclaredDimension(snapshot, "inline-size") || hasPositiveOrDeclaredDimension(snapshot, "min-width"),
-    hasUsableBlockDimension: hasHeight || hasBlockSize || hasMinHeight || hasMinBlockSize,
     hasContainIntrinsicSize: hasContainIntrinsic,
-    hasUsableAspectRatio: hasAspectRatio
+    hasUsableAspectRatio: hasAspectRatio,
+    hasDeclaredBlockDimension: hasHeight || hasBlockSize || hasMinHeight || hasMinBlockSize,
+    hasDeclaredInlineDimension: hasDeclaredDimension(snapshot, "width") || hasDeclaredDimension(snapshot, "inline-size") || hasDeclaredDimension(snapshot, "min-width") || hasDeclaredDimension(snapshot, "flex-basis") || isBlockLevelDisplay(snapshot)
   };
 }
-function hasPositiveOrDeclaredDimension(snapshot, property) {
+function hasDeclaredDimension(snapshot, property) {
   const signal = snapshot.signals.get(property);
   if (!signal) return false;
-  if (signal.guard.kind !== 0 /* Unconditional */) return false;
-  let normalized = "";
-  if (signal.kind === "known") {
+  if (signal.kind === 0 /* Known */) {
     if (signal.px !== null) return signal.px > 0;
-    normalized = signal.normalized.trim().toLowerCase();
+    if (signal.normalized.length === 0) return false;
+    return !isNonReservingDimension(signal.normalized);
   }
-  if (signal.kind === "unknown") {
+  if (signal.kind === 1 /* Unknown */) {
     return signal.source !== null;
   }
-  if (normalized.length === 0) return false;
-  if (isNonReservingDimension(normalized)) return false;
-  return true;
+  return false;
+}
+function isBlockLevelDisplay(snapshot) {
+  const signal = snapshot.signals.get("display");
+  if (!signal || signal.kind !== 0 /* Known */) return false;
+  return BLOCK_LEVEL_DISPLAY_VALUES.has(signal.normalized);
 }
 function hasUsableAspectRatio(snapshot) {
   const signal = snapshot.signals.get("aspect-ratio");
   if (!signal) return false;
   if (signal.guard.kind !== 0 /* Unconditional */) return false;
-  if (signal.kind === "unknown") {
+  if (signal.kind === 1 /* Unknown */) {
     return false;
   }
-  let normalized = "";
-  if (signal.kind === "known") {
-    normalized = signal.normalized.trim().toLowerCase();
-  }
-  if (normalized.length === 0) return false;
-  return normalized !== "auto";
+  if (signal.kind !== 0 /* Known */) return false;
+  if (signal.normalized.length === 0) return false;
+  return signal.normalized !== "auto";
 }
 function isNonReservingDimension(value2) {
   if (NON_RESERVING_DIMENSION_KEYWORDS.has(value2)) return true;
@@ -37736,8 +37558,8 @@ function isNonReservingDimension(value2) {
 function computeScrollContainerFact(snapshot) {
   const overflowSignal = snapshot.signals.get("overflow");
   const overflowYSignal = snapshot.signals.get("overflow-y");
-  const overflow = overflowSignal && overflowSignal.kind === "known" ? overflowSignal.normalized : null;
-  const overflowY = overflowYSignal && overflowYSignal.kind === "known" ? overflowYSignal.normalized : null;
+  const overflow = overflowSignal && overflowSignal.kind === 0 /* Known */ ? overflowSignal.normalized : null;
+  const overflowY = overflowYSignal && overflowYSignal.kind === 0 /* Known */ ? overflowYSignal.normalized : null;
   const shorthandAxis = parseOverflowShorthandAxis(overflow);
   const yFromLonghand = parseSingleAxisScroll(overflowY);
   const xScroll = shorthandAxis.x;
@@ -37785,7 +37607,7 @@ function toScrollAxis(x, y) {
 }
 function computeFlowParticipationFact(snapshot) {
   const signal = snapshot.signals.get("position");
-  if (!signal || signal.kind !== "known") {
+  if (!signal || signal.kind !== 0 /* Known */) {
     return {
       inFlow: true,
       position: null,
@@ -37817,8 +37639,8 @@ function buildContextIndex(childrenByParentNode, snapshotByElementNode, perf, lo
     if (trace) {
       const displaySignal = snapshot.signals.get("display");
       const flexDirSignal = snapshot.signals.get("flex-direction");
-      const displayDesc = displaySignal ? `${displaySignal.kind}:${displaySignal.kind === "known" ? displaySignal.normalized : "?"}(guard=${displaySignal.guard.kind === 1 /* Conditional */ ? "conditional" : "unconditional"})` : "absent";
-      const flexDirDesc = flexDirSignal ? `${flexDirSignal.kind}:${flexDirSignal.kind === "known" ? flexDirSignal.normalized : "?"}(guard=${flexDirSignal.guard.kind === 1 /* Conditional */ ? "conditional" : "unconditional"})` : "absent";
+      const displayDesc = displaySignal ? `${displaySignal.kind}:${displaySignal.kind === 0 /* Known */ ? displaySignal.normalized : "?"}(guard=${displaySignal.guard.kind === 1 /* Conditional */ ? "conditional" : "unconditional"})` : "absent";
+      const flexDirDesc = flexDirSignal ? `${flexDirSignal.kind}:${flexDirSignal.kind === 0 /* Known */ ? flexDirSignal.normalized : "?"}(guard=${flexDirSignal.guard.kind === 1 /* Conditional */ ? "conditional" : "unconditional"})` : "absent";
       logger.trace(
         `[context] parent=${parent.key} tag=${parent.tagName ?? "null"} children=${children.length} display=${displayDesc} flex-direction=${flexDirDesc} \u2192 kind=${ctx.kind} certainty=${ctx.certainty} crossAxisIsBlockAxis=${ctx.crossAxisIsBlockAxis} baseline=${ctx.baselineRelevance}`
       );
@@ -39980,8 +39802,8 @@ function hasReservedSize(solid, attributes, element, reservedSpaceFact, hostElem
   const hostJsxWidth = hostElementRef !== null ? readPositiveJsxAttribute(hostElementRef.solid, hostElementRef.element, "width") : false;
   const hostJsxHeight = hostElementRef !== null ? readPositiveJsxAttribute(hostElementRef.solid, hostElementRef.element, "height") : false;
   if (attrWidth && attrHeight || jsxAttrWidth && jsxAttrHeight || hostJsxWidth && hostJsxHeight) return true;
-  const hasAnyWidth = attrWidth || jsxAttrWidth || hostJsxWidth || reservedSpaceFact.hasUsableInlineDimension;
-  const hasAnyHeight = attrHeight || jsxAttrHeight || hostJsxHeight || reservedSpaceFact.hasUsableBlockDimension || reservedSpaceFact.hasContainIntrinsicSize;
+  const hasAnyWidth = attrWidth || jsxAttrWidth || hostJsxWidth || reservedSpaceFact.hasDeclaredInlineDimension;
+  const hasAnyHeight = attrHeight || jsxAttrHeight || hostJsxHeight || reservedSpaceFact.hasDeclaredBlockDimension || reservedSpaceFact.hasContainIntrinsicSize;
   if (reservedSpaceFact.hasUsableAspectRatio && (hasAnyWidth || hasAnyHeight)) return true;
   if (reservedSpaceFact.hasContainIntrinsicSize && (hasAnyWidth || hasAnyHeight)) return true;
   return false;
@@ -40458,7 +40280,7 @@ function collectConditionalOffsets(layout, node, snapshot) {
     const signal = snapshot.signals.get(name);
     if (!signal) continue;
     if (signal.guard.kind !== 1 /* Conditional */) continue;
-    if (signal.kind !== "known") continue;
+    if (signal.kind !== 0 /* Known */) continue;
     if (signal.px === null) continue;
     if (Math.abs(signal.px) <= 0.25) continue;
     out.push({ property: name, value: signal.px, guardKey: signal.guard.key });
@@ -40481,7 +40303,7 @@ function hasEffectivePositionForConditionalOffset(snapshot, guardKey) {
   if (hasEffectivePosition(snapshot)) return true;
   const position = snapshot.signals.get("position");
   if (!position) return false;
-  if (position.kind !== "known") return false;
+  if (position.kind !== 0 /* Known */) return false;
   if (position.guard.kind !== 1 /* Conditional */) return false;
   if (position.guard.key !== guardKey) return false;
   return position.normalized !== "static";
@@ -40941,6 +40763,9 @@ function isVisuallyHidden(snapshot) {
   const opacityAttr = node.inlineStyleValues.get("opacity");
   if (opacityAttr === "0") return true;
   if (node.classTokenSet.has("opacity-0")) return true;
+  const width = readKnownPx(snapshot, "width");
+  const height = readKnownPx(snapshot, "height");
+  if (width === 1 && height === 1) return true;
   return false;
 }
 var jsxLayoutPolicyTouchTarget = defineCrossRule({
@@ -40992,6 +40817,18 @@ var jsxLayoutPolicyTouchTarget = defineCrossRule({
         tag,
         policyName
       );
+      checkDimension(
+        snapshot,
+        "max-height",
+        kind === "button" ? policy.minButtonHeight : policy.minInputHeight,
+        layout,
+        node,
+        emit,
+        "heightTooSmall",
+        messages161.heightTooSmall,
+        tag,
+        policyName
+      );
       checkDimension(
         snapshot,
         "width",
@@ -41016,6 +40853,18 @@ var jsxLayoutPolicyTouchTarget = defineCrossRule({
         tag,
         policyName
       );
+      checkDimension(
+        snapshot,
+        "max-width",
+        kind === "button" ? policy.minButtonWidth : policy.minTouchTarget,
+        layout,
+        node,
+        emit,
+        "widthTooSmall",
+        messages161.widthTooSmall,
+        tag,
+        policyName
+      );
       if (kind === "button") {
         checkDimension(
           snapshot,
@@ -41045,7 +40894,7 @@ var jsxLayoutPolicyTouchTarget = defineCrossRule({
       const reservedSpace = readReservedSpaceFact(layout, node);
       const minBlock = kind === "button" ? policy.minButtonHeight : policy.minInputHeight;
       const minInline = kind === "button" ? policy.minButtonWidth : policy.minTouchTarget;
-      if (!reservedSpace.hasUsableBlockDimension) {
+      if (!reservedSpace.hasDeclaredBlockDimension) {
         emitLayoutDiagnostic(
           layout,
           node,
@@ -41057,7 +40906,7 @@ var jsxLayoutPolicyTouchTarget = defineCrossRule({
           { tag, min: String(minBlock), policy: policyName }
         );
       }
-      if (!reservedSpace.hasUsableInlineDimension) {
+      if (!reservedSpace.hasDeclaredInlineDimension) {
         emitLayoutDiagnostic(
           layout,
           node,