@tenphi/tasty 0.1.0

package/dist/pipeline/materialize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"materialize.js","names":[],"sources":["../../src/pipeline/materialize.ts"],"sourcesContent":["/**\n * CSS Materialization\n *\n * Converts condition trees into CSS selectors and at-rules.\n * This is the final stage that produces actual CSS output.\n */\n\nimport { Lru } from '../parser/lru';\n\nimport type {\n  ConditionNode,\n  ContainerCondition,\n  MediaCondition,\n  ModifierCondition,\n  OwnCondition,\n  PseudoCondition,\n  RootCondition,\n  StateCondition,\n  SupportsCondition} 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/**\n * Parsed root condition for structured analysis\n */\nexport interface ParsedRootCondition {\n  /** The selector part (e.g., '[data-theme=\"dark\"]') */\n  selector: string;\n  /** Whether this is negated (:root:not(...)) */\n  negated: boolean;\n}\n\n/**\n * A single selector variant (one term in a DNF expression)\n */\nexport interface SelectorVariant {\n  /** Structured modifier conditions */\n  modifierConditions: ParsedModifierCondition[];\n\n  /** Structured pseudo conditions */\n  pseudoConditions: ParsedPseudoCondition[];\n\n  /** Structured own conditions (for sub-element states) */\n  ownConditions: (ParsedModifierCondition | ParsedPseudoCondition)[];\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  /** Structured root conditions */\n  rootConditions: ParsedRootCondition[];\n\n  /** Whether to wrap in @starting-style */\n  startingStyle: boolean;\n}\n\n/**\n * CSS output components extracted from a condition\n * Supports multiple variants for OR conditions (DNF form)\n */\nexport interface CSSComponents {\n  /** Selector variants - OR means multiple variants, AND means single variant with combined selectors */\n  variants: SelectorVariant[];\n\n  /** Whether condition is impossible (should skip) */\n  isImpossible: boolean;\n}\n\n/**\n * Final CSS rule output\n */\nexport interface CSSRule {\n  /** Single selector or array of selector fragments (for OR conditions) */\n  selector: string | string[];\n  declarations: string;\n  atRules?: string[];\n  rootPrefix?: string;\n}\n\n// ============================================================================\n// Caching\n// ============================================================================\n\nconst conditionCache = new Lru<string, CSSComponents>(3000);\n\n// ============================================================================\n// Main Functions\n// ============================================================================\n\n/**\n * Convert a condition tree to CSS components\n */\nexport function conditionToCSS(node: ConditionNode): CSSComponents {\n  // Check cache\n  const key = getConditionKey(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\n/**\n * Create an empty selector variant\n */\nfunction emptyVariant(): SelectorVariant {\n  return {\n    modifierConditions: [],\n    pseudoConditions: [],\n    ownConditions: [],\n    mediaConditions: [],\n    containerConditions: [],\n    supportsConditions: [],\n    rootConditions: [],\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      // Media conditions can return multiple variants for negated ranges (OR branches)\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    default: {\n      const variant: SelectorVariant = emptyVariant();\n\n      switch (state.type) {\n        case 'modifier':\n          variant.modifierConditions.push(modifierToParsed(state));\n          break;\n\n        case 'pseudo':\n          variant.pseudoConditions.push(pseudoToParsed(state));\n          break;\n\n        case 'container':\n          variant.containerConditions.push(containerToParsed(state));\n          break;\n\n        case 'supports':\n          variant.supportsConditions.push(supportsToParsed(state));\n          break;\n\n        case 'root':\n          variant.rootConditions.push(rootToParsed(state));\n          break;\n\n        case 'own':\n          variant.ownConditions.push(...ownToParsed(state));\n          break;\n\n        case 'starting':\n          variant.startingStyle = !state.negated;\n          break;\n      }\n\n      return {\n        variants: [variant],\n        isImpossible: false,\n      };\n    }\n  }\n}\n\n/**\n * Convert modifier condition to parsed structure\n */\nfunction modifierToParsed(state: ModifierCondition): ParsedModifierCondition {\n  return {\n    attribute: state.attribute,\n    value: state.value,\n    operator: state.operator,\n    negated: state.negated ?? false,\n  };\n}\n\n/**\n * Convert parsed modifier to CSS selector string (for final output)\n */\nexport function modifierToCSS(mod: ParsedModifierCondition): string {\n  let selector: string;\n\n  if (mod.value !== undefined) {\n    // Value attribute: [data-attr=\"value\"]\n    const op = mod.operator || '=';\n    selector = `[${mod.attribute}${op}\"${mod.value}\"]`;\n  } else {\n    // Boolean attribute: [data-attr]\n    selector = `[${mod.attribute}]`;\n  }\n\n  if (mod.negated) {\n    return `:not(${selector})`;\n  }\n  return selector;\n}\n\n/**\n * Convert pseudo condition to parsed structure\n */\nfunction pseudoToParsed(state: PseudoCondition): ParsedPseudoCondition {\n  return {\n    pseudo: state.pseudo,\n    negated: state.negated ?? false,\n  };\n}\n\n/**\n * Convert parsed pseudo to CSS selector string (for final output)\n */\nexport function pseudoToCSS(pseudo: ParsedPseudoCondition): string {\n  if (pseudo.negated) {\n    // Wrap in :not() if not already\n    if (pseudo.pseudo.startsWith(':not(')) {\n      // Double negation - remove :not()\n      return pseudo.pseudo.slice(5, -1);\n    }\n    return `:not(${pseudo.pseudo})`;\n  }\n  return pseudo.pseudo;\n}\n\n/**\n * Convert media condition to parsed structure(s)\n * Returns an array because negated ranges produce OR branches (two separate conditions)\n */\nfunction mediaToParsed(state: MediaCondition): ParsedMediaCondition[] {\n  if (state.subtype === 'type') {\n    // @media:print → @media print (or @media not print)\n    const mediaType = state.mediaType || 'all';\n    return [\n      {\n        subtype: 'type',\n        negated: state.negated ?? false,\n        condition: mediaType,\n        mediaType: state.mediaType,\n      },\n    ];\n  } else if (state.subtype === 'feature') {\n    // @media(prefers-contrast: high) → @media (prefers-contrast: high)\n    let condition: string;\n    if (state.featureValue) {\n      condition = `(${state.feature}: ${state.featureValue})`;\n    } else {\n      condition = `(${state.feature})`;\n    }\n    return [\n      {\n        subtype: 'feature',\n        negated: state.negated ?? false,\n        condition,\n        feature: state.feature,\n        featureValue: state.featureValue,\n      },\n    ];\n  } else {\n    // Dimension query - negation is handled by inverting the condition\n    // because \"not (width < x)\" doesn't work reliably in browsers\n    return dimensionToMediaParsed(\n      state.dimension || 'width',\n      state.lowerBound,\n      state.upperBound,\n      state.negated ?? false,\n    );\n  }\n}\n\n/**\n * Convert dimension bounds to parsed media condition(s)\n * Uses CSS Media Queries Level 4 `not (condition)` syntax for negation.\n */\nfunction dimensionToMediaParsed(\n  dimension: 'width' | 'height' | 'inline-size' | 'block-size',\n  lowerBound?: {\n    value: string;\n    valueNumeric: number | null;\n    inclusive: boolean;\n  },\n  upperBound?: {\n    value: string;\n    valueNumeric: number | null;\n    inclusive: boolean;\n  },\n  negated?: boolean,\n): ParsedMediaCondition[] {\n  // Build the condition string\n  let condition: string;\n  if (lowerBound && upperBound) {\n    const lowerOp = lowerBound.inclusive ? '<=' : '<';\n    const upperOp = upperBound.inclusive ? '<=' : '<';\n    condition = `(${lowerBound.value} ${lowerOp} ${dimension} ${upperOp} ${upperBound.value})`;\n  } else if (upperBound) {\n    const op = upperBound.inclusive ? '<=' : '<';\n    condition = `(${dimension} ${op} ${upperBound.value})`;\n  } else if (lowerBound) {\n    const op = lowerBound.inclusive ? '>=' : '>';\n    condition = `(${dimension} ${op} ${lowerBound.value})`;\n  } else {\n    condition = `(${dimension})`;\n  }\n\n  // For negation, we use CSS `not (condition)` syntax in buildAtRulesFromVariant\n  return [\n    {\n      subtype: 'dimension',\n      negated: negated ?? false,\n      condition,\n      dimension,\n      lowerBound,\n      upperBound,\n    },\n  ];\n}\n\n/**\n * Convert container condition to parsed structure\n * This enables structured analysis for contradiction detection and condition combining\n */\nfunction containerToParsed(\n  state: ContainerCondition,\n): ParsedContainerCondition {\n  let condition: string;\n\n  if (state.subtype === 'style') {\n    // Style query: style(--prop: value)\n    if (state.propertyValue) {\n      condition = `style(--${state.property}: ${state.propertyValue})`;\n    } else {\n      condition = `style(--${state.property})`;\n    }\n  } else if (state.subtype === 'raw') {\n    // Raw function query: passed through verbatim (e.g., scroll-state(stuck: top))\n    condition = state.rawCondition!;\n  } else {\n    // Dimension query\n    condition = dimensionToContainerCondition(\n      state.dimension || 'width',\n      state.lowerBound,\n      state.upperBound,\n    );\n  }\n\n  return {\n    name: state.containerName,\n    condition,\n    negated: state.negated ?? false,\n    subtype: state.subtype,\n    property: state.property,\n    propertyValue: state.propertyValue,\n  };\n}\n\n/**\n * Convert dimension bounds to container query condition (single string)\n * Container queries support \"not (condition)\", so no need to invert manually\n */\nfunction dimensionToContainerCondition(\n  dimension: string,\n  lowerBound?: { value: string; inclusive: boolean },\n  upperBound?: { value: string; inclusive: boolean },\n): string {\n  if (lowerBound && upperBound) {\n    const lowerOp = lowerBound.inclusive ? '<=' : '<';\n    const upperOp = upperBound.inclusive ? '<=' : '<';\n    return `(${lowerBound.value} ${lowerOp} ${dimension} ${upperOp} ${upperBound.value})`;\n  } else if (upperBound) {\n    const op = upperBound.inclusive ? '<=' : '<';\n    return `(${dimension} ${op} ${upperBound.value})`;\n  } else if (lowerBound) {\n    const op = lowerBound.inclusive ? '>=' : '>';\n    return `(${dimension} ${op} ${lowerBound.value})`;\n  }\n  return '(width)'; // Fallback\n}\n\n/**\n * Convert supports condition to parsed structure\n */\nfunction supportsToParsed(state: SupportsCondition): ParsedSupportsCondition {\n  return {\n    subtype: state.subtype,\n    condition: state.condition,\n    negated: state.negated ?? false,\n  };\n}\n\n/**\n * Convert root condition to parsed structure\n */\nfunction rootToParsed(state: RootCondition): ParsedRootCondition {\n  return {\n    selector: state.selector,\n    negated: state.negated ?? false,\n  };\n}\n\n/**\n * Convert parsed root conditions to CSS selector prefix (for final output)\n */\nexport function rootConditionsToCSS(\n  roots: ParsedRootCondition[],\n): string | undefined {\n  if (roots.length === 0) return undefined;\n\n  // Combine all root conditions into a single :root prefix\n  // e.g., :root[data-theme=\"dark\"]:not([data-mode=\"light\"])\n  let prefix = ':root';\n  for (const root of roots) {\n    if (root.negated) {\n      prefix += `:not(${root.selector})`;\n    } else {\n      prefix += root.selector;\n    }\n  }\n  return prefix;\n}\n\n/**\n * Convert own condition to parsed structures for sub-element\n */\nfunction ownToParsed(\n  state: OwnCondition,\n): (ParsedModifierCondition | ParsedPseudoCondition)[] {\n  const innerCSS = conditionToCSS(state.innerCondition);\n\n  if (innerCSS.isImpossible || innerCSS.variants.length === 0) {\n    return [];\n  }\n\n  // Collect all modifier/pseudo conditions from all variants\n  const allConditions: (ParsedModifierCondition | ParsedPseudoCondition)[] = [];\n  for (const variant of innerCSS.variants) {\n    for (const mod of variant.modifierConditions) {\n      // Apply outer negation\n      allConditions.push({\n        ...mod,\n        negated: state.negated ? !mod.negated : mod.negated,\n      });\n    }\n    for (const pseudo of variant.pseudoConditions) {\n      // Apply outer negation\n      allConditions.push({\n        ...pseudo,\n        negated: state.negated ? !pseudo.negated : pseudo.negated,\n      });\n    }\n  }\n\n  return allConditions;\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 a root condition\n */\nfunction getRootKey(root: ParsedRootCondition): string {\n  return root.negated ? `!${root.selector}` : root.selector;\n}\n\n/**\n * Deduplicate modifier conditions\n */\nfunction dedupeModifierConditions(\n  conditions: ParsedModifierCondition[],\n): ParsedModifierCondition[] {\n  const seen = new Set<string>();\n  const result: ParsedModifierCondition[] = [];\n  for (const c of conditions) {\n    const key = getModifierKey(c);\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(c);\n    }\n  }\n  return result;\n}\n\n/**\n * Deduplicate pseudo conditions\n */\nfunction dedupePseudoConditions(\n  conditions: ParsedPseudoCondition[],\n): ParsedPseudoCondition[] {\n  const seen = new Set<string>();\n  const result: ParsedPseudoCondition[] = [];\n  for (const c of conditions) {\n    const key = getPseudoKey(c);\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(c);\n    }\n  }\n  return result;\n}\n\n/**\n * Deduplicate root conditions\n */\nfunction dedupeRootConditions(\n  conditions: ParsedRootCondition[],\n): ParsedRootCondition[] {\n  const seen = new Set<string>();\n  const result: ParsedRootCondition[] = [];\n  for (const c of conditions) {\n    const key = getRootKey(c);\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(c);\n    }\n  }\n  return result;\n}\n\n/**\n * Deduplicate own conditions (modifiers or pseudos)\n */\nfunction dedupeOwnConditions(\n  conditions: (ParsedModifierCondition | ParsedPseudoCondition)[],\n): (ParsedModifierCondition | ParsedPseudoCondition)[] {\n  const seen = new Set<string>();\n  const result: (ParsedModifierCondition | ParsedPseudoCondition)[] = [];\n  for (const c of conditions) {\n    const key =\n      'attribute' in c\n        ? `mod:${getModifierKey(c)}`\n        : `pseudo:${getPseudoKey(c)}`;\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(c);\n    }\n  }\n  return result;\n}\n\n/**\n * Check for modifier contradiction: same attribute with opposite negation\n */\nfunction hasModifierContradiction(\n  conditions: ParsedModifierCondition[],\n): boolean {\n  const byKey = new Map<string, boolean>(); // base key -> isPositive\n\n  for (const mod of conditions) {\n    const baseKey = mod.value\n      ? `${mod.attribute}${mod.operator || '='}${mod.value}`\n      : mod.attribute;\n    const existing = byKey.get(baseKey);\n    if (existing !== undefined && existing !== !mod.negated) {\n      return true; // Same attribute with opposite negation\n    }\n    byKey.set(baseKey, !mod.negated);\n  }\n  return false;\n}\n\n/**\n * Check for pseudo contradiction: same pseudo with opposite negation\n */\nfunction hasPseudoContradiction(conditions: ParsedPseudoCondition[]): boolean {\n  const byKey = new Map<string, boolean>(); // pseudo -> isPositive\n\n  for (const pseudo of conditions) {\n    const existing = byKey.get(pseudo.pseudo);\n    if (existing !== undefined && existing !== !pseudo.negated) {\n      return true; // Same pseudo with opposite negation\n    }\n    byKey.set(pseudo.pseudo, !pseudo.negated);\n  }\n  return false;\n}\n\n/**\n * Check for root condition contradiction: same selector with opposite negation\n */\nfunction hasRootContradiction(conditions: ParsedRootCondition[]): boolean {\n  const byKey = new Map<string, boolean>(); // selector -> isPositive\n\n  for (const root of conditions) {\n    const existing = byKey.get(root.selector);\n    if (existing !== undefined && existing !== !root.negated) {\n      return true; // Same selector with opposite negation\n    }\n    byKey.set(root.selector, !root.negated);\n  }\n  return false;\n}\n\n/**\n * Check for own condition contradiction\n */\nfunction hasOwnConditionContradiction(\n  conditions: (ParsedModifierCondition | ParsedPseudoCondition)[],\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 * Merge two selector variants (AND operation)\n * Deduplicates conditions and checks for contradictions\n */\nfunction mergeVariants(\n  a: SelectorVariant,\n  b: SelectorVariant,\n): SelectorVariant | null {\n  // Merge media conditions and check for contradictions\n  const mergedMedia = dedupeMediaConditions([\n    ...a.mediaConditions,\n    ...b.mediaConditions,\n  ]);\n  if (hasMediaContradiction(mergedMedia)) {\n    return null; // Impossible variant\n  }\n\n  // Merge root conditions and check for contradictions\n  const mergedRoots = dedupeRootConditions([\n    ...a.rootConditions,\n    ...b.rootConditions,\n  ]);\n  if (hasRootContradiction(mergedRoots)) {\n    return null; // Impossible variant\n  }\n\n  // Merge modifier conditions and check for contradictions\n  const mergedModifiers = dedupeModifierConditions([\n    ...a.modifierConditions,\n    ...b.modifierConditions,\n  ]);\n  if (hasModifierContradiction(mergedModifiers)) {\n    return null; // Impossible variant\n  }\n\n  // Merge pseudo conditions and check for contradictions\n  const mergedPseudos = dedupePseudoConditions([\n    ...a.pseudoConditions,\n    ...b.pseudoConditions,\n  ]);\n  if (hasPseudoContradiction(mergedPseudos)) {\n    return null; // Impossible variant\n  }\n\n  // Merge own conditions and check for contradictions\n  const mergedOwn = dedupeOwnConditions([\n    ...a.ownConditions,\n    ...b.ownConditions,\n  ]);\n  if (hasOwnConditionContradiction(mergedOwn)) {\n    return null; // Impossible variant\n  }\n\n  // Merge container conditions and check for contradictions\n  const mergedContainers = dedupeContainerConditions([\n    ...a.containerConditions,\n    ...b.containerConditions,\n  ]);\n  if (hasContainerStyleContradiction(mergedContainers)) {\n    return null; // Impossible variant\n  }\n\n  // Merge supports conditions and check for contradictions\n  const mergedSupports = dedupeSupportsConditions([\n    ...a.supportsConditions,\n    ...b.supportsConditions,\n  ]);\n  if (hasSupportsContradiction(mergedSupports)) {\n    return null; // Impossible variant\n  }\n\n  return {\n    modifierConditions: mergedModifiers,\n    pseudoConditions: mergedPseudos,\n    ownConditions: mergedOwn,\n    mediaConditions: mergedMedia,\n    containerConditions: mergedContainers,\n    supportsConditions: mergedSupports,\n    rootConditions: mergedRoots,\n    startingStyle: a.startingStyle || b.startingStyle,\n  };\n}\n\n/**\n * Deduplicate media conditions by their key (subtype + condition + negated)\n */\nfunction dedupeMediaConditions(\n  conditions: ParsedMediaCondition[],\n): ParsedMediaCondition[] {\n  const seen = new Set<string>();\n  const result: ParsedMediaCondition[] = [];\n  for (const c of conditions) {\n    const key = `${c.subtype}|${c.condition}|${c.negated}`;\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(c);\n    }\n  }\n  return result;\n}\n\n/**\n * Deduplicate container conditions by their key (name + condition + negated)\n */\nfunction dedupeContainerConditions(\n  conditions: ParsedContainerCondition[],\n): ParsedContainerCondition[] {\n  const seen = new Set<string>();\n  const result: ParsedContainerCondition[] = [];\n  for (const c of conditions) {\n    const key = `${c.name ?? ''}|${c.condition}|${c.negated}`;\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(c);\n    }\n  }\n  return result;\n}\n\n/**\n * Deduplicate supports conditions by their key (subtype + condition + negated)\n */\nfunction dedupeSupportsConditions(\n  conditions: ParsedSupportsCondition[],\n): ParsedSupportsCondition[] {\n  const seen = new Set<string>();\n  const result: ParsedSupportsCondition[] = [];\n  for (const c of conditions) {\n    const key = `${c.subtype}|${c.condition}|${c.negated}`;\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(c);\n    }\n  }\n  return result;\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\n/**\n * Get a unique key for a variant (for deduplication)\n */\nfunction getVariantKey(v: SelectorVariant): string {\n  const modifierKey = v.modifierConditions.map(getModifierKey).sort().join('|');\n  const pseudoKey = v.pseudoConditions.map(getPseudoKey).sort().join('|');\n  const ownKey = v.ownConditions\n    .map((c) =>\n      'attribute' in c\n        ? `mod:${getModifierKey(c)}`\n        : `pseudo:${getPseudoKey(c)}`,\n    )\n    .sort()\n    .join('|');\n  const containerKey = v.containerConditions\n    .map((c) => `${c.name ?? ''}:${c.negated ? '!' : ''}${c.condition}`)\n    .sort()\n    .join('|');\n  const mediaKey = v.mediaConditions\n    .map((c) => `${c.subtype}:${c.negated ? '!' : ''}${c.condition}`)\n    .sort()\n    .join('|');\n  const supportsKey = v.supportsConditions\n    .map((c) => `${c.subtype}:${c.negated ? '!' : ''}${c.condition}`)\n    .sort()\n    .join('|');\n  const rootKey = v.rootConditions.map(getRootKey).sort().join('|');\n  return [\n    modifierKey,\n    pseudoKey,\n    ownKey,\n    mediaKey,\n    containerKey,\n    supportsKey,\n    rootKey,\n    v.startingStyle ? '1' : '0',\n  ].join('###');\n}\n\n/**\n * Check if variant A is a superset of variant B (A is more restrictive)\n *\n * If A has all of B's conditions plus more, then A is redundant\n * because B already covers the same cases (and more).\n *\n * Example:\n *   A: :not([size=large]):not([size=medium]):not([size=small])\n *   B: :not([size=large])\n *   A is a superset of B, so A is redundant when B exists.\n */\nfunction isVariantSuperset(a: SelectorVariant, b: SelectorVariant): boolean {\n  // Must have same context\n  if (a.startingStyle !== b.startingStyle) return false;\n\n  // Check if a.rootConditions is superset of b.rootConditions\n  if (!isRootConditionsSuperset(a.rootConditions, b.rootConditions))\n    return false;\n\n  // Check if a.mediaConditions is superset of b.mediaConditions\n  if (!isMediaConditionsSuperset(a.mediaConditions, b.mediaConditions))\n    return false;\n\n  // Check if a.containerConditions is superset of b.containerConditions\n  if (\n    !isContainerConditionsSuperset(a.containerConditions, b.containerConditions)\n  )\n    return false;\n\n  // Check if a.supportsConditions is superset of b.supportsConditions\n  if (!isSupportsConditionsSuperset(a.supportsConditions, b.supportsConditions))\n    return false;\n\n  // Check if a.modifierConditions is superset of b.modifierConditions\n  if (!isModifierConditionsSuperset(a.modifierConditions, b.modifierConditions))\n    return false;\n\n  // Check if a.pseudoConditions is superset of b.pseudoConditions\n  if (!isPseudoConditionsSuperset(a.pseudoConditions, b.pseudoConditions))\n    return false;\n\n  // Check if a.ownConditions is superset of b.ownConditions\n  if (!isOwnConditionsSuperset(a.ownConditions, b.ownConditions)) return false;\n\n  // A is a superset if it has all of B's items (possibly more)\n  // and at least one category has strictly more items\n  const aTotal =\n    a.mediaConditions.length +\n    a.containerConditions.length +\n    a.supportsConditions.length +\n    a.modifierConditions.length +\n    a.pseudoConditions.length +\n    a.rootConditions.length +\n    a.ownConditions.length;\n  const bTotal =\n    b.mediaConditions.length +\n    b.containerConditions.length +\n    b.supportsConditions.length +\n    b.modifierConditions.length +\n    b.pseudoConditions.length +\n    b.rootConditions.length +\n    b.ownConditions.length;\n\n  return aTotal > bTotal;\n}\n\n/**\n * Check if media conditions A is a superset of B\n */\nfunction isMediaConditionsSuperset(\n  a: ParsedMediaCondition[],\n  b: ParsedMediaCondition[],\n): boolean {\n  const aKeys = new Set(\n    a.map((c) => `${c.subtype}|${c.condition}|${c.negated}`),\n  );\n  for (const c of b) {\n    const key = `${c.subtype}|${c.condition}|${c.negated}`;\n    if (!aKeys.has(key)) return false;\n  }\n  return true;\n}\n\n/**\n * Check if container conditions A is a superset of B\n */\nfunction isContainerConditionsSuperset(\n  a: ParsedContainerCondition[],\n  b: ParsedContainerCondition[],\n): boolean {\n  const aKeys = new Set(\n    a.map((c) => `${c.name ?? ''}|${c.condition}|${c.negated}`),\n  );\n  for (const c of b) {\n    const key = `${c.name ?? ''}|${c.condition}|${c.negated}`;\n    if (!aKeys.has(key)) return false;\n  }\n  return true;\n}\n\n/**\n * Check if supports conditions A is a superset of B\n */\nfunction isSupportsConditionsSuperset(\n  a: ParsedSupportsCondition[],\n  b: ParsedSupportsCondition[],\n): boolean {\n  const aKeys = new Set(\n    a.map((c) => `${c.subtype}|${c.condition}|${c.negated}`),\n  );\n  for (const c of b) {\n    const key = `${c.subtype}|${c.condition}|${c.negated}`;\n    if (!aKeys.has(key)) return false;\n  }\n  return true;\n}\n\n/**\n * Check if modifier conditions A is a superset of B\n */\nfunction isModifierConditionsSuperset(\n  a: ParsedModifierCondition[],\n  b: ParsedModifierCondition[],\n): boolean {\n  const aKeys = new Set(a.map(getModifierKey));\n  for (const c of b) {\n    if (!aKeys.has(getModifierKey(c))) return false;\n  }\n  return true;\n}\n\n/**\n * Check if pseudo conditions A is a superset of B\n */\nfunction isPseudoConditionsSuperset(\n  a: ParsedPseudoCondition[],\n  b: ParsedPseudoCondition[],\n): boolean {\n  const aKeys = new Set(a.map(getPseudoKey));\n  for (const c of b) {\n    if (!aKeys.has(getPseudoKey(c))) return false;\n  }\n  return true;\n}\n\n/**\n * Check if root conditions A is a superset of B\n */\nfunction isRootConditionsSuperset(\n  a: ParsedRootCondition[],\n  b: ParsedRootCondition[],\n): boolean {\n  const aKeys = new Set(a.map(getRootKey));\n  for (const c of b) {\n    if (!aKeys.has(getRootKey(c))) return false;\n  }\n  return true;\n}\n\n/**\n * Check if own conditions A is a superset of B\n */\nfunction isOwnConditionsSuperset(\n  a: (ParsedModifierCondition | ParsedPseudoCondition)[],\n  b: (ParsedModifierCondition | ParsedPseudoCondition)[],\n): boolean {\n  const aKeys = new Set(\n    a.map((c) =>\n      'attribute' in c\n        ? `mod:${getModifierKey(c)}`\n        : `pseudo:${getPseudoKey(c)}`,\n    ),\n  );\n  for (const c of b) {\n    const key =\n      'attribute' in c\n        ? `mod:${getModifierKey(c)}`\n        : `pseudo:${getPseudoKey(c)}`;\n    if (!aKeys.has(key)) return false;\n  }\n  return true;\n}\n\n/**\n * Deduplicate variants\n *\n * Removes:\n * 1. Exact duplicates (same key)\n * 2. Superset variants (more restrictive selectors that are redundant)\n */\nfunction dedupeVariants(variants: SelectorVariant[]): SelectorVariant[] {\n  // First pass: exact deduplication\n  const seen = new Set<string>();\n  const result: SelectorVariant[] = [];\n\n  for (const v of variants) {\n    const key = getVariantKey(v);\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(v);\n    }\n  }\n\n  // Second pass: remove supersets (more restrictive variants)\n  // Sort by total condition count (fewer conditions = less restrictive = keep)\n  result.sort((a, b) => {\n    const aCount =\n      a.modifierConditions.length +\n      a.pseudoConditions.length +\n      a.ownConditions.length +\n      a.mediaConditions.length +\n      a.containerConditions.length +\n      a.supportsConditions.length +\n      a.rootConditions.length;\n    const bCount =\n      b.modifierConditions.length +\n      b.pseudoConditions.length +\n      b.ownConditions.length +\n      b.mediaConditions.length +\n      b.containerConditions.length +\n      b.supportsConditions.length +\n      b.rootConditions.length;\n    return aCount - bCount;\n  });\n\n  // Remove variants that are supersets of earlier (less restrictive) variants\n  const filtered: SelectorVariant[] = [];\n  for (const candidate of result) {\n    let isRedundant = false;\n    for (const kept of filtered) {\n      if (isVariantSuperset(candidate, kept)) {\n        isRedundant = true;\n        break;\n      }\n    }\n    if (!isRedundant) {\n      filtered.push(candidate);\n    }\n  }\n\n  return filtered;\n}\n\n/**\n * Combine AND conditions into CSS\n *\n * AND of conditions means cartesian product of variants:\n * (A1 | A2) & (B1 | B2) = A1&B1 | A1&B2 | A2&B1 | A2&B2\n *\n * Variants that result in contradictions (e.g., conflicting media rules)\n * are filtered out.\n */\nfunction andToCSS(children: ConditionNode[]): CSSComponents {\n  // Start with a single empty variant\n  let currentVariants: SelectorVariant[] = [emptyVariant()];\n\n  for (const child of children) {\n    const childCSS = conditionToCSSInner(child);\n\n    if (childCSS.isImpossible || childCSS.variants.length === 0) {\n      return { variants: [], isImpossible: true };\n    }\n\n    // Cartesian product: each current variant × each child variant\n    const newVariants: SelectorVariant[] = [];\n    for (const current of currentVariants) {\n      for (const childVariant of childCSS.variants) {\n        const merged = mergeVariants(current, childVariant);\n        // Skip impossible variants (contradictions detected during merge)\n        if (merged !== null) {\n          newVariants.push(merged);\n        }\n      }\n    }\n\n    if (newVariants.length === 0) {\n      return { variants: [], isImpossible: true };\n    }\n\n    // Deduplicate after each step to prevent exponential blowup\n    currentVariants = dedupeVariants(newVariants);\n  }\n\n  return {\n    variants: currentVariants,\n    isImpossible: false,\n  };\n}\n\n/**\n * Combine OR conditions into CSS\n *\n * OR in CSS means multiple selector variants (DNF).\n * Each variant becomes a separate selector in the comma-separated list,\n * or multiple CSS rules if they have different at-rules.\n *\n * Note: OR exclusivity is handled at the pipeline level (expandOrConditions),\n * so here we just collect all variants. Any remaining ORs in the condition\n * tree (e.g., from De Morgan expansion) are handled as simple alternatives.\n */\nfunction orToCSS(children: ConditionNode[]): CSSComponents {\n  const allVariants: SelectorVariant[] = [];\n\n  for (const child of children) {\n    const childCSS = conditionToCSSInner(child);\n    if (childCSS.isImpossible) continue;\n\n    allVariants.push(...childCSS.variants);\n  }\n\n  if (allVariants.length === 0) {\n    return { variants: [], isImpossible: true };\n  }\n\n  // Deduplicate variants\n  return {\n    variants: dedupeVariants(allVariants),\n    isImpossible: false,\n  };\n}\n\n// ============================================================================\n// Utility Functions\n// ============================================================================\n\n/**\n * Get a cache key for a condition\n */\nfunction getConditionKey(node: ConditionNode): string {\n  if (node.kind === 'true') return 'TRUE';\n  if (node.kind === 'false') return 'FALSE';\n  if (node.kind === 'state') return node.uniqueId;\n  if (node.kind === 'compound') {\n    const childKeys = node.children.map(getConditionKey).sort();\n    return `${node.operator}(${childKeys.join(',')})`;\n  }\n  return 'UNKNOWN';\n}\n\n/**\n * Build a complete CSS selector from a single variant\n */\nfunction buildCSSSelectorFromVariant(\n  className: string,\n  variant: SelectorVariant,\n  selectorSuffix = '',\n): string {\n  // Start with base class (doubled for specificity)\n  let selector = `.${className}.${className}`;\n\n  // Add modifier selectors\n  for (const mod of variant.modifierConditions) {\n    selector += modifierToCSS(mod);\n  }\n\n  // Add pseudo selectors\n  for (const pseudo of variant.pseudoConditions) {\n    selector += pseudoToCSS(pseudo);\n  }\n\n  // Add selector suffix (e.g., ' [data-element=\"Label\"]')\n  selector += selectorSuffix;\n\n  // Add own selectors (after sub-element)\n  for (const own of variant.ownConditions) {\n    if ('attribute' in own) {\n      selector += modifierToCSS(own);\n    } else {\n      selector += pseudoToCSS(own);\n    }\n  }\n\n  // Add root prefix if present\n  const rootPrefix = rootConditionsToCSS(variant.rootConditions);\n  if (rootPrefix) {\n    selector = `${rootPrefix} ${selector}`;\n  }\n\n  return selector;\n}\n\n/**\n * Build at-rules array from a variant\n */\nexport function buildAtRulesFromVariant(variant: SelectorVariant): string[] {\n  const atRules: string[] = [];\n\n  // Add media rules - combine all conditions with \"and\"\n  if (variant.mediaConditions.length > 0) {\n    const conditionParts = variant.mediaConditions.map((c) => {\n      if (c.subtype === 'type') {\n        // Media type: print, screen, etc.\n        return c.negated ? `not ${c.condition}` : c.condition;\n      } else {\n        // Feature or dimension: use not (condition) syntax for negation\n        // MQ Level 4 requires parentheses around the condition for negation\n        return c.negated ? `(not ${c.condition})` : c.condition;\n      }\n    });\n    atRules.push(`@media ${conditionParts.join(' and ')}`);\n  }\n\n  // Add container rules - group by container name and combine with \"and\"\n  if (variant.containerConditions.length > 0) {\n    // Group conditions by container name (undefined = unnamed/nearest)\n    const byName = new Map<string | undefined, ParsedContainerCondition[]>();\n    for (const cond of variant.containerConditions) {\n      const group = byName.get(cond.name) || [];\n      group.push(cond);\n      byName.set(cond.name, group);\n    }\n\n    // Build one @container rule per container name\n    for (const [name, conditions] of byName) {\n      // CSS Container Query syntax requires parentheses around negated conditions:\n      // @container (not style(--x)) and style(--y) - NOT @container not style(--x) and style(--y)\n      const conditionParts = conditions.map((c) =>\n        c.negated ? `(not ${c.condition})` : c.condition,\n      );\n      const namePrefix = name ? `${name} ` : '';\n      atRules.push(`@container ${namePrefix}${conditionParts.join(' and ')}`);\n    }\n  }\n\n  // Add supports rules - combine all conditions with \"and\"\n  if (variant.supportsConditions.length > 0) {\n    const conditionParts = variant.supportsConditions.map((c) => {\n      // Build the condition based on subtype\n      // feature: (display: grid) or (not (display: grid))\n      // selector: selector(:has(*)) or (not selector(:has(*)))\n      if (c.subtype === 'selector') {\n        const selectorCond = `selector(${c.condition})`;\n        return c.negated ? `(not ${selectorCond})` : selectorCond;\n      } else {\n        const featureCond = `(${c.condition})`;\n        return c.negated ? `(not ${featureCond})` : featureCond;\n      }\n    });\n    atRules.push(`@supports ${conditionParts.join(' and ')}`);\n  }\n\n  // Add starting-style\n  if (variant.startingStyle) {\n    atRules.push('@starting-style');\n  }\n\n  return atRules;\n}\n\n/**\n * Get a string key for a variant's at-rules (for grouping)\n */\nfunction getAtRulesKey(variant: SelectorVariant): string {\n  const atRules = buildAtRulesFromVariant(variant);\n  return atRules.sort().join('|||');\n}\n\n/**\n * Materialize a computed rule into final CSS format\n *\n * Returns an array of CSSRules because OR conditions may require multiple rules\n * (when different branches have different at-rules)\n */\nfunction _materializeRule(\n  condition: ConditionNode,\n  declarations: Record<string, string>,\n  selectorSuffix: string,\n  className: string,\n): CSSRule[] {\n  const components = conditionToCSS(condition);\n\n  if (components.isImpossible || components.variants.length === 0) {\n    return [];\n  }\n\n  const declarationsStr = Object.entries(declarations)\n    .map(([prop, value]) => `${prop}: ${value};`)\n    .join(' ');\n\n  // Group variants by their at-rules (variants with same at-rules can be combined with commas)\n  const byAtRules = new Map<string, SelectorVariant[]>();\n  for (const variant of components.variants) {\n    const key = getAtRulesKey(variant);\n    const group = byAtRules.get(key) || [];\n    group.push(variant);\n    byAtRules.set(key, group);\n  }\n\n  // Generate one CSSRule per at-rules group\n  const rules: CSSRule[] = [];\n  for (const [, variants] of byAtRules) {\n    // All variants in this group have the same at-rules, so combine selectors with commas\n    const selectors = variants.map((v) =>\n      buildCSSSelectorFromVariant(className, v, selectorSuffix),\n    );\n    const selector = selectors.join(', ');\n    const atRules = buildAtRulesFromVariant(variants[0]);\n\n    const rule: CSSRule = {\n      selector,\n      declarations: declarationsStr,\n    };\n\n    if (atRules.length > 0) {\n      rule.atRules = atRules;\n    }\n\n    const rootPrefix = rootConditionsToCSS(variants[0].rootConditions);\n    if (rootPrefix) {\n      rule.rootPrefix = rootPrefix;\n    }\n\n    rules.push(rule);\n  }\n\n  return rules;\n}\n"],"mappings":"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"}