@tenphi/tasty 1.5.4 → 2.0.1

package/dist/pipeline/materialize.js.map

@@ -1 +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 } 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 selector conditions that produces an :is() or :not() wrapper.\n *\n * Each branch is an AND conjunction of conditions (one selector fragment).\n * Multiple branches are OR'd together inside the :is()/:not() wrapper.\n *\n * Example: size=small | size=medium\n *   branches: [[size=small], [size=medium]]\n *   renders:  :is([data-size=\"small\"], [data-size=\"medium\"])\n *\n * When negated, :is() becomes :not():\n *   :not([data-size=\"small\"], [data-size=\"medium\"])\n *\n * Single-branch groups are unwrapped (no :is() wrapper):\n *   branches: [[size=small]]\n *   renders:  [data-size=\"small\"]\n */\nexport interface SelectorGroup {\n  branches: ParsedSelectorCondition[][];\n  negated: boolean;\n}\n\n/**\n * A group of parent conditions originating from a single @parent() call.\n * Each group produces its own :is()/:not() wrapper in the final CSS.\n * Separate @parent() calls = separate groups = can match different ancestors.\n *\n * Extends SelectorGroup with a `direct` flag for ancestor combinator:\n *   direct = false → ` *` (any ancestor)\n *   direct = true  → ` > *` (direct parent only)\n *\n * Example: @parent(hovered & pressed | active)\n *   branches: [[hovered, pressed], [active]]\n *   renders:  :is([data-hovered][data-pressed] *, [data-active] *)\n */\nexport interface ParentGroup extends SelectorGroup {\n  direct: boolean;\n}\n\n/**\n * A single selector variant (one term in a DNF expression)\n */\nexport interface SelectorVariant {\n  /** Structured modifier conditions (flat AND) */\n  modifierConditions: ParsedModifierCondition[];\n\n  /** Structured pseudo conditions (flat AND) */\n  pseudoConditions: ParsedPseudoCondition[];\n\n  /** Selector groups — :is()/:not() wrappers for OR branches on the element */\n  selectorGroups: SelectorGroup[];\n\n  /** Own groups — :is()/:not() wrappers for @own() OR branches on sub-elements */\n  ownGroups: SelectorGroup[];\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 groups — :is()/:not() wrappers for @root() OR branches */\n  rootGroups: SelectorGroup[];\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  /** When true, declarations are wrapped in @starting-style { ... } inside the selector rule */\n  startingStyle?: boolean;\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/**\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 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  // 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 * 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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"}
+{"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';\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 selector conditions that produces an :is() or :not() wrapper.\n *\n * Each branch is an AND conjunction of conditions (one selector fragment).\n * Multiple branches are OR'd together inside the :is()/:not() wrapper.\n *\n * Example: size=small | size=medium\n *   branches: [[size=small], [size=medium]]\n *   renders:  :is([data-size=\"small\"], [data-size=\"medium\"])\n *\n * When negated, :is() becomes :not():\n *   :not([data-size=\"small\"], [data-size=\"medium\"])\n *\n * Single-branch groups are unwrapped (no :is() wrapper):\n *   branches: [[size=small]]\n *   renders:  [data-size=\"small\"]\n */\nexport interface SelectorGroup {\n  branches: ParsedSelectorCondition[][];\n  negated: boolean;\n}\n\n/**\n * A group of parent conditions originating from a single @parent() call.\n * Each group produces its own :is()/:not() wrapper in the final CSS.\n * Separate @parent() calls = separate groups = can match different ancestors.\n *\n * Extends SelectorGroup with a `direct` flag for ancestor combinator:\n *   direct = false → ` *` (any ancestor)\n *   direct = true  → ` > *` (direct parent only)\n *\n * Example: @parent(hovered & pressed | active)\n *   branches: [[hovered, pressed], [active]]\n *   renders:  :is([data-hovered][data-pressed] *, [data-active] *)\n */\nexport interface ParentGroup extends SelectorGroup {\n  direct: boolean;\n}\n\n/**\n * A single selector variant (one term in a DNF expression)\n */\nexport interface SelectorVariant {\n  /** Structured modifier conditions (flat AND) */\n  modifierConditions: ParsedModifierCondition[];\n\n  /** Structured pseudo conditions (flat AND) */\n  pseudoConditions: ParsedPseudoCondition[];\n\n  /** Selector groups — :is()/:not() wrappers for OR branches on the element */\n  selectorGroups: SelectorGroup[];\n\n  /** Own groups — :is()/:not() wrappers for @own() OR branches on sub-elements */\n  ownGroups: SelectorGroup[];\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 groups — :is()/:not() wrappers for @root() OR branches */\n  rootGroups: SelectorGroup[];\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  /** When true, declarations are wrapped in @starting-style { ... } inside the selector rule */\n  startingStyle?: boolean;\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/**\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 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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"}