@tenphi/tasty 2.0.3 → 2.0.4

package/dist/pipeline/materialize.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"materialize.js","names":[],"sources":["../../src/pipeline/materialize.ts"],"sourcesContent":["/**\n * CSS Materialization\n *\n * Converts condition trees into CSS selectors and at-rules.\n * This is the final stage that produces actual CSS output.\n */\n\nimport { Lru } from '../parser/lru';\n\nimport type {\n  ConditionNode,\n  ContainerCondition,\n  MediaCondition,\n  ModifierCondition,\n  PseudoCondition,\n  StateCondition,\n  SupportsCondition,\n} from './conditions';\nimport {\n  and,\n  getConditionUniqueId,\n  isCompoundCondition,\n  not,\n} from './conditions';\nimport { simplifyCondition } from './simplify';\nimport {\n  dedupeContainerConditions,\n  dedupeMediaConditions,\n  dedupeSupportsConditions,\n  hasContainerStyleContradiction,\n  hasMediaContradiction,\n  hasSupportsContradiction,\n} from './materialize-contradictions';\nimport type {\n  CSSComponents,\n  CSSRule,\n  ParentGroup,\n  ParsedContainerCondition,\n  ParsedMediaCondition,\n  ParsedModifierCondition,\n  ParsedPseudoCondition,\n  ParsedSelectorCondition,\n  ParsedSupportsCondition,\n  SelectorGroup,\n  SelectorVariant,\n} from './materialize-types';\n\n// Re-export types so existing `import { ... } from './materialize'` keeps\n// working without callers needing to chase the new file layout.\nexport type {\n  CSSComponents,\n  CSSRule,\n  ParentGroup,\n  ParsedContainerCondition,\n  ParsedMediaCondition,\n  ParsedModifierCondition,\n  ParsedPseudoCondition,\n  ParsedSelectorCondition,\n  ParsedSupportsCondition,\n  SelectorGroup,\n  SelectorVariant,\n};\n\n// ============================================================================\n// Caching\n// ============================================================================\n\nconst conditionCache = new Lru<string, CSSComponents>(3000);\n\n// ============================================================================\n// Main Functions\n// ============================================================================\n\n/**\n * Convert a condition tree to CSS components\n */\nexport function conditionToCSS(node: ConditionNode): CSSComponents {\n  // Check cache\n  const key = getConditionUniqueId(node);\n  const cached = conditionCache.get(key);\n  if (cached) {\n    return cached;\n  }\n\n  const result = conditionToCSSInner(node);\n\n  // Cache result\n  conditionCache.set(key, result);\n\n  return result;\n}\n\n/**\n * Clear the condition cache (for testing)\n */\nexport function clearConditionCache(): void {\n  conditionCache.clear();\n}\n\n// ============================================================================\n// Inner Implementation\n// ============================================================================\n\nfunction emptyVariant(): SelectorVariant {\n  return {\n    modifierConditions: [],\n    pseudoConditions: [],\n    selectorGroups: [],\n    ownGroups: [],\n    mediaConditions: [],\n    containerConditions: [],\n    supportsConditions: [],\n    rootGroups: [],\n    parentGroups: [],\n    startingStyle: false,\n  };\n}\n\nfunction conditionToCSSInner(node: ConditionNode): CSSComponents {\n  // Base case: TRUE condition - single empty variant (matches everything)\n  if (node.kind === 'true') {\n    return {\n      variants: [emptyVariant()],\n      isImpossible: false,\n    };\n  }\n\n  // Base case: FALSE condition - no variants (matches nothing)\n  if (node.kind === 'false') {\n    return {\n      variants: [],\n      isImpossible: true,\n    };\n  }\n\n  // State condition\n  if (node.kind === 'state') {\n    return stateToCSS(node);\n  }\n\n  // Compound condition\n  if (node.kind === 'compound') {\n    if (node.operator === 'AND') {\n      return andToCSS(node.children);\n    } else {\n      return orToCSS(node.children);\n    }\n  }\n\n  // Fallback - single empty variant\n  return {\n    variants: [emptyVariant()],\n    isImpossible: false,\n  };\n}\n\n/**\n * Convert a state condition to CSS\n */\nfunction stateToCSS(state: StateCondition): CSSComponents {\n  switch (state.type) {\n    case 'media': {\n      const mediaResults = mediaToParsed(state);\n      const variants = mediaResults.map((mediaCond) => {\n        const v = emptyVariant();\n        v.mediaConditions.push(mediaCond);\n        return v;\n      });\n      return { variants, isImpossible: false };\n    }\n\n    case 'root':\n      return innerConditionToVariants(\n        state.innerCondition,\n        state.negated ?? false,\n        'rootGroups',\n      );\n\n    case 'parent':\n      return parentConditionToVariants(\n        state.innerCondition,\n        state.negated ?? false,\n        state.direct,\n      );\n\n    case 'own':\n      return innerConditionToVariants(\n        state.innerCondition,\n        state.negated ?? false,\n        'ownGroups',\n      );\n\n    case 'modifier': {\n      const v = emptyVariant();\n      v.modifierConditions.push(modifierToParsed(state));\n      return { variants: [v], isImpossible: false };\n    }\n\n    case 'pseudo': {\n      const v = emptyVariant();\n      v.pseudoConditions.push(pseudoToParsed(state));\n      return { variants: [v], isImpossible: false };\n    }\n\n    case 'container': {\n      const v = emptyVariant();\n      v.containerConditions.push(containerToParsed(state));\n      return { variants: [v], isImpossible: false };\n    }\n\n    case 'supports': {\n      const v = emptyVariant();\n      v.supportsConditions.push(supportsToParsed(state));\n      return { variants: [v], isImpossible: false };\n    }\n\n    case 'starting': {\n      const v = emptyVariant();\n      v.startingStyle = !state.negated;\n      return { variants: [v], isImpossible: false };\n    }\n  }\n}\n\n/**\n * Convert modifier condition to parsed structure\n */\nfunction modifierToParsed(state: ModifierCondition): ParsedModifierCondition {\n  return {\n    attribute: state.attribute,\n    value: state.value,\n    operator: state.operator,\n    negated: state.negated ?? false,\n  };\n}\n\n/**\n * Convert parsed modifier to CSS selector string (for final output)\n */\nexport function modifierToCSS(mod: ParsedModifierCondition): string {\n  let selector: string;\n\n  if (mod.value !== undefined) {\n    // Value attribute: [data-attr=\"value\"]\n    const op = mod.operator || '=';\n    selector = `[${mod.attribute}${op}\"${mod.value}\"]`;\n  } else {\n    // Boolean attribute: [data-attr]\n    selector = `[${mod.attribute}]`;\n  }\n\n  if (mod.negated) {\n    return `:not(${selector})`;\n  }\n  return selector;\n}\n\n/**\n * Convert pseudo condition to parsed structure\n */\nfunction pseudoToParsed(state: PseudoCondition): ParsedPseudoCondition {\n  return {\n    pseudo: state.pseudo,\n    negated: state.negated ?? false,\n  };\n}\n\n/**\n * Convert parsed pseudo to CSS selector string (for final output).\n *\n * :not() is normalized to negated :is() at parse time, so pseudo.pseudo\n * never starts with ':not(' here. When negated:\n * - :is(X) → :not(X)     (unwrap :is)\n * - :where(X) → :not(X)  (unwrap :where)\n * - :has(X) → :not(:has(X))\n * - other → :not(other)\n *\n * When not negated, single-argument :is()/:where() is unwrapped when the\n * inner content is a simple compound selector that can safely append to\n * the base selector (this happens after double-negation of :not()).\n */\nexport function pseudoToCSS(pseudo: ParsedPseudoCondition): string {\n  const p = pseudo.pseudo;\n\n  if (pseudo.negated) {\n    if (p.startsWith(':is(') || p.startsWith(':where(')) {\n      return `:not(${p.slice(p.indexOf('(') + 1, -1)})`;\n    }\n    return `:not(${p})`;\n  }\n\n  if ((p.startsWith(':is(') || p.startsWith(':where(')) && !p.includes(',')) {\n    const inner = p.slice(p.indexOf('(') + 1, -1);\n    const ch = inner[0];\n\n    // Only unwrap when the inner content is a simple compound selector:\n    // must start with a compoundable character and contain no whitespace\n    // (whitespace implies combinators like `>`, `+`, `~`, or descendant).\n    if (\n      (ch === ':' || ch === '.' || ch === '[' || ch === '#') &&\n      !/\\s/.test(inner)\n    ) {\n      return inner;\n    }\n  }\n\n  return p;\n}\n\n/**\n * Convert media condition to parsed structure(s)\n * Returns an array because negated ranges produce OR branches (two separate conditions)\n */\nfunction mediaToParsed(state: MediaCondition): ParsedMediaCondition[] {\n  if (state.subtype === 'type') {\n    // @media:print → @media print (or @media not print)\n    const mediaType = state.mediaType || 'all';\n    return [\n      {\n        subtype: 'type',\n        negated: state.negated ?? false,\n        condition: mediaType,\n        mediaType: state.mediaType,\n      },\n    ];\n  } else if (state.subtype === 'feature') {\n    // @media(prefers-contrast: high) → @media (prefers-contrast: high)\n    let condition: string;\n    if (state.featureValue) {\n      condition = `(${state.feature}: ${state.featureValue})`;\n    } else {\n      condition = `(${state.feature})`;\n    }\n    return [\n      {\n        subtype: 'feature',\n        negated: state.negated ?? false,\n        condition,\n        feature: state.feature,\n        featureValue: state.featureValue,\n      },\n    ];\n  } else {\n    // Dimension query - negation is handled by inverting the condition\n    // because \"not (width < x)\" doesn't work reliably in browsers\n    return dimensionToMediaParsed(\n      state.dimension || 'width',\n      state.lowerBound,\n      state.upperBound,\n      state.negated ?? false,\n    );\n  }\n}\n\n/**\n * Convert dimension bounds to parsed media condition(s)\n * Uses CSS Media Queries Level 4 `not (condition)` syntax for negation.\n */\nfunction dimensionToMediaParsed(\n  dimension: 'width' | 'height' | 'inline-size' | 'block-size',\n  lowerBound?: {\n    value: string;\n    valueNumeric: number | null;\n    inclusive: boolean;\n  },\n  upperBound?: {\n    value: string;\n    valueNumeric: number | null;\n    inclusive: boolean;\n  },\n  negated?: boolean,\n): ParsedMediaCondition[] {\n  // Build the condition string\n  let condition: string;\n  if (lowerBound && upperBound) {\n    const lowerOp = lowerBound.inclusive ? '<=' : '<';\n    const upperOp = upperBound.inclusive ? '<=' : '<';\n    condition = `(${lowerBound.value} ${lowerOp} ${dimension} ${upperOp} ${upperBound.value})`;\n  } else if (upperBound) {\n    const op = upperBound.inclusive ? '<=' : '<';\n    condition = `(${dimension} ${op} ${upperBound.value})`;\n  } else if (lowerBound) {\n    const op = lowerBound.inclusive ? '>=' : '>';\n    condition = `(${dimension} ${op} ${lowerBound.value})`;\n  } else {\n    condition = `(${dimension})`;\n  }\n\n  // For negation, we use CSS `not (condition)` syntax in buildAtRulesFromVariant\n  return [\n    {\n      subtype: 'dimension',\n      negated: negated ?? false,\n      condition,\n      dimension,\n      lowerBound,\n      upperBound,\n    },\n  ];\n}\n\n/**\n * Convert container condition to parsed structure\n * This enables structured analysis for contradiction detection and condition combining\n */\nfunction containerToParsed(\n  state: ContainerCondition,\n): ParsedContainerCondition {\n  let condition: string;\n\n  if (state.subtype === 'style') {\n    // Style query: style(--prop: value)\n    if (state.propertyValue) {\n      condition = `style(--${state.property}: ${state.propertyValue})`;\n    } else {\n      condition = `style(--${state.property})`;\n    }\n  } else if (state.subtype === 'raw') {\n    // Raw function query: passed through verbatim (e.g., scroll-state(stuck: top))\n    condition = state.rawCondition!;\n  } else {\n    // Dimension query\n    condition = dimensionToContainerCondition(\n      state.dimension || 'width',\n      state.lowerBound,\n      state.upperBound,\n    );\n  }\n\n  return {\n    name: state.containerName,\n    condition,\n    negated: state.negated ?? false,\n    subtype: state.subtype,\n    property: state.property,\n    propertyValue: state.propertyValue,\n  };\n}\n\n/**\n * Convert dimension bounds to container query condition (single string)\n * Container queries support \"not (condition)\", so no need to invert manually\n */\nfunction dimensionToContainerCondition(\n  dimension: string,\n  lowerBound?: { value: string; inclusive: boolean },\n  upperBound?: { value: string; inclusive: boolean },\n): string {\n  if (lowerBound && upperBound) {\n    const lowerOp = lowerBound.inclusive ? '<=' : '<';\n    const upperOp = upperBound.inclusive ? '<=' : '<';\n    return `(${lowerBound.value} ${lowerOp} ${dimension} ${upperOp} ${upperBound.value})`;\n  } else if (upperBound) {\n    const op = upperBound.inclusive ? '<=' : '<';\n    return `(${dimension} ${op} ${upperBound.value})`;\n  } else if (lowerBound) {\n    const op = lowerBound.inclusive ? '>=' : '>';\n    return `(${dimension} ${op} ${lowerBound.value})`;\n  }\n  return '(width)'; // Fallback\n}\n\n/**\n * Convert supports condition to parsed structure\n */\nfunction supportsToParsed(state: SupportsCondition): ParsedSupportsCondition {\n  return {\n    subtype: state.subtype,\n    condition: state.condition,\n    negated: state.negated ?? false,\n  };\n}\n\n/**\n * Collect all modifier and pseudo conditions from a variant as a flat array.\n */\nfunction collectSelectorConditions(\n  variant: SelectorVariant,\n): ParsedSelectorCondition[] {\n  return [...variant.modifierConditions, ...variant.pseudoConditions];\n}\n\n/**\n * Convert an inner condition tree into a single SelectorVariant with\n * one SelectorGroup whose branches represent the inner OR alternatives.\n * Shared by @root() and @own().\n *\n * Both positive and negated cases produce one variant with one group.\n * Negation simply sets the `negated` flag, which swaps :is() for :not()\n * in the final CSS output — no De Morgan transformation is needed.\n *\n * This mirrors parentConditionToVariants: OR branches are kept inside\n * a single group and rendered as comma-separated arguments in\n * :is()/:not(), e.g. :root:is([a], [b]) or [el]:not([a], [b]).\n */\nfunction innerConditionToVariants(\n  innerCondition: ConditionNode,\n  negated: boolean,\n  target: 'rootGroups' | 'ownGroups',\n): CSSComponents {\n  const innerCSS = conditionToCSS(innerCondition);\n\n  if (innerCSS.isImpossible || innerCSS.variants.length === 0) {\n    return { variants: [], isImpossible: true };\n  }\n\n  const branches: ParsedSelectorCondition[][] = [];\n\n  for (const innerVariant of innerCSS.variants) {\n    const conditions = collectSelectorConditions(innerVariant);\n\n    if (conditions.length > 0) {\n      branches.push(conditions);\n    }\n  }\n\n  if (branches.length === 0) {\n    return { variants: [emptyVariant()], isImpossible: false };\n  }\n\n  const v = emptyVariant();\n  v[target].push({ branches, negated });\n\n  return { variants: [v], isImpossible: false };\n}\n\n/**\n * Convert a @parent() inner condition into a single SelectorVariant with\n * one ParentGroup whose branches represent the inner OR alternatives.\n *\n * Both positive and negated cases produce one variant with one group.\n * Negation simply sets the `negated` flag, which swaps :is() for :not()\n * in the final CSS output — no structural transformation is needed.\n */\nfunction parentConditionToVariants(\n  innerCondition: ConditionNode,\n  negated: boolean,\n  direct: boolean,\n): CSSComponents {\n  const innerCSS = conditionToCSS(innerCondition);\n\n  if (innerCSS.isImpossible || innerCSS.variants.length === 0) {\n    return { variants: [], isImpossible: true };\n  }\n\n  const branches: ParsedSelectorCondition[][] = [];\n\n  for (const innerVariant of innerCSS.variants) {\n    const conditions = collectSelectorConditions(innerVariant);\n\n    if (conditions.length > 0) {\n      branches.push(conditions);\n    }\n  }\n\n  if (branches.length === 0) {\n    return { variants: [emptyVariant()], isImpossible: false };\n  }\n\n  const v = emptyVariant();\n  v.parentGroups.push({ branches, direct, negated });\n\n  return { variants: [v], isImpossible: false };\n}\n\n/**\n * Sort key for canonical condition output within selectors.\n *\n * Priority order:\n * 0: Boolean attribute selectors ([data-hovered])\n * 1: Value attribute selectors ([data-size=\"small\"])\n * 2: Negated boolean attributes (:not([data-disabled]))\n * 3: Negated value attributes (:not([data-size=\"small\"]))\n * 4: Pseudo-classes (:hover, :focus)\n * 5: Negated pseudo-classes (:not(:disabled))\n *\n * Secondary sort: alphabetical by attribute name / pseudo string.\n */\nfunction conditionSortKey(cond: ParsedSelectorCondition): string {\n  if ('attribute' in cond) {\n    const hasValue = cond.value !== undefined ? 1 : 0;\n    const neg = cond.negated ? 2 : 0;\n    return `${neg + hasValue}|${cond.attribute}|${cond.value ?? ''}`;\n  }\n  const priority = cond.negated ? 5 : 4;\n  return `${priority}|${cond.pseudo}`;\n}\n\nfunction sortConditions(\n  conditions: ParsedSelectorCondition[],\n): ParsedSelectorCondition[] {\n  return conditions.toSorted((a, b) =>\n    conditionSortKey(a).localeCompare(conditionSortKey(b)),\n  );\n}\n\nexport function branchToCSS(branch: ParsedSelectorCondition[]): string {\n  let parts = '';\n  for (const cond of sortConditions(branch)) {\n    parts += selectorConditionToCSS(cond);\n  }\n  return parts;\n}\n\n/**\n * Wrap serialized selector arguments in :is() or :not().\n * Arguments are sorted for canonical output.\n */\nfunction wrapInIsOrNot(args: string[], negated: boolean): string {\n  const wrapper = negated ? ':not' : ':is';\n  return `${wrapper}(${args.sort().join(', ')})`;\n}\n\n/**\n * Convert a selector group to a CSS selector fragment.\n *\n * Single-branch groups are unwrapped (no :is() wrapper).\n * Multi-branch groups use :is() or :not().\n * Negation swaps :is() for :not().\n */\nexport function selectorGroupToCSS(group: SelectorGroup): string {\n  if (group.branches.length === 0) return '';\n\n  // Single branch: emit directly without :is() wrapper\n  if (group.branches.length === 1) {\n    const parts = branchToCSS(group.branches[0]);\n    if (group.negated) {\n      return `:not(${parts})`;\n    }\n    return parts;\n  }\n\n  return wrapInIsOrNot(group.branches.map(branchToCSS), group.negated);\n}\n\n// ============================================================================\n// Modifier Subsumption (shared by optimizeGroups and dedupeSelectorConditions)\n// ============================================================================\n\ninterface SubsumptionFacts {\n  negatedBooleanAttrs: Set<string>;\n  positiveExactValuesByAttr: Map<string, Set<string>>;\n}\n\n/**\n * Collect facts about modifier conditions for subsumption analysis.\n * Tracks negated boolean attrs (:not([attr])) and positive exact values ([attr=\"X\"]).\n */\nfunction collectSubsumptionFacts(\n  modifiers: Iterable<ParsedModifierCondition>,\n): SubsumptionFacts {\n  const negatedBooleanAttrs = new Set<string>();\n  const positiveExactValuesByAttr = new Map<string, Set<string>>();\n\n  for (const mod of modifiers) {\n    if (mod.negated && mod.value === undefined) {\n      negatedBooleanAttrs.add(mod.attribute);\n    }\n    if (\n      !mod.negated &&\n      mod.value !== undefined &&\n      (mod.operator ?? '=') === '='\n    ) {\n      let vals = positiveExactValuesByAttr.get(mod.attribute);\n      if (!vals) {\n        vals = new Set();\n        positiveExactValuesByAttr.set(mod.attribute, vals);\n      }\n      vals.add(mod.value);\n    }\n  }\n\n  return { negatedBooleanAttrs, positiveExactValuesByAttr };\n}\n\n/**\n * Check if a negated-value modifier is subsumed by stronger facts:\n * - :not([attr]) subsumes :not([attr=\"val\"])\n * - [attr=\"X\"] implies :not([attr=\"Y\"]) is redundant (single exact value)\n *\n * Only applies to exact-match (=) operators; substring operators don't\n * imply exclusivity between values.\n */\nfunction isSubsumedNegatedModifier(\n  mod: ParsedModifierCondition,\n  facts: SubsumptionFacts,\n): boolean {\n  if (!mod.negated || mod.value === undefined) return false;\n\n  if (facts.negatedBooleanAttrs.has(mod.attribute)) return true;\n\n  if ((mod.operator ?? '=') === '=') {\n    const posVals = facts.positiveExactValuesByAttr.get(mod.attribute);\n    if (posVals && posVals.size === 1 && !posVals.has(mod.value)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n\n/**\n * Remove redundant single-condition groups that are subsumed by stronger\n * groups on the same attribute. O(n) — only inspects single-branch,\n * single-condition groups.\n */\nexport function optimizeGroups(groups: SelectorGroup[]): SelectorGroup[] {\n  if (groups.length <= 1) return groups;\n\n  // Exact dedup by key\n  const seen = new Set<string>();\n  const result: SelectorGroup[] = [];\n  for (const g of groups) {\n    const key = getSelectorGroupKey(g);\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(g);\n    }\n  }\n\n  if (result.length <= 1) return result;\n\n  // Extract modifier conditions from simple groups for subsumption analysis\n  const effectiveModifiers: ParsedModifierCondition[] = [];\n  for (const g of result) {\n    if (g.branches.length !== 1 || g.branches[0].length !== 1) continue;\n    const cond = g.branches[0][0];\n    if (!('attribute' in cond)) continue;\n    // Map group-level negation onto the condition for fact collection\n    effectiveModifiers.push({\n      ...cond,\n      negated: g.negated !== cond.negated,\n    });\n  }\n\n  const facts = collectSubsumptionFacts(effectiveModifiers);\n  if (\n    facts.negatedBooleanAttrs.size === 0 &&\n    facts.positiveExactValuesByAttr.size === 0\n  ) {\n    return result;\n  }\n\n  return result.filter((g) => {\n    if (g.branches.length !== 1 || g.branches[0].length !== 1) return true;\n    const cond = g.branches[0][0];\n    if (\n      !('attribute' in cond) ||\n      !g.negated ||\n      cond.negated ||\n      cond.value === undefined\n    ) {\n      return true;\n    }\n    return !isSubsumedNegatedModifier({ ...cond, negated: true }, facts);\n  });\n}\n\n/**\n * Convert root groups to CSS selector prefix (for final output)\n */\nexport function rootGroupsToCSS(groups: SelectorGroup[]): string | undefined {\n  if (groups.length === 0) return undefined;\n\n  const optimized = optimizeGroups(groups);\n  if (optimized.length === 0) return undefined;\n\n  let prefix = ':root';\n  for (const group of optimized) {\n    prefix += selectorGroupToCSS(group);\n  }\n  return prefix;\n}\n\n/**\n * Convert parent groups to CSS selector fragments (for final output).\n * Each group produces its own :is()/:not() wrapper with a combinator\n * suffix (` *` or ` > *`) appended to each branch.\n */\nexport function parentGroupsToCSS(groups: ParentGroup[]): string {\n  let result = '';\n  for (const group of groups) {\n    const combinator = group.direct ? ' > *' : ' *';\n    const args = group.branches.map(\n      (branch) => branchToCSS(branch) + combinator,\n    );\n    result += wrapInIsOrNot(args, group.negated);\n  }\n  return result;\n}\n\n/**\n * Convert a modifier or pseudo condition to a CSS selector fragment\n */\nexport function selectorConditionToCSS(cond: ParsedSelectorCondition): string {\n  if ('attribute' in cond) {\n    return modifierToCSS(cond);\n  }\n  return pseudoToCSS(cond);\n}\n\n/**\n * Get unique key for a modifier condition\n */\nfunction getModifierKey(mod: ParsedModifierCondition): string {\n  const base = mod.value\n    ? `${mod.attribute}${mod.operator || '='}${mod.value}`\n    : mod.attribute;\n  return mod.negated ? `!${base}` : base;\n}\n\n/**\n * Get unique key for a pseudo condition\n */\nfunction getPseudoKey(pseudo: ParsedPseudoCondition): string {\n  return pseudo.negated ? `!${pseudo.pseudo}` : pseudo.pseudo;\n}\n\n/**\n * Get unique key for any selector condition (modifier or pseudo)\n */\nfunction getSelectorConditionKey(cond: ParsedSelectorCondition): string {\n  return 'attribute' in cond\n    ? `mod:${getModifierKey(cond)}`\n    : `pseudo:${getPseudoKey(cond)}`;\n}\n\n/**\n * Deduplicate selector conditions (modifiers or pseudos).\n * Shared by root, parent, and own conditions.\n */\nfunction dedupeSelectorConditions(\n  conditions: ParsedSelectorCondition[],\n): ParsedSelectorCondition[] {\n  // Pass 1: exact-key dedup\n  const seen = new Set<string>();\n  const result: ParsedSelectorCondition[] = [];\n  for (const c of conditions) {\n    const key = getSelectorConditionKey(c);\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(c);\n    }\n  }\n\n  // Pass 2: remove negated value modifiers subsumed by other modifiers\n  const modifiers = result.filter(\n    (c): c is ParsedModifierCondition => 'attribute' in c,\n  );\n  const facts = collectSubsumptionFacts(modifiers);\n  if (\n    facts.negatedBooleanAttrs.size === 0 &&\n    facts.positiveExactValuesByAttr.size === 0\n  ) {\n    return result;\n  }\n\n  return result.filter((c) => {\n    if (!('attribute' in c)) return true;\n    return !isSubsumedNegatedModifier(c, facts);\n  });\n}\n\n/**\n * Check for modifier contradiction: same attribute with opposite negation\n */\nfunction hasModifierContradiction(\n  conditions: ParsedModifierCondition[],\n): boolean {\n  const byKey = new Map<string, boolean>(); // base key -> isPositive\n\n  for (const mod of conditions) {\n    const baseKey = mod.value\n      ? `${mod.attribute}${mod.operator || '='}${mod.value}`\n      : mod.attribute;\n    const existing = byKey.get(baseKey);\n    if (existing !== undefined && existing !== !mod.negated) {\n      return true; // Same attribute with opposite negation\n    }\n    byKey.set(baseKey, !mod.negated);\n  }\n  return false;\n}\n\n/**\n * Check for pseudo contradiction: same pseudo with opposite negation\n */\nfunction hasPseudoContradiction(conditions: ParsedPseudoCondition[]): boolean {\n  const byKey = new Map<string, boolean>(); // pseudo -> isPositive\n\n  for (const pseudo of conditions) {\n    const existing = byKey.get(pseudo.pseudo);\n    if (existing !== undefined && existing !== !pseudo.negated) {\n      return true; // Same pseudo with opposite negation\n    }\n    byKey.set(pseudo.pseudo, !pseudo.negated);\n  }\n  return false;\n}\n\n/**\n * Check for selector condition contradiction (modifier or pseudo with opposite negation).\n * Shared by root, parent, and own conditions.\n */\nfunction hasSelectorConditionContradiction(\n  conditions: ParsedSelectorCondition[],\n): boolean {\n  const modifiers: ParsedModifierCondition[] = [];\n  const pseudos: ParsedPseudoCondition[] = [];\n\n  for (const c of conditions) {\n    if ('attribute' in c) {\n      modifiers.push(c);\n    } else {\n      pseudos.push(c);\n    }\n  }\n\n  return hasModifierContradiction(modifiers) || hasPseudoContradiction(pseudos);\n}\n\n/**\n * Check for parent group contradiction: same target (direct + conditions)\n * with opposite negation. E.g. :not([data-hovered] *) and :is([data-hovered] *)\n * in the same variant is impossible.\n */\nfunction getBranchesKey(branches: ParsedSelectorCondition[][]): string {\n  if (branches.length === 1) {\n    const b = branches[0];\n    if (b.length === 1) return getSelectorConditionKey(b[0]);\n    return b.map(getSelectorConditionKey).sort().join('+');\n  }\n  return branches\n    .map((b) => b.map(getSelectorConditionKey).sort().join('+'))\n    .sort()\n    .join(',');\n}\n\nfunction hasParentGroupContradiction(groups: ParentGroup[]): boolean {\n  const byBaseKey = new Map<string, boolean>();\n\n  for (const g of groups) {\n    const baseKey = `${g.direct ? '>' : ''}(${getBranchesKey(g.branches)})`;\n    const existing = byBaseKey.get(baseKey);\n    if (existing !== undefined && existing !== !g.negated) {\n      return true;\n    }\n    byBaseKey.set(baseKey, !g.negated);\n  }\n  return false;\n}\n\n/**\n * Check for selector group contradiction: same branches with opposite negation.\n * E.g. :is([data-a]) and :not([data-a]) in the same variant is impossible.\n */\nfunction hasSelectorGroupContradiction(groups: SelectorGroup[]): boolean {\n  const byBaseKey = new Map<string, boolean>();\n\n  for (const g of groups) {\n    const baseKey = getBranchesKey(g.branches);\n    const existing = byBaseKey.get(baseKey);\n    if (existing !== undefined && existing !== !g.negated) {\n      return true;\n    }\n    byBaseKey.set(baseKey, !g.negated);\n  }\n  return false;\n}\n\n/**\n * Merge two selector variants (AND operation)\n * Deduplicates conditions and checks for contradictions\n */\nfunction mergeVariants(\n  a: SelectorVariant,\n  b: SelectorVariant,\n): SelectorVariant | null {\n  // Merge media conditions and check for contradictions\n  const mergedMedia = dedupeMediaConditions([\n    ...a.mediaConditions,\n    ...b.mediaConditions,\n  ]);\n  if (hasMediaContradiction(mergedMedia)) {\n    return null; // Impossible variant\n  }\n\n  // Concatenate root groups, optimize, and check for contradictions\n  const mergedRootGroups = optimizeGroups([...a.rootGroups, ...b.rootGroups]);\n  if (hasSelectorGroupContradiction(mergedRootGroups)) {\n    return null; // Impossible variant\n  }\n\n  // Merge modifier and pseudo conditions separately, then cross-check\n  const mergedModifiers = dedupeSelectorConditions([\n    ...a.modifierConditions,\n    ...b.modifierConditions,\n  ]) as ParsedModifierCondition[];\n  const mergedPseudos = dedupeSelectorConditions([\n    ...a.pseudoConditions,\n    ...b.pseudoConditions,\n  ]) as ParsedPseudoCondition[];\n  if (\n    hasSelectorConditionContradiction([...mergedModifiers, ...mergedPseudos])\n  ) {\n    return null; // Impossible variant\n  }\n\n  // Concatenate selector groups, optimize, and check for contradictions\n  const mergedSelectorGroups = optimizeGroups([\n    ...a.selectorGroups,\n    ...b.selectorGroups,\n  ]);\n  if (hasSelectorGroupContradiction(mergedSelectorGroups)) {\n    return null; // Impossible variant\n  }\n\n  // Concatenate parent groups (each group is an independent :is() wrapper)\n  const mergedParentGroups = [...a.parentGroups, ...b.parentGroups];\n  if (hasParentGroupContradiction(mergedParentGroups)) {\n    return null; // Impossible variant\n  }\n\n  // Concatenate own groups, optimize, and check for contradictions\n  const mergedOwnGroups = optimizeGroups([...a.ownGroups, ...b.ownGroups]);\n  if (hasSelectorGroupContradiction(mergedOwnGroups)) {\n    return null; // Impossible variant\n  }\n\n  // Merge container conditions and check for contradictions\n  const mergedContainers = dedupeContainerConditions([\n    ...a.containerConditions,\n    ...b.containerConditions,\n  ]);\n  if (hasContainerStyleContradiction(mergedContainers)) {\n    return null; // Impossible variant\n  }\n\n  // Merge supports conditions and check for contradictions\n  const mergedSupports = dedupeSupportsConditions([\n    ...a.supportsConditions,\n    ...b.supportsConditions,\n  ]);\n  if (hasSupportsContradiction(mergedSupports)) {\n    return null; // Impossible variant\n  }\n\n  return {\n    modifierConditions: mergedModifiers,\n    pseudoConditions: mergedPseudos,\n    selectorGroups: mergedSelectorGroups,\n    ownGroups: mergedOwnGroups,\n    mediaConditions: mergedMedia,\n    containerConditions: mergedContainers,\n    supportsConditions: mergedSupports,\n    rootGroups: mergedRootGroups,\n    parentGroups: mergedParentGroups,\n    startingStyle: a.startingStyle || b.startingStyle,\n  };\n}\n\n// Contradiction-detection helpers (`hasMediaContradiction`,\n// `hasContainerStyleContradiction`, `hasSupportsContradiction`) and the\n// matching `dedupe*Conditions` helpers live in `./materialize-contradictions`.\n// They're imported at the top of this file.\n\nconst variantKeyCache = new WeakMap<SelectorVariant, string>();\n\n/**\n * Get a unique key for a variant (for deduplication).\n * Cached via WeakMap since variants are compared multiple times during\n * deduplication and sorting.\n */\nfunction getSelectorGroupKey(g: SelectorGroup): string {\n  return `${g.negated ? '!' : ''}(${getBranchesKey(g.branches)})`;\n}\n\n/**\n * Get a context key for a variant — everything except flat modifier/pseudo\n * conditions. Variants with the same context key can be merged into an\n * :is() group. Also used by getVariantKey as the shared non-selector portion.\n */\nfunction getVariantContextKey(v: SelectorVariant): string {\n  const mediaKey = v.mediaConditions\n    .map((c) => `${c.subtype}:${c.negated ? '!' : ''}${c.condition}`)\n    .sort()\n    .join('|');\n  const containerKey = v.containerConditions\n    .map((c) => `${c.name ?? ''}:${c.negated ? '!' : ''}${c.condition}`)\n    .sort()\n    .join('|');\n  const supportsKey = v.supportsConditions\n    .map((c) => `${c.subtype}:${c.negated ? '!' : ''}${c.condition}`)\n    .sort()\n    .join('|');\n  const rootKey = v.rootGroups.map(getSelectorGroupKey).sort().join('|');\n  const parentKey = v.parentGroups.map(getParentGroupKey).sort().join('|');\n  const ownKey = v.ownGroups.map(getSelectorGroupKey).sort().join('|');\n  const selectorGroupKey = v.selectorGroups\n    .map(getSelectorGroupKey)\n    .sort()\n    .join('|');\n\n  return [\n    mediaKey,\n    containerKey,\n    supportsKey,\n    rootKey,\n    parentKey,\n    ownKey,\n    selectorGroupKey,\n    v.startingStyle ? '1' : '0',\n  ].join('###');\n}\n\nfunction getVariantKey(v: SelectorVariant): string {\n  const cached = variantKeyCache.get(v);\n  if (cached !== undefined) return cached;\n  const modifierKey = v.modifierConditions.map(getModifierKey).sort().join('|');\n  const pseudoKey = v.pseudoConditions.map(getPseudoKey).sort().join('|');\n  const key = modifierKey + '###' + pseudoKey + '###' + getVariantContextKey(v);\n  variantKeyCache.set(v, key);\n  return key;\n}\n\n/**\n * Total number of leaf conditions in a variant (for superset / dedup comparisons).\n */\nfunction groupConditionCount(\n  groups: readonly { branches: ParsedSelectorCondition[][] }[],\n): number {\n  return groups.reduce(\n    (sum, g) => sum + g.branches.reduce((s, b) => s + b.length, 0),\n    0,\n  );\n}\n\nfunction variantConditionCount(v: SelectorVariant): number {\n  return (\n    v.modifierConditions.length +\n    v.pseudoConditions.length +\n    groupConditionCount(v.selectorGroups) +\n    groupConditionCount(v.ownGroups) +\n    v.mediaConditions.length +\n    v.containerConditions.length +\n    v.supportsConditions.length +\n    groupConditionCount(v.rootGroups) +\n    groupConditionCount(v.parentGroups)\n  );\n}\n\n/**\n * Check if variant A is a superset of variant B (A is more restrictive)\n *\n * If A has all of B's conditions plus more, then A is redundant\n * because B already covers the same cases (and more).\n *\n * Example:\n *   A: :not([size=large]):not([size=medium]):not([size=small])\n *   B: :not([size=large])\n *   A is a superset of B, so A is redundant when B exists.\n */\nfunction isVariantSuperset(a: SelectorVariant, b: SelectorVariant): boolean {\n  // Must have same context\n  if (a.startingStyle !== b.startingStyle) return false;\n\n  // Check if a.rootGroups is superset of b.rootGroups\n  if (!isSelectorGroupsSuperset(a.rootGroups, b.rootGroups)) return false;\n\n  // Check if a.mediaConditions is superset of b.mediaConditions\n  if (!isMediaConditionsSuperset(a.mediaConditions, b.mediaConditions))\n    return false;\n\n  // Check if a.containerConditions is superset of b.containerConditions\n  if (\n    !isContainerConditionsSuperset(a.containerConditions, b.containerConditions)\n  )\n    return false;\n\n  // Check if a.supportsConditions is superset of b.supportsConditions\n  if (!isSupportsConditionsSuperset(a.supportsConditions, b.supportsConditions))\n    return false;\n\n  // Check if a.modifierConditions is superset of b.modifierConditions\n  if (!isModifierConditionsSuperset(a.modifierConditions, b.modifierConditions))\n    return false;\n\n  // Check if a.pseudoConditions is superset of b.pseudoConditions\n  if (!isPseudoConditionsSuperset(a.pseudoConditions, b.pseudoConditions))\n    return false;\n\n  // Check if a.selectorGroups is superset of b.selectorGroups\n  if (!isSelectorGroupsSuperset(a.selectorGroups, b.selectorGroups))\n    return false;\n\n  // Check if a.ownGroups is superset of b.ownGroups\n  if (!isSelectorGroupsSuperset(a.ownGroups, b.ownGroups)) return false;\n\n  // Check if a.parentGroups is superset of b.parentGroups\n  if (!isParentGroupsSuperset(a.parentGroups, b.parentGroups)) return false;\n\n  return variantConditionCount(a) > variantConditionCount(b);\n}\n\n/**\n * Generic superset check: true if every item in B has a matching key in A.\n */\nfunction isConditionsSuperset<T>(\n  a: T[],\n  b: T[],\n  getKey: (item: T) => string,\n): boolean {\n  const aKeys = new Set(a.map(getKey));\n  return b.every((c) => aKeys.has(getKey(c)));\n}\n\nfunction isMediaConditionsSuperset(\n  a: ParsedMediaCondition[],\n  b: ParsedMediaCondition[],\n): boolean {\n  return isConditionsSuperset(\n    a,\n    b,\n    (c) => `${c.subtype}|${c.condition}|${c.negated}`,\n  );\n}\n\nfunction isContainerConditionsSuperset(\n  a: ParsedContainerCondition[],\n  b: ParsedContainerCondition[],\n): boolean {\n  return isConditionsSuperset(\n    a,\n    b,\n    (c) => `${c.name ?? ''}|${c.condition}|${c.negated}`,\n  );\n}\n\nfunction isSupportsConditionsSuperset(\n  a: ParsedSupportsCondition[],\n  b: ParsedSupportsCondition[],\n): boolean {\n  return isConditionsSuperset(\n    a,\n    b,\n    (c) => `${c.subtype}|${c.condition}|${c.negated}`,\n  );\n}\n\nfunction isModifierConditionsSuperset(\n  a: ParsedModifierCondition[],\n  b: ParsedModifierCondition[],\n): boolean {\n  return isConditionsSuperset(a, b, getModifierKey);\n}\n\nfunction isPseudoConditionsSuperset(\n  a: ParsedPseudoCondition[],\n  b: ParsedPseudoCondition[],\n): boolean {\n  return isConditionsSuperset(a, b, getPseudoKey);\n}\n\nfunction isSelectorGroupsSuperset(\n  a: SelectorGroup[],\n  b: SelectorGroup[],\n): boolean {\n  if (a.length < b.length) return false;\n  return isConditionsSuperset(a, b, getSelectorGroupKey);\n}\n\n/**\n * Check if parent groups A is a superset of B.\n * Each group in B must have a matching group in A.\n */\nfunction isParentGroupsSuperset(a: ParentGroup[], b: ParentGroup[]): boolean {\n  if (a.length < b.length) return false;\n  return isConditionsSuperset(a, b, getParentGroupKey);\n}\n\nfunction getParentGroupKey(g: ParentGroup): string {\n  return `${g.negated ? '!' : ''}${g.direct ? '>' : ''}(${getBranchesKey(g.branches)})`;\n}\n\n/**\n * Deduplicate variants\n *\n * Removes:\n * 1. Exact duplicates (same key)\n * 2. Superset variants (more restrictive selectors that are redundant)\n */\nfunction dedupeVariants(variants: SelectorVariant[]): SelectorVariant[] {\n  if (variants.length <= 1) return variants;\n\n  // First pass: exact deduplication\n  const seen = new Set<string>();\n  const result: SelectorVariant[] = [];\n\n  for (const v of variants) {\n    const key = getVariantKey(v);\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(v);\n    }\n  }\n\n  if (result.length <= 1) return result;\n\n  // Second pass: remove supersets (more restrictive variants)\n  // Sort by total condition count (fewer conditions = less restrictive = keep)\n  result.sort((a, b) => variantConditionCount(a) - variantConditionCount(b));\n\n  // Remove variants that are supersets of earlier (less restrictive) variants\n  const filtered: SelectorVariant[] = [];\n  for (const candidate of result) {\n    let isRedundant = false;\n    for (const kept of filtered) {\n      if (isVariantSuperset(candidate, kept)) {\n        isRedundant = true;\n        break;\n      }\n    }\n    if (!isRedundant) {\n      filtered.push(candidate);\n    }\n  }\n\n  return filtered;\n}\n\n/**\n * Combine AND conditions into CSS\n *\n * AND of conditions means cartesian product of variants:\n * (A1 | A2) & (B1 | B2) = A1&B1 | A1&B2 | A2&B1 | A2&B2\n *\n * Variants that result in contradictions (e.g., conflicting media rules)\n * are filtered out.\n */\nfunction andToCSS(children: ConditionNode[]): CSSComponents {\n  // Make inner OR branches exclusive before materializing so the\n  // Cartesian product produces non-overlapping CSS variants.\n  const exclusiveChildren = makeOrBranchesExclusive(children);\n\n  // Start with a single empty variant\n  let currentVariants: SelectorVariant[] = [emptyVariant()];\n\n  for (const child of exclusiveChildren) {\n    const childCSS = conditionToCSSInner(child);\n\n    if (childCSS.isImpossible || childCSS.variants.length === 0) {\n      return { variants: [], isImpossible: true };\n    }\n\n    // Cartesian product: each current variant × each child variant\n    const newVariants: SelectorVariant[] = [];\n    for (const current of currentVariants) {\n      for (const childVariant of childCSS.variants) {\n        const merged = mergeVariants(current, childVariant);\n        // Skip impossible variants (contradictions detected during merge)\n        if (merged !== null) {\n          newVariants.push(merged);\n        }\n      }\n    }\n\n    if (newVariants.length === 0) {\n      return { variants: [], isImpossible: true };\n    }\n\n    // Deduplicate after each step to prevent exponential blowup\n    currentVariants = dedupeVariants(newVariants);\n  }\n\n  return {\n    variants: currentVariants,\n    isImpossible: false,\n  };\n}\n\n/**\n * Make OR branches within AND children mutually exclusive.\n *\n * For an AND child that is OR(A, B), transforms it to OR(A, B & !A)\n * so that when andToCSS does a Cartesian product, the resulting\n * CSS variants don't overlap.\n *\n * Only transforms OR children whose branches actually produce\n * different at-rule contexts when materialized. This avoids\n * breaking cases where contradiction detection in the Cartesian\n * product naturally handles deduplication.\n */\nfunction makeOrBranchesExclusive(children: ConditionNode[]): ConditionNode[] {\n  return children.map((child) => {\n    if (!isCompoundCondition(child) || child.operator !== 'OR') return child;\n    if (child.children.length <= 1) return child;\n\n    // Only apply when branches produce different at-rule contexts.\n    // Materialize each branch and compare context keys. If all branches\n    // produce the same context key, the :is() merging handles it.\n    if (!branchesProduceDifferentContexts(child.children)) return child;\n\n    const exclusiveBranches: ConditionNode[] = [];\n    const priorBranches: ConditionNode[] = [];\n\n    for (const branch of child.children) {\n      if (priorBranches.length === 0) {\n        exclusiveBranches.push(branch);\n      } else {\n        let exclusive: ConditionNode = branch;\n        for (const prior of priorBranches) {\n          exclusive = and(exclusive, not(prior));\n        }\n        const simplified = simplifyCondition(exclusive);\n        if (simplified.kind !== 'false') {\n          exclusiveBranches.push(simplified);\n        }\n      }\n      priorBranches.push(branch);\n    }\n\n    if (exclusiveBranches.length === 0) {\n      return child;\n    }\n    if (exclusiveBranches.length === 1) {\n      return exclusiveBranches[0];\n    }\n\n    return {\n      kind: 'compound' as const,\n      operator: 'OR' as const,\n      children: exclusiveBranches,\n    };\n  });\n}\n\n/**\n * Check if OR branches produce different at-rule contexts when\n * materialized. If so, the Cartesian product in andToCSS will\n * create overlapping CSS variants that need exclusive expansion.\n */\nfunction branchesProduceDifferentContexts(branches: ConditionNode[]): boolean {\n  const contextKeys = new Set<string>();\n\n  for (const branch of branches) {\n    const css = conditionToCSSInner(branch);\n    if (css.isImpossible) continue;\n\n    for (const v of css.variants) {\n      contextKeys.add(getVariantContextKey(v));\n    }\n  }\n\n  return contextKeys.size > 1;\n}\n\n/**\n * Combine OR conditions into CSS\n *\n * OR in CSS means multiple selector variants (DNF).\n * After deduplication, variants that differ only in their base\n * modifier/pseudo conditions are merged into :is() groups.\n *\n * Note: OR exclusivity is handled at the pipeline level (expandOrConditions),\n * so here we just collect all variants. Any remaining ORs in the condition\n * tree (e.g., from De Morgan expansion) are handled as simple alternatives.\n */\nfunction orToCSS(children: ConditionNode[]): CSSComponents {\n  const allVariants: SelectorVariant[] = [];\n\n  for (const child of children) {\n    const childCSS = conditionToCSSInner(child);\n    if (childCSS.isImpossible) continue;\n\n    allVariants.push(...childCSS.variants);\n  }\n\n  if (allVariants.length === 0) {\n    return { variants: [], isImpossible: true };\n  }\n\n  return {\n    variants: dedupeVariants(allVariants),\n    isImpossible: false,\n  };\n}\n\n// ============================================================================\n// OR → :is() Merging\n// ============================================================================\n\n/**\n * Find keys present in ALL condition arrays.\n */\nfunction findCommonKeys<T>(\n  conditionSets: T[][],\n  getKey: (item: T) => string,\n): Set<string> {\n  if (conditionSets.length === 0) return new Set();\n\n  const common = new Set(conditionSets[0].map(getKey));\n  for (let i = 1; i < conditionSets.length; i++) {\n    const keys = new Set(conditionSets[i].map(getKey));\n    for (const key of common) {\n      if (!keys.has(key)) common.delete(key);\n    }\n  }\n  return common;\n}\n\n/**\n * Merge OR variants that share the same \"context\" (at-rules, root, parent,\n * own, starting) into a single variant with a SelectorGroup.\n *\n * Variants with no modifier/pseudo conditions are kept separate (they match\n * unconditionally and can't be expressed inside :is()).\n */\nexport function mergeVariantsIntoSelectorGroups(\n  variants: SelectorVariant[],\n): SelectorVariant[] {\n  if (variants.length <= 1) return variants;\n\n  // Group variants by their context (everything except flat modifier/pseudo)\n  const groups = new Map<string, SelectorVariant[]>();\n  for (const v of variants) {\n    const key = getVariantContextKey(v);\n    const group = groups.get(key);\n    if (group) group.push(v);\n    else groups.set(key, [v]);\n  }\n\n  const result: SelectorVariant[] = [];\n  for (const group of groups.values()) {\n    if (group.length === 1) {\n      result.push(group[0]);\n      continue;\n    }\n\n    // Separate variants with no selector conditions (can't merge into :is())\n    const withSelectors: SelectorVariant[] = [];\n    const withoutSelectors: SelectorVariant[] = [];\n    for (const v of group) {\n      if (\n        v.modifierConditions.length === 0 &&\n        v.pseudoConditions.length === 0\n      ) {\n        withoutSelectors.push(v);\n      } else {\n        withSelectors.push(v);\n      }\n    }\n\n    result.push(...withoutSelectors);\n\n    if (withSelectors.length <= 1) {\n      result.push(...withSelectors);\n      continue;\n    }\n\n    // Factor out common conditions and create a SelectorGroup\n    result.push(factorAndGroup(withSelectors));\n  }\n\n  return result;\n}\n\n/**\n * Factor common modifier/pseudo conditions out of variants and create\n * a single variant with a SelectorGroup for the remaining (differing)\n * conditions.\n *\n * Precondition: all variants must share the same context key (identical\n * at-rules, root/parent/own/selector groups, startingStyle).\n */\nfunction factorAndGroup(variants: SelectorVariant[]): SelectorVariant {\n  if (process.env.NODE_ENV !== 'production') {\n    const key0 = getVariantContextKey(variants[0]);\n    for (let i = 1; i < variants.length; i++) {\n      const keyI = getVariantContextKey(variants[i]);\n      if (keyI !== key0) {\n        throw new Error(\n          `factorAndGroup: context key mismatch at index ${i}.\\n` +\n            `  expected: ${key0}\\n  got:      ${keyI}`,\n        );\n      }\n    }\n  }\n\n  // Find common modifier and pseudo keys across ALL variants\n  const commonModKeys = findCommonKeys(\n    variants.map((v) => v.modifierConditions),\n    getModifierKey,\n  );\n  const commonPseudoKeys = findCommonKeys(\n    variants.map((v) => v.pseudoConditions),\n    getPseudoKey,\n  );\n\n  // Extract common conditions from first variant\n  const commonModifiers = variants[0].modifierConditions.filter((m) =>\n    commonModKeys.has(getModifierKey(m)),\n  );\n  const commonPseudos = variants[0].pseudoConditions.filter((p) =>\n    commonPseudoKeys.has(getPseudoKey(p)),\n  );\n\n  // Build branches from remaining (non-common) conditions.\n  // If any variant has only common conditions (empty branch), it matches\n  // unconditionally within this context — the :is() group would lose it.\n  // In that case, return the broadest variant (common conditions only).\n  const branches: ParsedSelectorCondition[][] = [];\n  let hasEmptyBranch = false;\n  for (const v of variants) {\n    const branch: ParsedSelectorCondition[] = [];\n    for (const mod of v.modifierConditions) {\n      if (!commonModKeys.has(getModifierKey(mod))) branch.push(mod);\n    }\n    for (const pseudo of v.pseudoConditions) {\n      if (!commonPseudoKeys.has(getPseudoKey(pseudo))) branch.push(pseudo);\n    }\n    if (branch.length > 0) {\n      branches.push(branch);\n    } else {\n      hasEmptyBranch = true;\n    }\n  }\n\n  // If a variant has only common conditions, it's the broadest match —\n  // the :is() group with specific branches is subsumed by it.\n  // Return the variant with common conditions only.\n  if (hasEmptyBranch) {\n    return {\n      ...variants[0],\n      modifierConditions: commonModifiers,\n      pseudoConditions: commonPseudos,\n    };\n  }\n\n  return {\n    modifierConditions: commonModifiers,\n    pseudoConditions: commonPseudos,\n    selectorGroups: [\n      ...variants[0].selectorGroups,\n      { branches, negated: false },\n    ],\n    ownGroups: [...variants[0].ownGroups],\n    mediaConditions: [...variants[0].mediaConditions],\n    containerConditions: [...variants[0].containerConditions],\n    supportsConditions: [...variants[0].supportsConditions],\n    rootGroups: [...variants[0].rootGroups],\n    parentGroups: [...variants[0].parentGroups],\n    startingStyle: variants[0].startingStyle,\n  };\n}\n\n// ============================================================================\n// Utility Functions\n// ============================================================================\n\n/**\n * Build at-rules array from a variant\n */\nexport function buildAtRulesFromVariant(variant: SelectorVariant): string[] {\n  const atRules: string[] = [];\n\n  // Add media rules - combine all conditions with \"and\"\n  if (variant.mediaConditions.length > 0) {\n    const conditionParts = variant.mediaConditions.map((c) => {\n      if (c.subtype === 'type') {\n        // Media type: print, screen, etc.\n        return c.negated ? `not ${c.condition}` : c.condition;\n      } else {\n        // Feature or dimension: use not (condition) syntax for negation\n        // MQ Level 4 requires parentheses around the condition for negation\n        return c.negated ? `(not ${c.condition})` : c.condition;\n      }\n    });\n    atRules.push(`@media ${conditionParts.join(' and ')}`);\n  }\n\n  // Add container rules - group by container name and combine with \"and\"\n  if (variant.containerConditions.length > 0) {\n    // Group conditions by container name (undefined = unnamed/nearest)\n    const byName = new Map<string | undefined, ParsedContainerCondition[]>();\n    for (const cond of variant.containerConditions) {\n      const group = byName.get(cond.name) || [];\n      group.push(cond);\n      byName.set(cond.name, group);\n    }\n\n    // Build one @container rule per container name\n    for (const [name, conditions] of byName) {\n      // CSS Container Query syntax requires parentheses around negated conditions:\n      // @container (not style(--x)) and style(--y) - NOT @container not style(--x) and style(--y)\n      const conditionParts = conditions.map((c) =>\n        c.negated ? `(not ${c.condition})` : c.condition,\n      );\n      const namePrefix = name ? `${name} ` : '';\n      atRules.push(`@container ${namePrefix}${conditionParts.join(' and ')}`);\n    }\n  }\n\n  // Add supports rules - combine all conditions with \"and\"\n  if (variant.supportsConditions.length > 0) {\n    const conditionParts = variant.supportsConditions.map((c) => {\n      // Build the condition based on subtype\n      // feature: (display: grid) or (not (display: grid))\n      // selector: selector(:has(*)) or (not selector(:has(*)))\n      if (c.subtype === 'selector') {\n        const selectorCond = `selector(${c.condition})`;\n        return c.negated ? `(not ${selectorCond})` : selectorCond;\n      } else {\n        const featureCond = `(${c.condition})`;\n        return c.negated ? `(not ${featureCond})` : featureCond;\n      }\n    });\n    atRules.push(`@supports ${conditionParts.join(' and ')}`);\n  }\n\n  return atRules;\n}\n"],"mappings":"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"}

package/dist/pipeline/parseStateKey.d.ts

@@ -1,15 +0,0 @@
-import { ConditionNode } from "./conditions.js";
-import { StateParserContext } from "../states/index.js";
-
-//#region src/pipeline/parseStateKey.d.ts
-interface ParseStateKeyOptions {
-  context?: StateParserContext;
-  isSubElement?: boolean;
-}
-/**
- * Parse a state key string into a ConditionNode
- */
-declare function parseStateKey(stateKey: string, options?: ParseStateKeyOptions): ConditionNode;
-//#endregion
-export { ParseStateKeyOptions, parseStateKey };
-//# sourceMappingURL=parseStateKey.d.ts.map

package/dist/pipeline/parseStateKey.js

@@ -1,446 +0,0 @@
-import { Lru } from "../parser/lru.js";
-import { expandDimensionShorthands, expandTastyUnits, findTopLevelComma, resolvePredefinedState } from "../states/index.js";
-import { and, createContainerDimensionCondition, createContainerRawCondition, createContainerStyleCondition, createMediaDimensionCondition, createMediaFeatureCondition, createMediaTypeCondition, createModifierCondition, createOwnCondition, createParentCondition, createPseudoCondition, createRootCondition, createStartingCondition, createSupportsCondition, not, or, trueCondition } from "./conditions.js";
-import { camelToKebab } from "../utils/case-converter.js";
-import { transformSelectorContent } from "../utils/selector-transform.js";
-import { emitWarning } from "./warnings.js";
-//#region src/pipeline/parseStateKey.ts
-/**
-* State Key Parser
-*
-* Parses state notation strings (like 'hovered & !disabled', '@media(w < 768px)')
-* into ConditionNode trees for processing in the pipeline.
-*/
-/**
-* Maximum XOR operands before emitting a performance warning.
-* A ^ B ^ C ^ D = 8 OR branches (2^(n-1)), so chains above 4
-* risk exponential blowup in downstream processing.
-*/
-const MAX_XOR_CHAIN_LENGTH = 4;
-const parseCache = new Lru(5e3);
-/**
-* Pattern for tokenizing state notation.
-* Matches: operators, parentheses, @-prefixed states, value mods, boolean mods,
-* pseudo-classes, class selectors, and attribute selectors.
-*
-* All @-prefixed state groups (@supports, @root, @parent, @own, @(...))
-* and :is/:has/:not/:where pseudo-classes support up to 2 levels of
-* nested parentheses via:
-*   [^()]*(?:\([^()]*(?:\([^)]*\))?[^)]*\))*[^)]*
-*/
-const STATE_TOKEN_PATTERN = /([&|!^])|([()])|(@media:[a-z]+)|(@media\([^)]+\))|(@supports\([^()]*(?:\([^()]*(?:\([^)]*\))?[^)]*\))*[^)]*\))|(@root\([^()]*(?:\([^()]*(?:\([^)]*\))?[^)]*\))*[^)]*\))|(@parent\([^()]*(?:\([^()]*(?:\([^)]*\))?[^)]*\))*[^)]*\))|(@own\([^()]*(?:\([^()]*(?:\([^)]*\))?[^)]*\))*[^)]*\))|(@\([^()]*(?:\([^()]*(?:\([^)]*\))?[^)]*\))*[^)]*\))|(@starting)|(@[A-Za-z][A-Za-z0-9-]*)|([a-z][a-z0-9-]*(?:\^=|\$=|\*=|=)(?:"[^"]*"|'[^']*'|[^\s&|!^()]+))|([a-z][a-z0-9-]+)|(:(?:is|has|not|where)\([^()]*(?:\([^()]*(?:\([^)]*\))?[^)]*\))*[^)]*\))|(:[-a-z][a-z0-9-]*(?:\([^)]+\))?)|(\.[a-z][a-z0-9-]+)|(\[[^\]]+\])/gi;
-/**
-* Tokenize a state notation string
-*/
-function tokenize(stateKey) {
-	const tokens = [];
-	let match;
-	const normalized = replaceCommasOutsideParens(stateKey);
-	STATE_TOKEN_PATTERN.lastIndex = 0;
-	while ((match = STATE_TOKEN_PATTERN.exec(normalized)) !== null) {
-		const fullMatch = match[0];
-		if (match[1]) switch (fullMatch) {
-			case "&":
-				tokens.push({
-					type: "AND",
-					value: "&",
-					raw: fullMatch
-				});
-				break;
-			case "|":
-				tokens.push({
-					type: "OR",
-					value: "|",
-					raw: fullMatch
-				});
-				break;
-			case "!":
-				tokens.push({
-					type: "NOT",
-					value: "!",
-					raw: fullMatch
-				});
-				break;
-			case "^":
-				tokens.push({
-					type: "XOR",
-					value: "^",
-					raw: fullMatch
-				});
-				break;
-		}
-		else if (match[2]) if (fullMatch === "(") tokens.push({
-			type: "LPAREN",
-			value: "(",
-			raw: fullMatch
-		});
-		else tokens.push({
-			type: "RPAREN",
-			value: ")",
-			raw: fullMatch
-		});
-		else tokens.push({
-			type: "STATE",
-			value: fullMatch,
-			raw: fullMatch
-		});
-	}
-	return tokens;
-}
-/**
-* Replace commas with | only outside of parentheses
-*/
-function replaceCommasOutsideParens(str) {
-	let result = "";
-	let depth = 0;
-	for (const char of str) if (char === "(") {
-		depth++;
-		result += char;
-	} else if (char === ")") {
-		depth--;
-		result += char;
-	} else if (char === "," && depth === 0) result += "|";
-	else result += char;
-	return result;
-}
-/**
-* Parser state
-*/
-var Parser = class {
-	tokens;
-	pos = 0;
-	options;
-	constructor(tokens, options) {
-		this.tokens = tokens;
-		this.options = options;
-	}
-	parse() {
-		if (this.tokens.length === 0) return trueCondition();
-		return this.parseExpression();
-	}
-	current() {
-		return this.tokens[this.pos];
-	}
-	advance() {
-		return this.tokens[this.pos++];
-	}
-	match(type) {
-		if (this.current()?.type === type) {
-			this.advance();
-			return true;
-		}
-		return false;
-	}
-	/**
-	* Parse expression with operator precedence:
-	* ! (NOT) > ^ (XOR) > | (OR) > & (AND)
-	*/
-	parseExpression() {
-		return this.parseAnd();
-	}
-	parseAnd() {
-		let left = this.parseOr();
-		while (this.current()?.type === "AND") {
-			this.advance();
-			const right = this.parseOr();
-			left = and(left, right);
-		}
-		return left;
-	}
-	parseOr() {
-		let left = this.parseXor();
-		while (this.current()?.type === "OR") {
-			this.advance();
-			const right = this.parseXor();
-			left = or(left, right);
-		}
-		return left;
-	}
-	parseXor() {
-		let left = this.parseUnary();
-		let operandCount = 1;
-		while (this.current()?.type === "XOR") {
-			this.advance();
-			const right = this.parseUnary();
-			operandCount++;
-			if (operandCount > MAX_XOR_CHAIN_LENGTH) emitWarning("XOR_CHAIN_TOO_LONG", `XOR chain with ${operandCount} operands produces ${Math.pow(2, operandCount - 1)} OR branches. Consider breaking into smaller expressions to avoid exponential growth.`);
-			left = or(and(left, not(right)), and(not(left), right));
-		}
-		return left;
-	}
-	parseUnary() {
-		if (this.match("NOT")) return not(this.parseUnary());
-		return this.parsePrimary();
-	}
-	parsePrimary() {
-		if (this.match("LPAREN")) {
-			const expr = this.parseExpression();
-			this.match("RPAREN");
-			return expr;
-		}
-		const token = this.current();
-		if (token?.type === "STATE") {
-			this.advance();
-			return this.parseStateToken(token.value);
-		}
-		return trueCondition();
-	}
-	/**
-	* Parse a state token into a ConditionNode
-	*/
-	parseStateToken(value) {
-		if (value === "@starting") return createStartingCondition(false, value);
-		if (value.startsWith("@media:")) return createMediaTypeCondition(value.slice(7), false, value);
-		if (value.startsWith("@media(")) return this.parseMediaQuery(value);
-		if (value.startsWith("@supports(")) return this.parseSupportsQuery(value);
-		if (value.startsWith("@root(")) return this.parseRootState(value);
-		if (value.startsWith("@parent(")) return this.parseParentState(value);
-		if (value.startsWith("@own(")) return this.parseOwnState(value);
-		if (value.startsWith("@(")) return this.parseContainerQuery(value);
-		if (value.startsWith("@") && /^@[A-Za-z][A-Za-z0-9-]*$/.test(value)) return this.parsePredefinedState(value);
-		if (value.startsWith(":")) {
-			const enhancedMatch = /^:(is|has|not|where)\(/.exec(value);
-			if (enhancedMatch) {
-				const fn = enhancedMatch[1];
-				const prefix = enhancedMatch[0];
-				let content = transformSelectorContent(value.slice(prefix.length, -1));
-				content = content.replace(/([>+~])\s*$/, "$1 *");
-				if (fn === "not") return createPseudoCondition(`:is(${content})`, true, value);
-				return createPseudoCondition(`:${fn}(${content})`, false, value);
-			}
-			return createPseudoCondition(value, false, value);
-		}
-		if (value.startsWith(".")) return createPseudoCondition(value, false, value);
-		if (value.startsWith("[")) return createPseudoCondition(value, false, value);
-		if (value.includes("=")) return this.parseValueModifier(value);
-		return this.parseBooleanModifier(value);
-	}
-	/**
-	* Parse @media(...) query
-	*/
-	parseMediaQuery(raw) {
-		const content = raw.slice(7, -1);
-		if (!content.trim()) return trueCondition();
-		let condition = expandDimensionShorthands(content);
-		condition = expandTastyUnits(condition);
-		if (condition.includes(":") && !condition.includes("<") && !condition.includes(">") && !condition.includes("=")) {
-			const colonIdx = condition.indexOf(":");
-			return createMediaFeatureCondition(condition.slice(0, colonIdx).trim(), condition.slice(colonIdx + 1).trim(), false, raw);
-		}
-		if (!condition.includes("<") && !condition.includes(">") && !condition.includes("=")) return createMediaFeatureCondition(condition.trim(), void 0, false, raw);
-		const { dimension, lowerBound, upperBound } = this.parseDimensionCondition(condition);
-		if (!dimension) return createPseudoCondition(raw, false, raw);
-		return createMediaDimensionCondition(dimension, lowerBound, upperBound, false, raw);
-	}
-	/**
-	* Parse dimension condition string (e.g., "width < 768px", "600px <= width < 1200px")
-	*/
-	parseDimensionCondition(condition) {
-		const rangeMatch = condition.match(/^(.+?)\s*(<=|<)\s*(width|height|inline-size|block-size)\s*(<=|<)\s*(.+)$/);
-		if (rangeMatch) {
-			const [, lowerValue, lowerOp, dimension, upperOp, upperValue] = rangeMatch;
-			return {
-				dimension,
-				lowerBound: {
-					value: lowerValue.trim(),
-					valueNumeric: parseNumericValue(lowerValue.trim()),
-					inclusive: lowerOp === "<="
-				},
-				upperBound: {
-					value: upperValue.trim(),
-					valueNumeric: parseNumericValue(upperValue.trim()),
-					inclusive: upperOp === "<="
-				}
-			};
-		}
-		const simpleMatch = condition.match(/^(width|height|inline-size|block-size)\s*(<=|>=|<|>|=)\s*(.+)$/);
-		if (simpleMatch) {
-			const [, dimension, operator, value] = simpleMatch;
-			const numeric = parseNumericValue(value.trim());
-			if (operator === "<" || operator === "<=") return {
-				dimension,
-				upperBound: {
-					value: value.trim(),
-					valueNumeric: numeric,
-					inclusive: operator === "<="
-				}
-			};
-			else if (operator === ">" || operator === ">=") return {
-				dimension,
-				lowerBound: {
-					value: value.trim(),
-					valueNumeric: numeric,
-					inclusive: operator === ">="
-				}
-			};
-			else if (operator === "=") return {
-				dimension,
-				lowerBound: {
-					value: value.trim(),
-					valueNumeric: numeric,
-					inclusive: true
-				},
-				upperBound: {
-					value: value.trim(),
-					valueNumeric: numeric,
-					inclusive: true
-				}
-			};
-		}
-		const reversedMatch = condition.match(/^(.+?)\s*(<=|>=|<|>|=)\s*(width|height|inline-size|block-size)$/);
-		if (reversedMatch) {
-			const [, value, operator, dimension] = reversedMatch;
-			const numeric = parseNumericValue(value.trim());
-			if (operator === "<" || operator === "<=") return {
-				dimension,
-				lowerBound: {
-					value: value.trim(),
-					valueNumeric: numeric,
-					inclusive: operator === "<="
-				}
-			};
-			else if (operator === ">" || operator === ">=") return {
-				dimension,
-				upperBound: {
-					value: value.trim(),
-					valueNumeric: numeric,
-					inclusive: operator === ">="
-				}
-			};
-		}
-		return {};
-	}
-	/**
-	* Parse @root(...) state
-	*/
-	parseInnerCondition(raw, prefixLen, wrap) {
-		const content = raw.slice(prefixLen, -1);
-		if (!content.trim()) return trueCondition();
-		return wrap(parseStateKey(content, this.options));
-	}
-	parseRootState(raw) {
-		return this.parseInnerCondition(raw, 6, (inner) => createRootCondition(inner, false, raw));
-	}
-	/**
-	* Parse @parent(...) state
-	*
-	* Syntax:
-	*   @parent(hovered)      → :is([data-hovered] *)
-	*   @parent(theme=dark)   → :is([data-theme="dark"] *)
-	*   @parent(hovered, >)   → :is([data-hovered] > *)  (direct parent)
-	*   @parent(.my-class)    → :is(.my-class *)
-	*/
-	parseParentState(raw) {
-		const content = raw.slice(8, -1);
-		if (!content.trim()) return trueCondition();
-		let condition = content.trim();
-		let direct = false;
-		const lastCommaIdx = condition.lastIndexOf(",");
-		if (lastCommaIdx !== -1) {
-			if (condition.slice(lastCommaIdx + 1).trim() === ">") {
-				direct = true;
-				condition = condition.slice(0, lastCommaIdx).trim();
-			}
-		}
-		return createParentCondition(parseStateKey(condition, this.options), direct, false, raw);
-	}
-	/**
-	* Parse @supports(...) query
-	*
-	* Syntax:
-	*   @supports(display: grid)     → @supports (display: grid)
-	*   @supports($, :has(*))        → @supports selector(:has(*))
-	*/
-	parseSupportsQuery(raw) {
-		const content = raw.slice(10, -1);
-		if (!content.trim()) return trueCondition();
-		if (content.startsWith("$,")) return createSupportsCondition("selector", content.slice(2).trim(), false, raw);
-		return createSupportsCondition("feature", content, false, raw);
-	}
-	parseOwnState(raw) {
-		return this.parseInnerCondition(raw, 5, (inner) => createOwnCondition(inner, false, raw));
-	}
-	/**
-	* Parse @(...) container query
-	*/
-	parseContainerQuery(raw) {
-		const content = raw.slice(2, -1);
-		if (!content.trim()) return trueCondition();
-		const commaIdx = findTopLevelComma(content);
-		let containerName;
-		let condition;
-		if (commaIdx !== -1) {
-			containerName = content.slice(0, commaIdx).trim();
-			condition = content.slice(commaIdx + 1).trim();
-		} else condition = content.trim();
-		if (condition.startsWith("$")) {
-			const styleQuery = condition.slice(1);
-			const eqIdx = styleQuery.indexOf("=");
-			if (eqIdx === -1) return createContainerStyleCondition(styleQuery, void 0, containerName, false, raw);
-			const property = styleQuery.slice(0, eqIdx).trim();
-			let propertyValue = styleQuery.slice(eqIdx + 1).trim();
-			if (propertyValue.startsWith("\"") && propertyValue.endsWith("\"") || propertyValue.startsWith("'") && propertyValue.endsWith("'")) propertyValue = propertyValue.slice(1, -1);
-			return createContainerStyleCondition(property, propertyValue, containerName, false, raw);
-		}
-		if (/^[a-zA-Z][\w-]*\s*\(/.test(condition)) return createContainerRawCondition(condition, containerName, false, raw);
-		let expandedCondition = expandDimensionShorthands(condition);
-		expandedCondition = expandTastyUnits(expandedCondition);
-		const { dimension, lowerBound, upperBound } = this.parseDimensionCondition(expandedCondition);
-		if (!dimension) return createPseudoCondition(raw, false, raw);
-		return createContainerDimensionCondition(dimension, lowerBound, upperBound, containerName, false, raw);
-	}
-	/**
-	* Parse predefined state (@mobile, @dark, etc.)
-	*/
-	parsePredefinedState(raw) {
-		const ctx = this.options.context;
-		if (!ctx) return createPseudoCondition(raw, false, raw);
-		const resolved = resolvePredefinedState(raw, ctx);
-		if (!resolved) return createModifierCondition(`data-${camelToKebab(raw.slice(1))}`, void 0, "=", false, raw);
-		return parseStateKey(resolved, this.options);
-	}
-	/**
-	* Parse value modifier (e.g., theme=danger, size^=sm)
-	*/
-	parseValueModifier(raw) {
-		const opMatch = raw.match(/^([a-z][a-z0-9-]*)(\^=|\$=|\*=|=)(.+)$/i);
-		if (!opMatch) return createModifierCondition(`data-${camelToKebab(raw)}`, void 0, "=", false, raw);
-		const [, key, operator, value] = opMatch;
-		let cleanValue = value;
-		if (cleanValue.startsWith("\"") && cleanValue.endsWith("\"") || cleanValue.startsWith("'") && cleanValue.endsWith("'")) cleanValue = cleanValue.slice(1, -1);
-		return createModifierCondition(`data-${camelToKebab(key)}`, cleanValue, operator, false, raw);
-	}
-	/**
-	* Parse boolean modifier (e.g., hovered, disabled)
-	*/
-	parseBooleanModifier(raw) {
-		return createModifierCondition(`data-${camelToKebab(raw)}`, void 0, "=", false, raw);
-	}
-};
-/**
-* Parse a numeric value from a CSS value string
-*/
-function parseNumericValue(value) {
-	const match = value.match(/^(\d+(?:\.\d+)?)(px|em|rem|vh|vw|%)?$/);
-	if (match) return parseFloat(match[1]);
-	return null;
-}
-/**
-* Parse a state key string into a ConditionNode
-*/
-function parseStateKey(stateKey, options = {}) {
-	if (!stateKey || !stateKey.trim()) return trueCondition();
-	const trimmed = stateKey.trim();
-	const ctx = options.context;
-	const localStatesKey = ctx && Object.keys(ctx.localPredefinedStates).length > 0 ? JSON.stringify(ctx.localPredefinedStates) : "";
-	const cacheKey = trimmed + "\0" + (options.isSubElement ? "1" : "0") + "\0" + localStatesKey;
-	const cached = parseCache.get(cacheKey);
-	if (cached) return cached;
-	const result = new Parser(tokenize(trimmed), options).parse();
-	parseCache.set(cacheKey, result);
-	return result;
-}
-//#endregion
-export { parseStateKey };
-
-//# sourceMappingURL=parseStateKey.js.map