@tenphi/tasty 0.0.0-snapshot.09c74e2

package/dist/pipeline/materialize.js.map

@@ -0,0 +1 @@
+{"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 { getConditionUniqueId, not } from './conditions';\n\n// ============================================================================\n// Types\n// ============================================================================\n\n/**\n * Parsed media condition for structured analysis and combination\n */\nexport interface ParsedMediaCondition {\n  /** Subtype for structured analysis */\n  subtype: 'dimension' | 'feature' | 'type';\n  /** Whether this is a negated condition */\n  negated: boolean;\n  /** The condition part for CSS output (e.g., \"(width < 600px)\", \"print\") */\n  condition: string;\n  /** For dimension queries: dimension name */\n  dimension?: 'width' | 'height' | 'inline-size' | 'block-size';\n  /** For dimension queries: lower bound value */\n  lowerBound?: {\n    value: string;\n    valueNumeric: number | null;\n    inclusive: boolean;\n  };\n  /** For dimension queries: upper bound value */\n  upperBound?: {\n    value: string;\n    valueNumeric: number | null;\n    inclusive: boolean;\n  };\n  /** For feature queries: feature name */\n  feature?: string;\n  /** For feature queries: feature value */\n  featureValue?: string;\n  /** For type queries: media type */\n  mediaType?: 'print' | 'screen' | 'all' | 'speech';\n}\n\n/**\n * Parsed container condition for structured analysis and combination\n */\nexport interface ParsedContainerCondition {\n  /** Container name (undefined = unnamed/nearest container) */\n  name?: string;\n  /** The condition part (e.g., \"(width < 600px)\" or \"style(--variant: danger)\") */\n  condition: string;\n  /** Whether this is a negated condition */\n  negated: boolean;\n  /** Subtype for structured analysis */\n  subtype: 'dimension' | 'style' | 'raw';\n  /** For style queries: property name (without --) */\n  property?: string;\n  /** For style queries: property value (undefined = existence check) */\n  propertyValue?: string;\n}\n\n/**\n * Parsed supports condition for structured analysis and combination\n */\nexport interface ParsedSupportsCondition {\n  /** Subtype: 'feature' for property support, 'selector' for selector() support */\n  subtype: 'feature' | 'selector';\n  /** The condition string (e.g., \"display: grid\" or \":has(*)\") */\n  condition: string;\n  /** Whether this is a negated condition */\n  negated: boolean;\n}\n\n/**\n * Parsed modifier condition for structured analysis\n */\nexport interface ParsedModifierCondition {\n  /** Attribute name (e.g., 'data-hovered', 'data-size') */\n  attribute: string;\n  /** Value if present (e.g., 'large', 'danger') */\n  value?: string;\n  /** Operator for value matching (default '=') */\n  operator?: '=' | '^=' | '$=' | '*=';\n  /** Whether this is negated (:not(...)) */\n  negated: boolean;\n}\n\n/**\n * Parsed pseudo-class condition for structured analysis\n */\nexport interface ParsedPseudoCondition {\n  /** The pseudo-class (e.g., ':hover', ':focus-visible', ':has(> Icon)') */\n  pseudo: string;\n  /** Whether this is negated (:not(...)) */\n  negated: boolean;\n}\n\n/** Modifier or pseudo condition (shared across own/root/parent) */\ntype ParsedSelectorCondition = ParsedModifierCondition | ParsedPseudoCondition;\n\n/**\n * A group of parent conditions originating from a single @parent() call.\n * Each group produces its own :is() wrapper in the final CSS.\n * Separate @parent() calls = separate groups = can match different ancestors.\n * @parent(a & b) = one group with two conditions = same ancestor must match both.\n */\nexport interface ParentGroup {\n  conditions: ParsedSelectorCondition[];\n  direct: boolean;\n  negated: boolean;\n}\n\n/**\n * A single selector variant (one term in a DNF expression)\n */\nexport interface SelectorVariant {\n  /** Structured modifier conditions */\n  modifierConditions: ParsedModifierCondition[];\n\n  /** Structured pseudo conditions */\n  pseudoConditions: ParsedPseudoCondition[];\n\n  /** Structured own conditions (for sub-element states) */\n  ownConditions: ParsedSelectorCondition[];\n\n  /** Parsed media conditions for structured combination */\n  mediaConditions: ParsedMediaCondition[];\n\n  /** Parsed container conditions for structured combination */\n  containerConditions: ParsedContainerCondition[];\n\n  /** Parsed supports conditions for @supports at-rules */\n  supportsConditions: ParsedSupportsCondition[];\n\n  /** Root conditions (modifier/pseudo applied to :root) */\n  rootConditions: ParsedSelectorCondition[];\n\n  /** Parent condition groups — each @parent() call is a separate group */\n  parentGroups: ParentGroup[];\n\n  /** Whether to wrap in @starting-style */\n  startingStyle: boolean;\n}\n\n/**\n * CSS output components extracted from a condition\n * Supports multiple variants for OR conditions (DNF form)\n */\nexport interface CSSComponents {\n  /** Selector variants - OR means multiple variants, AND means single variant with combined selectors */\n  variants: SelectorVariant[];\n\n  /** Whether condition is impossible (should skip) */\n  isImpossible: boolean;\n}\n\n/**\n * Final CSS rule output\n */\nexport interface CSSRule {\n  /** Single selector or array of selector fragments (for OR conditions) */\n  selector: string | string[];\n  declarations: string;\n  atRules?: string[];\n  rootPrefix?: string;\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    ownConditions: [],\n    mediaConditions: [],\n    containerConditions: [],\n    supportsConditions: [],\n    rootConditions: [],\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        'rootConditions',\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        'ownConditions',\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 */\nexport function pseudoToCSS(pseudo: ParsedPseudoCondition): string {\n  if (pseudo.negated) {\n    // Wrap in :not() if not already\n    if (pseudo.pseudo.startsWith(':not(')) {\n      // Double negation - remove :not()\n      return pseudo.pseudo.slice(5, -1);\n    }\n    return `:not(${pseudo.pseudo})`;\n  }\n  return pseudo.pseudo;\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 SelectorVariants.\n * Each inner OR branch becomes a separate variant, preserving disjunction.\n * Shared by @root() and @own().\n */\nfunction innerConditionToVariants(\n  innerCondition: ConditionNode,\n  negated: boolean,\n  target: 'rootConditions' | 'ownConditions',\n): CSSComponents {\n  // For @root/@own, negation is applied upfront via De Morgan: !(A | B) = !A & !B.\n  // This is safe because the negated conditions are appended directly to the same\n  // selector (e.g. :root:not([a]):not([b])), so collapsing OR branches is correct.\n  //\n  // @parent uses a different strategy (parentConditionToVariants) because each OR\n  // branch must become its own :not(... *) wrapper — the * combinator scopes to a\n  // specific ancestor, so branches cannot be merged into one selector.\n  const effectiveCondition = negated ? not(innerCondition) : innerCondition;\n  const innerCSS = conditionToCSS(effectiveCondition);\n\n  if (innerCSS.isImpossible || innerCSS.variants.length === 0) {\n    return { variants: [], isImpossible: true };\n  }\n\n  const variants: SelectorVariant[] = [];\n\n  for (const innerVariant of innerCSS.variants) {\n    const conditions = collectSelectorConditions(innerVariant);\n\n    if (conditions.length > 0) {\n      const v = emptyVariant();\n      v[target].push(...conditions);\n      variants.push(v);\n    }\n  }\n\n  if (variants.length === 0) {\n    return { variants: [emptyVariant()], isImpossible: false };\n  }\n\n  return { variants, isImpossible: false };\n}\n\n/**\n * Convert a @parent() inner condition into SelectorVariants with ParentGroups.\n *\n * Positive: each inner OR branch becomes a separate variant with one :is() group.\n * Negated: !(A | B) = !A & !B — all branches become :not() groups collected\n * into a single variant so they produce :not([a] *):not([b] *) on one element.\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  if (negated) {\n    // Collect all OR branches into one variant as separate :not() groups.\n    const v = emptyVariant();\n\n    for (const innerVariant of innerCSS.variants) {\n      const conditions = collectSelectorConditions(innerVariant);\n\n      if (conditions.length > 0) {\n        v.parentGroups.push({ conditions, direct, negated: true });\n      }\n    }\n\n    if (v.parentGroups.length === 0) {\n      return { variants: [emptyVariant()], isImpossible: false };\n    }\n\n    return { variants: [v], isImpossible: false };\n  }\n\n  // Positive: each OR branch is a separate variant\n  const variants: SelectorVariant[] = [];\n\n  for (const innerVariant of innerCSS.variants) {\n    const conditions = collectSelectorConditions(innerVariant);\n\n    if (conditions.length > 0) {\n      const v = emptyVariant();\n      v.parentGroups.push({ conditions, direct, negated: false });\n      variants.push(v);\n    }\n  }\n\n  if (variants.length === 0) {\n    return { variants: [emptyVariant()], isImpossible: false };\n  }\n\n  return { variants, isImpossible: false };\n}\n\n/**\n * Convert parsed root conditions to CSS selector prefix (for final output)\n */\nexport function rootConditionsToCSS(\n  roots: ParsedSelectorCondition[],\n): string | undefined {\n  if (roots.length === 0) return undefined;\n\n  let prefix = ':root';\n  for (const cond of roots) {\n    prefix += selectorConditionToCSS(cond);\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() wrapper.\n */\nexport function parentGroupsToCSS(groups: ParentGroup[]): string {\n  let result = '';\n  for (const group of groups) {\n    const combinator = group.direct ? ' > *' : ' *';\n    let parts = '';\n    for (const cond of group.conditions) {\n      parts += selectorConditionToCSS(cond);\n    }\n    const wrapper = group.negated ? ':not' : ':is';\n    result += `${wrapper}(${parts}${combinator})`;\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  let 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  // :not([data-attr]) subsumes :not([data-attr=\"value\"])\n  // [data-attr=\"X\"] implies :not([data-attr=\"Y\"]) is redundant\n  // This implication only holds for exact-match (=) operators; substring\n  // operators (^=, $=, *=) don't imply exclusivity between values.\n  const negatedBooleanAttrs = new Set<string>();\n  const positiveExactValuesByAttr = new Map<string, Set<string>>();\n\n  for (const c of result) {\n    if (!('attribute' in c)) continue;\n    if (c.negated && c.value === undefined) {\n      negatedBooleanAttrs.add(c.attribute);\n    }\n    const op = c.operator ?? '=';\n    if (!c.negated && c.value !== undefined && op === '=') {\n      let values = positiveExactValuesByAttr.get(c.attribute);\n      if (!values) {\n        values = new Set();\n        positiveExactValuesByAttr.set(c.attribute, values);\n      }\n      values.add(c.value);\n    }\n  }\n\n  result = result.filter((c) => {\n    if (!('attribute' in c) || !c.negated || c.value === undefined) {\n      return true;\n    }\n    if (negatedBooleanAttrs.has(c.attribute)) {\n      return false;\n    }\n    const op = c.operator ?? '=';\n    if (op !== '=') return true;\n    const positiveValues = positiveExactValuesByAttr.get(c.attribute);\n    if (\n      positiveValues !== undefined &&\n      positiveValues.size === 1 &&\n      !positiveValues.has(c.value)\n    ) {\n      return false;\n    }\n    return true;\n  });\n\n  return result;\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 hasParentGroupContradiction(groups: ParentGroup[]): boolean {\n  const byBaseKey = new Map<string, boolean>();\n\n  for (const g of groups) {\n    const baseKey = `${g.direct ? '>' : ''}(${g.conditions.map(getSelectorConditionKey).sort().join(',')})`;\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  // Merge root conditions and check for contradictions\n  const mergedRoots = dedupeSelectorConditions([\n    ...a.rootConditions,\n    ...b.rootConditions,\n  ]);\n  if (hasSelectorConditionContradiction(mergedRoots)) {\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 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  // Merge own conditions and check for contradictions\n  const mergedOwn = dedupeSelectorConditions([\n    ...a.ownConditions,\n    ...b.ownConditions,\n  ]);\n  if (hasSelectorConditionContradiction(mergedOwn)) {\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    ownConditions: mergedOwn,\n    mediaConditions: mergedMedia,\n    containerConditions: mergedContainers,\n    supportsConditions: mergedSupports,\n    rootConditions: mergedRoots,\n    parentGroups: mergedParentGroups,\n    startingStyle: a.startingStyle || b.startingStyle,\n  };\n}\n\n/**\n * Generic deduplication by a key extraction function.\n * Preserves insertion order, keeping the first occurrence of each key.\n */\nfunction dedupeByKey<T>(items: T[], getKey: (item: T) => string): T[] {\n  const seen = new Set<string>();\n  const result: T[] = [];\n  for (const item of items) {\n    const key = getKey(item);\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(item);\n    }\n  }\n  return result;\n}\n\nfunction dedupeMediaConditions(\n  conditions: ParsedMediaCondition[],\n): ParsedMediaCondition[] {\n  return dedupeByKey(\n    conditions,\n    (c) => `${c.subtype}|${c.condition}|${c.negated}`,\n  );\n}\n\nfunction dedupeContainerConditions(\n  conditions: ParsedContainerCondition[],\n): ParsedContainerCondition[] {\n  return dedupeByKey(\n    conditions,\n    (c) => `${c.name ?? ''}|${c.condition}|${c.negated}`,\n  );\n}\n\nfunction dedupeSupportsConditions(\n  conditions: ParsedSupportsCondition[],\n): ParsedSupportsCondition[] {\n  return dedupeByKey(\n    conditions,\n    (c) => `${c.subtype}|${c.condition}|${c.negated}`,\n  );\n}\n\n/**\n * Check if supports conditions contain contradictions\n * e.g., @supports(display: grid) AND NOT @supports(display: grid)\n */\nfunction hasSupportsContradiction(\n  conditions: ParsedSupportsCondition[],\n): boolean {\n  const conditionMap = new Map<string, boolean>(); // key -> isPositive\n\n  for (const cond of conditions) {\n    const key = `${cond.subtype}|${cond.condition}`;\n    const existing = conditionMap.get(key);\n    if (existing !== undefined && existing !== !cond.negated) {\n      return true; // Contradiction: positive AND negated\n    }\n    conditionMap.set(key, !cond.negated);\n  }\n\n  return false;\n}\n\n/**\n * Check if a set of media conditions contains contradictions\n * e.g., (prefers-color-scheme: light) AND NOT (prefers-color-scheme: light)\n * or (width >= 900px) AND (width < 600px)\n *\n * Uses parsed media conditions for efficient analysis without regex parsing.\n */\nfunction hasMediaContradiction(conditions: ParsedMediaCondition[]): boolean {\n  // Track conditions by their key (condition string) to detect A and NOT A\n  const featureConditions = new Map<string, boolean>(); // key -> isPositive\n  const typeConditions = new Map<string, boolean>(); // mediaType -> isPositive\n  const dimensionConditions = new Map<string, boolean>(); // condition -> isPositive\n\n  // Track dimension conditions for range contradiction detection (non-negated only)\n  const dimensionsByDim = new Map<\n    string,\n    { lowerBound: number | null; upperBound: number | null }\n  >();\n\n  for (const cond of conditions) {\n    if (cond.subtype === 'type') {\n      // Type query: check for direct contradiction (print AND NOT print)\n      const key = cond.mediaType || 'all';\n      const existing = typeConditions.get(key);\n      if (existing !== undefined && existing !== !cond.negated) {\n        return true; // Contradiction: positive AND negated\n      }\n      typeConditions.set(key, !cond.negated);\n    } else if (cond.subtype === 'feature') {\n      // Feature query: check for direct contradiction\n      const key = cond.condition;\n      const existing = featureConditions.get(key);\n      if (existing !== undefined && existing !== !cond.negated) {\n        return true; // Contradiction: positive AND negated\n      }\n      featureConditions.set(key, !cond.negated);\n    } else if (cond.subtype === 'dimension') {\n      // First, check for direct contradiction: (width < 600px) AND NOT (width < 600px)\n      const condKey = cond.condition;\n      const existing = dimensionConditions.get(condKey);\n      if (existing !== undefined && existing !== !cond.negated) {\n        return true; // Contradiction: positive AND negated\n      }\n      dimensionConditions.set(condKey, !cond.negated);\n\n      // For range analysis, only consider non-negated conditions\n      // Negated conditions are handled via the direct contradiction check above\n      if (!cond.negated) {\n        const dim = cond.dimension || 'width';\n        let bounds = dimensionsByDim.get(dim);\n        if (!bounds) {\n          bounds = { lowerBound: null, upperBound: null };\n          dimensionsByDim.set(dim, bounds);\n        }\n\n        // Track the effective bounds\n        if (cond.lowerBound?.valueNumeric != null) {\n          const value = cond.lowerBound.valueNumeric;\n          if (bounds.lowerBound === null || value > bounds.lowerBound) {\n            bounds.lowerBound = value;\n          }\n        }\n        if (cond.upperBound?.valueNumeric != null) {\n          const value = cond.upperBound.valueNumeric;\n          if (bounds.upperBound === null || value < bounds.upperBound) {\n            bounds.upperBound = value;\n          }\n        }\n\n        // Check for impossible range\n        if (\n          bounds.lowerBound !== null &&\n          bounds.upperBound !== null &&\n          bounds.lowerBound >= bounds.upperBound\n        ) {\n          return true;\n        }\n      }\n    }\n  }\n\n  return false;\n}\n\n/**\n * Check if container conditions contain contradictions in style queries\n * e.g., style(--variant: danger) and style(--variant: success) together\n * Same property with different values = always false\n *\n * Uses parsed container conditions for efficient analysis without regex parsing.\n */\nfunction hasContainerStyleContradiction(\n  conditions: ParsedContainerCondition[],\n): boolean {\n  // Track style queries by property name\n  // key: property name, value: { hasExistence: boolean, values: Set<string>, hasNegatedExistence: boolean }\n  const styleQueries = new Map<\n    string,\n    { hasExistence: boolean; values: Set<string>; hasNegatedExistence: boolean }\n  >();\n\n  for (const cond of conditions) {\n    // Only analyze style queries\n    if (cond.subtype !== 'style' || !cond.property) {\n      continue;\n    }\n\n    const property = cond.property;\n    const value = cond.propertyValue;\n\n    if (!styleQueries.has(property)) {\n      styleQueries.set(property, {\n        hasExistence: false,\n        values: new Set(),\n        hasNegatedExistence: false,\n      });\n    }\n\n    const entry = styleQueries.get(property)!;\n\n    if (cond.negated) {\n      if (value === undefined) {\n        // not style(--prop) - negated existence check\n        entry.hasNegatedExistence = true;\n      }\n      // Negated value checks don't contradict positive value checks directly\n      // They just mean \"not this value\"\n    } else {\n      if (value === undefined) {\n        // style(--prop) - existence check\n        entry.hasExistence = true;\n      } else {\n        // style(--prop: value) - value check\n        entry.values.add(value);\n      }\n    }\n  }\n\n  // Check for contradictions\n  for (const [, entry] of styleQueries) {\n    // Contradiction: existence check + negated existence check\n    if (entry.hasExistence && entry.hasNegatedExistence) {\n      return true;\n    }\n\n    // Contradiction: multiple different values for same property\n    // style(--variant: danger) AND style(--variant: success) is impossible\n    if (entry.values.size > 1) {\n      return true;\n    }\n\n    // Contradiction: negated existence + value check\n    // not style(--variant) AND style(--variant: danger) is impossible\n    if (entry.hasNegatedExistence && entry.values.size > 0) {\n      return true;\n    }\n  }\n\n  return false;\n}\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 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 ownKey = v.ownConditions.map(getSelectorConditionKey).sort().join('|');\n  const containerKey = v.containerConditions\n    .map((c) => `${c.name ?? ''}:${c.negated ? '!' : ''}${c.condition}`)\n    .sort()\n    .join('|');\n  const mediaKey = v.mediaConditions\n    .map((c) => `${c.subtype}:${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.rootConditions\n    .map(getSelectorConditionKey)\n    .sort()\n    .join('|');\n  const parentKey = v.parentGroups.map(getParentGroupKey).sort().join('|');\n  const key = [\n    modifierKey,\n    pseudoKey,\n    ownKey,\n    mediaKey,\n    containerKey,\n    supportsKey,\n    rootKey,\n    parentKey,\n    v.startingStyle ? '1' : '0',\n  ].join('###');\n  variantKeyCache.set(v, key);\n  return key;\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.rootConditions is superset of b.rootConditions\n  if (!isSelectorConditionsSuperset(a.rootConditions, b.rootConditions))\n    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.ownConditions is superset of b.ownConditions\n  if (!isSelectorConditionsSuperset(a.ownConditions, b.ownConditions))\n    return false;\n\n  // Check if a.parentGroups is superset of b.parentGroups\n  if (!isParentGroupsSuperset(a.parentGroups, b.parentGroups)) return false;\n\n  // A is a superset if it has all of B's items (possibly more)\n  // and at least one category has strictly more items\n  const parentConditionCount = (groups: ParentGroup[]) =>\n    groups.reduce((sum, g) => sum + g.conditions.length, 0);\n  const aTotal =\n    a.mediaConditions.length +\n    a.containerConditions.length +\n    a.supportsConditions.length +\n    a.modifierConditions.length +\n    a.pseudoConditions.length +\n    a.rootConditions.length +\n    parentConditionCount(a.parentGroups) +\n    a.ownConditions.length;\n  const bTotal =\n    b.mediaConditions.length +\n    b.containerConditions.length +\n    b.supportsConditions.length +\n    b.modifierConditions.length +\n    b.pseudoConditions.length +\n    b.rootConditions.length +\n    parentConditionCount(b.parentGroups) +\n    b.ownConditions.length;\n\n  return aTotal > bTotal;\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 isSelectorConditionsSuperset(\n  a: ParsedSelectorCondition[],\n  b: ParsedSelectorCondition[],\n): boolean {\n  return isConditionsSuperset(a, b, getSelectorConditionKey);\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 ? '>' : ''}(${g.conditions.map(getSelectorConditionKey).sort().join(',')})`;\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  // 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  // Second pass: remove supersets (more restrictive variants)\n  // Sort by total condition count (fewer conditions = less restrictive = keep)\n  const variantConditionCount = (v: SelectorVariant) =>\n    v.modifierConditions.length +\n    v.pseudoConditions.length +\n    v.ownConditions.length +\n    v.mediaConditions.length +\n    v.containerConditions.length +\n    v.supportsConditions.length +\n    v.rootConditions.length +\n    v.parentGroups.reduce((sum, g) => sum + g.conditions.length, 0);\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  // Start with a single empty variant\n  let currentVariants: SelectorVariant[] = [emptyVariant()];\n\n  for (const child of children) {\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 * Combine OR conditions into CSS\n *\n * OR in CSS means multiple selector variants (DNF).\n * Each variant becomes a separate selector in the comma-separated list,\n * or multiple CSS rules if they have different at-rules.\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  // Deduplicate variants\n  return {\n    variants: dedupeVariants(allVariants),\n    isImpossible: false,\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  // Add starting-style\n  if (variant.startingStyle) {\n    atRules.push('@starting-style');\n  }\n\n  return atRules;\n}\n"],"mappings":"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"}

package/dist/pipeline/parseStateKey.d.ts

@@ -0,0 +1,15 @@
+import { StateParserContext } from "../states/index.js";
+import { ConditionNode } from "./conditions.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

@@ -0,0 +1,438 @@
+import { Lru } from "../parser/lru.js";
+import { expandDimensionShorthands, expandTastyUnits, findTopLevelComma, resolvePredefinedState } from "../states/index.js";
+import { camelToKebab } from "../utils/case-converter.js";
+import { and, createContainerDimensionCondition, createContainerRawCondition, createContainerStyleCondition, createMediaDimensionCondition, createMediaFeatureCondition, createMediaTypeCondition, createModifierCondition, createOwnCondition, createParentCondition, createPseudoCondition, createRootCondition, createStartingCondition, createSupportsCondition, not, or, trueCondition } from "./conditions.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.
+*
+* Note: For @supports and @(...) container queries we need to handle nested parentheses
+* like @supports($, :has(*)) or @(scroll-state(stuck: top)).
+* We use a pattern that allows one level of nesting: [^()]*(?:\([^)]*\))?[^)]*
+*/
+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-]+)|(:[-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(":")) 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 = JSON.stringify([
+		trimmed,
+		options.isSubElement,
+		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