@tenphi/tasty 2.5.0 → 2.6.1

package/dist/{config-JokB1Lc8.js → config-D0ZQMdY8.js}

@@ -3321,10 +3321,13 @@ function resolveFontFamily(font, fontFamily) {
 /**
 * Handles typography preset and individual font properties.
 *
-* Preset syntax uses `/` to separate name from modifier:
+* Preset syntax uses `/` to separate the name from one or more
+* space-separated modifiers:
 * - `preset="h1"` — name only
 * - `preset="h2 / strong"` — name + modifier
+* - `preset="h2 / strong italic"` — name + multiple modifiers
 * - `preset="bold"` — modifier-only shorthand (name defaults to `inherit`)
+* - `preset="bold italic"` — modifier-only shorthand with multiple modifiers
 *
 * When `preset` is defined, it sets up CSS custom properties for typography.
 * Individual font props can be used with or without `preset`:
@@ -3344,14 +3347,17 @@ function presetStyle({ preset, fontSize, lineHeight, textTransform, letterSpacin
 		const { parts } = parseStyle(preset === true ? "" : String(preset)).groups[0] ?? { parts: [] };
 		const namePart = parts[0];
 		const modPart = parts[1];
+		const nameTokens = namePart?.all ?? [];
+		const isModOnly = nameTokens.length > 0 && nameTokens.every((t) => PRESET_MODIFIERS.has(t));
 		const nameToken = namePart?.mods[0] ?? namePart?.values[0] ?? "";
-		const isModOnly = PRESET_MODIFIERS.has(nameToken);
 		const name = isModOnly ? "inherit" : nameToken || "inherit";
-		const modifier = isModOnly ? nameToken : modPart?.mods[0] ?? "";
-		const isStrong = modifier === "strong" || modifier === "bold";
-		const isItalic = modifier === "italic";
-		const isIcon = modifier === "icon";
-		const isTight = modifier === "tight";
+		const modTokens = isModOnly ? nameTokens : modPart?.all ?? [];
+		const activeMods = /* @__PURE__ */ new Set();
+		for (const tok of modTokens) if (PRESET_MODIFIERS.has(tok)) activeMods.add(tok);
+		const isStrong = activeMods.has("strong") || activeMods.has("bold");
+		const isItalic = activeMods.has("italic");
+		const isIcon = activeMods.has("icon");
+		const isTight = activeMods.has("tight");
 		if (fontSize == null) setCSSValue(styles, "font-size", name, { cssOnly: true });
 		if (lineHeight == null) setCSSValue(styles, "line-height", name, { cssOnly: true });
 		if (letterSpacing == null) setCSSValue(styles, "letter-spacing", name, { cssOnly: true });
@@ -6889,1063 +6895,679 @@ function pruneContradictedOrBranches(terms) {
 	return flattened;
 }
 //#endregion
-//#region src/pipeline/exclusive.ts
+//#region src/pipeline/materialize-contradictions.ts
 /**
-* Build exclusive conditions for a list of parsed style entries.
-*
-* The entries should be ordered by priority (highest priority first).
-*
-* For each entry, we compute:
-*   exclusiveCondition = condition & !prior[0] & !prior[1] & ...
-*
-* This ensures exactly one condition matches at any time.
-*
-* Example:
-*   Input (ordered highest to lowest priority):
-*     A: value1 (priority 2)
-*     B: value2 (priority 1)
-*     C: value3 (priority 0)
-*
-*   Output:
-*     A: A
-*     B: B & !A
-*     C: C & !A & !B
-*
-* @param entries Parsed style entries ordered by priority (highest first)
-* @returns Entries with exclusive conditions, filtered to remove impossible ones
+* Generic deduplication by a key extraction function.
+* Preserves insertion order, keeping the first occurrence of each key.
 */
-function buildExclusiveConditions(entries) {
+function dedupeByKey(items, getKey) {
+	const seen = /* @__PURE__ */ new Set();
 	const result = [];
-	const priorConditions = [];
-	for (const entry of entries) {
-		let exclusive = entry.condition;
-		for (const prior of priorConditions) if (prior.kind !== "true") exclusive = and(exclusive, not(prior));
-		const simplified = simplifyCondition(exclusive);
-		if (simplified.kind === "false") continue;
-		result.push({
-			...entry,
-			exclusiveCondition: simplified
-		});
-		if (entry.condition.kind !== "true") priorConditions.push(entry.condition);
+	for (const item of items) {
+		const key = getKey(item);
+		if (!seen.has(key)) {
+			seen.add(key);
+			result.push(item);
+		}
 	}
 	return result;
 }
-/**
-* Parse style entries from a value mapping object.
-*
-* @param styleKey The style key (e.g., 'padding')
-* @param valueMap The value mapping { '': '2x', 'compact': '1x', '@media(w < 768px)': '0.5x' }
-* @param parseCondition Function to parse state keys into conditions
-* @returns Parsed entries ordered by priority (highest first)
-*/
-function parseStyleEntries(styleKey, valueMap, parseCondition) {
-	const entries = [];
-	Object.keys(valueMap).forEach((stateKey, index) => {
-		const value = valueMap[stateKey];
-		const condition = stateKey === "" ? trueCondition() : parseCondition(stateKey);
-		entries.push({
-			styleKey,
-			stateKey,
-			value,
-			condition,
-			priority: index
-		});
-	});
-	entries.reverse();
-	return entries;
+function dedupeMediaConditions(conditions) {
+	return dedupeByKey(conditions, (c) => `${c.subtype}|${c.condition}|${c.negated}`);
 }
-/**
-* Merge parsed entries that share the same value.
-*
-* When multiple **non-default** state keys map to the same value, their
-* conditions can be combined with OR and treated as a single entry.
-* This must happen **before** exclusive expansion and OR branch splitting
-* to avoid combinatorial explosion and duplicate CSS output.
-*
-* Default (TRUE) entries are **never** merged with non-default entries.
-* Merging `TRUE | X` collapses to `TRUE`, destroying the non-default
-* condition's participation in exclusive building. That causes
-* intermediate-priority states to lose their `:not(X)` negation,
-* breaking mutual exclusivity when X and an intermediate state are
-* both active. Stage 6 `mergeByValue` handles combining rules with
-* identical CSS output after exclusive conditions are correctly built.
-*
-* Example: `{ '@dark': 'red', '@dark & @hc': 'red' }` merges into a
-* single entry with condition `@dark | (@dark & @hc)` = `@dark`.
-*
-* Entries are ordered highest-priority-first. The merged entry keeps the
-* highest priority of the group.
-*/
-function mergeEntriesByValue(entries) {
-	if (entries.length <= 1) return entries;
-	const groups = /* @__PURE__ */ new Map();
-	for (const entry of entries) {
-		const valueKey = serializeValue(entry.value);
-		const group = groups.get(valueKey);
-		if (group) {
-			group.entries.push(entry);
-			group.maxPriority = Math.max(group.maxPriority, entry.priority);
-		} else groups.set(valueKey, {
-			entries: [entry],
-			maxPriority: entry.priority
-		});
-	}
-	if (groups.size === entries.length) return entries;
-	const merged = [];
-	for (const [, group] of groups) {
-		if (group.entries.length === 1) {
-			merged.push(group.entries[0]);
-			continue;
-		}
-		const defaultEntries = group.entries.filter((e) => e.condition.kind === "true");
-		const nonDefaultEntries = group.entries.filter((e) => e.condition.kind !== "true");
-		for (const entry of defaultEntries) merged.push(entry);
-		if (nonDefaultEntries.length === 1) merged.push(nonDefaultEntries[0]);
-		else if (nonDefaultEntries.length >= 2) {
-			const combinedCondition = simplifyCondition(or(...nonDefaultEntries.map((e) => e.condition)));
-			const combinedStateKey = nonDefaultEntries.map((e) => e.stateKey).join(" | ");
-			merged.push({
-				styleKey: nonDefaultEntries[0].styleKey,
-				stateKey: combinedStateKey,
-				value: nonDefaultEntries[0].value,
-				condition: combinedCondition,
-				priority: group.maxPriority
-			});
-		}
-	}
-	merged.sort((a, b) => b.priority - a.priority);
-	return merged;
+function dedupeContainerConditions(conditions) {
+	return dedupeByKey(conditions, (c) => `${c.name ?? ""}|${c.condition}|${c.negated}`);
 }
-function serializeValue(value) {
-	if (value === null || value === void 0) return "null";
-	if (typeof value === "string" || typeof value === "number") return String(value);
-	return JSON.stringify(value);
+function dedupeSupportsConditions(conditions) {
+	return dedupeByKey(conditions, (c) => `${c.subtype}|${c.condition}|${c.negated}`);
 }
 /**
-* Eliminate redundant state dimensions from a value map.
-*
-* When a value map contains compound AND state keys (e.g. `@dark & @hc`),
-* checks whether any state atom is a "don't-care" variable — i.e. the
-* value is the same whether that atom is present or absent. Redundant
-* atoms are removed from all keys and duplicate entries are collapsed.
-*
-* This runs **before** condition parsing so that downstream stages
-* (`mergeEntriesByValue`, `buildExclusiveConditions`, materialization)
-* never see the irrelevant dimension, producing simpler, smaller CSS.
-*
-* Only pure top-level AND combinations are eligible. Keys that contain
-* `|`, `^`, or `,` at the top level are treated as opaque single atoms.
-*
-* @example
-*   { '': A, '@dark': B, '@hc': A, '@dark & @hc': B }
-*   // @hc is redundant → { '': A, '@dark': B }
+* Check if supports conditions contain contradictions
+* e.g., @supports(display: grid) AND NOT @supports(display: grid)
 */
-function extractCompoundStates(valueMap) {
-	const keys = Object.keys(valueMap);
-	if (keys.length < 3 || !keys.some((k) => k.includes("&"))) return valueMap;
-	const entries = keys.map((key) => {
-		return {
-			atoms: splitTopLevelAnd(key) ?? [key],
-			value: valueMap[key]
-		};
-	});
-	const allAtoms = /* @__PURE__ */ new Set();
-	for (const e of entries) for (const a of e.atoms) allAtoms.add(a);
-	const redundant = /* @__PURE__ */ new Set();
-	for (const atom of allAtoms) if (isAtomRedundant(entries, atom)) redundant.add(atom);
-	if (redundant.size === 0) return valueMap;
-	const newMap = {};
-	for (const e of entries) {
-		const newKey = e.atoms.filter((a) => !redundant.has(a)).join(" & ");
-		if (!(newKey in newMap)) newMap[newKey] = e.value;
+function hasSupportsContradiction(conditions) {
+	const conditionMap = /* @__PURE__ */ new Map();
+	for (const cond of conditions) {
+		const key = `${cond.subtype}|${cond.condition}`;
+		const existing = conditionMap.get(key);
+		if (existing !== void 0 && existing !== !cond.negated) return true;
+		conditionMap.set(key, !cond.negated);
 	}
-	return newMap;
+	return false;
 }
 /**
-* Split a state key by top-level `&` operators.
+* Check if a set of media conditions contains contradictions
+* e.g., (prefers-color-scheme: light) AND NOT (prefers-color-scheme: light)
+* or (width >= 900px) AND (width < 600px)
 *
-* Returns `null` if the key contains `|`, `^`, or `,` at the top level
-* (making it ineligible for atom-level extraction).
-* Returns `[]` for the empty string (default key).
+* Uses parsed media conditions for efficient analysis without regex parsing.
 */
-function splitTopLevelAnd(key) {
-	if (key === "") return [];
-	const parts = [];
-	let depth = 0;
-	let current = "";
-	for (const ch of key) {
-		if (ch === "(" || ch === "[") depth++;
-		else if (ch === ")" || ch === "]") depth--;
-		if (depth === 0) {
-			if (ch === "&") {
-				const trimmed = current.trim();
-				if (trimmed) parts.push(trimmed);
-				current = "";
-				continue;
+function hasMediaContradiction(conditions) {
+	const featureConditions = /* @__PURE__ */ new Map();
+	const typeConditions = /* @__PURE__ */ new Map();
+	const dimensionConditions = /* @__PURE__ */ new Map();
+	const dimensionsByDim = /* @__PURE__ */ new Map();
+	for (const cond of conditions) if (cond.subtype === "type") {
+		const key = cond.mediaType || "all";
+		const existing = typeConditions.get(key);
+		if (existing !== void 0 && existing !== !cond.negated) return true;
+		typeConditions.set(key, !cond.negated);
+	} else if (cond.subtype === "feature") {
+		const key = cond.condition;
+		const existing = featureConditions.get(key);
+		if (existing !== void 0 && existing !== !cond.negated) return true;
+		featureConditions.set(key, !cond.negated);
+	} else if (cond.subtype === "dimension") {
+		const condKey = cond.condition;
+		const existing = dimensionConditions.get(condKey);
+		if (existing !== void 0 && existing !== !cond.negated) return true;
+		dimensionConditions.set(condKey, !cond.negated);
+		if (!cond.negated) {
+			const dim = cond.dimension || "width";
+			let bounds = dimensionsByDim.get(dim);
+			if (!bounds) {
+				bounds = {
+					lowerBound: null,
+					upperBound: null
+				};
+				dimensionsByDim.set(dim, bounds);
 			}
-			if (ch === "|" || ch === "^" || ch === ",") return null;
+			if (cond.lowerBound?.valueNumeric != null) {
+				const value = cond.lowerBound.valueNumeric;
+				if (bounds.lowerBound === null || value > bounds.lowerBound) bounds.lowerBound = value;
+			}
+			if (cond.upperBound?.valueNumeric != null) {
+				const value = cond.upperBound.valueNumeric;
+				if (bounds.upperBound === null || value < bounds.upperBound) bounds.upperBound = value;
+			}
+			if (bounds.lowerBound !== null && bounds.upperBound !== null && bounds.lowerBound >= bounds.upperBound) return true;
 		}
-		current += ch;
 	}
-	const trimmed = current.trim();
-	if (trimmed) parts.push(trimmed);
-	return parts;
+	return false;
 }
 /**
-* An atom is redundant when every entry that contains it has a matching
-* partner (same remaining atoms, atom absent) with the same value.
-*/
-function isAtomRedundant(entries, atom) {
-	const withAtom = entries.filter((e) => e.atoms.includes(atom));
-	if (withAtom.length === 0) return false;
-	for (const wa of withAtom) {
-		const remaining = wa.atoms.filter((a) => a !== atom);
-		const pair = entries.find((e) => !e.atoms.includes(atom) && e.atoms.length === remaining.length && remaining.every((r) => e.atoms.includes(r)));
-		if (!pair) return false;
-		if (serializeValue(wa.value) !== serializeValue(pair.value)) return false;
+* Check if container conditions contain contradictions in style queries
+* e.g., style(--variant: danger) and style(--variant: success) together
+* Same property with different values = always false
+*
+* Uses parsed container conditions for efficient analysis without regex parsing.
+*/
+function hasContainerStyleContradiction(conditions) {
+	const styleQueries = /* @__PURE__ */ new Map();
+	for (const cond of conditions) {
+		if (cond.subtype !== "style" || !cond.property) continue;
+		const property = cond.property;
+		const value = cond.propertyValue;
+		if (!styleQueries.has(property)) styleQueries.set(property, {
+			hasExistence: false,
+			values: /* @__PURE__ */ new Set(),
+			hasNegatedExistence: false
+		});
+		const entry = styleQueries.get(property);
+		if (cond.negated) {
+			if (value === void 0) entry.hasNegatedExistence = true;
+		} else if (value === void 0) entry.hasExistence = true;
+		else entry.values.add(value);
 	}
-	return true;
+	for (const [, entry] of styleQueries) {
+		if (entry.hasExistence && entry.hasNegatedExistence) return true;
+		if (entry.values.size > 1) return true;
+		if (entry.hasNegatedExistence && entry.values.size > 0) return true;
+	}
+	return false;
 }
+//#endregion
+//#region src/pipeline/materialize.ts
 /**
-* Check if a value is a style value mapping (object with state keys)
+* CSS Materialization
+*
+* Converts condition trees into CSS selectors and at-rules.
+* This is the final stage that produces actual CSS output.
 */
-function isValueMapping(value) {
-	return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
-}
+const conditionCache = new Lru(3e3);
 /**
-* Expand OR conditions in parsed entries into multiple exclusive entries.
-*
-* For an entry with condition `A | B | C`, this creates 3 entries:
-*   - condition: A
-*   - condition: B & !A
-*   - condition: C & !A & !B
-*
-* This ensures OR branches are mutually exclusive BEFORE the main
-* exclusive condition building pass.
-*
-* @param entries Parsed entries (may contain OR conditions)
-* @returns Expanded entries with OR branches made exclusive
+* Convert a condition tree to CSS components
 */
-function expandOrConditions(entries) {
-	const result = [];
-	for (const entry of entries) {
-		const expanded = expandSingleEntry(entry);
-		result.push(...expanded);
-	}
+function conditionToCSS(node) {
+	const key = getConditionUniqueId(node);
+	const cached = conditionCache.get(key);
+	if (cached) return cached;
+	const result = conditionToCSSInner(node);
+	conditionCache.set(key, result);
 	return result;
 }
+function emptyVariant() {
+	return {
+		modifierConditions: [],
+		pseudoConditions: [],
+		selectorGroups: [],
+		ownGroups: [],
+		mediaConditions: [],
+		containerConditions: [],
+		supportsConditions: [],
+		rootGroups: [],
+		parentGroups: [],
+		startingStyle: false
+	};
+}
+function conditionToCSSInner(node) {
+	if (node.kind === "true") return {
+		variants: [emptyVariant()],
+		isImpossible: false
+	};
+	if (node.kind === "false") return {
+		variants: [],
+		isImpossible: true
+	};
+	if (node.kind === "state") return stateToCSS(node);
+	if (node.kind === "compound") if (node.operator === "AND") return andToCSS(node.children);
+	else return orToCSS(node.children);
+	return {
+		variants: [emptyVariant()],
+		isImpossible: false
+	};
+}
 /**
-* Expand a single entry's OR condition into multiple exclusive entries.
-*
-* Note: branches are NOT sorted by at-rule context here (unlike the
-* `expandExclusiveOrs` pass below). User-authored ORs in state keys aren't
-* the product of De Morgan negation, so each branch is expected to render
-* independently in its own scope and at-rule sort isn't load-bearing.
-* The post-build pass needs the sort because it has to preserve at-rule
-* wrapping across branches that came from negating a compound at-rule.
+* Convert a state condition to CSS
 */
-function expandSingleEntry(entry) {
-	const orBranches = collectOrBranches(entry.condition);
-	if (orBranches.length <= 1) return [entry];
-	const result = [];
-	const priorBranches = [];
-	for (let i = 0; i < orBranches.length; i++) {
-		const branch = orBranches[i];
-		let exclusiveBranch = branch;
-		for (const prior of priorBranches) exclusiveBranch = and(exclusiveBranch, not(prior));
-		const simplified = simplifyCondition(exclusiveBranch);
-		if (simplified.kind === "false") {
-			priorBranches.push(branch);
-			continue;
+function stateToCSS(state) {
+	switch (state.type) {
+		case "media": return {
+			variants: mediaToParsed(state).map((mediaCond) => {
+				const v = emptyVariant();
+				v.mediaConditions.push(mediaCond);
+				return v;
+			}),
+			isImpossible: false
+		};
+		case "root": return innerConditionToVariants(state.innerCondition, state.negated ?? false, "rootGroups");
+		case "parent": return parentConditionToVariants(state.innerCondition, state.negated ?? false, state.direct);
+		case "own": return innerConditionToVariants(state.innerCondition, state.negated ?? false, "ownGroups");
+		case "modifier": {
+			const v = emptyVariant();
+			v.modifierConditions.push(modifierToParsed(state));
+			return {
+				variants: [v],
+				isImpossible: false
+			};
+		}
+		case "pseudo": {
+			const v = emptyVariant();
+			v.pseudoConditions.push(pseudoToParsed(state));
+			return {
+				variants: [v],
+				isImpossible: false
+			};
+		}
+		case "container": {
+			const v = emptyVariant();
+			v.containerConditions.push(containerToParsed(state));
+			return {
+				variants: [v],
+				isImpossible: false
+			};
+		}
+		case "supports": {
+			const v = emptyVariant();
+			v.supportsConditions.push(supportsToParsed(state));
+			return {
+				variants: [v],
+				isImpossible: false
+			};
+		}
+		case "starting": {
+			const v = emptyVariant();
+			v.startingStyle = !state.negated;
+			return {
+				variants: [v],
+				isImpossible: false
+			};
 		}
-		result.push({
-			...entry,
-			stateKey: `${entry.stateKey}[${i}]`,
-			condition: simplified
-		});
-		priorBranches.push(branch);
 	}
-	return result;
 }
 /**
-* Collect top-level OR branches from a condition.
-*
-* For `A | B | C`, returns [A, B, C]
-* For `A & B`, returns [A & B] (single branch)
-* For `A | (B & C)`, returns [A, B & C]
+* Convert modifier condition to parsed structure
 */
-function collectOrBranches(condition) {
-	if (condition.kind === "true" || condition.kind === "false") return [condition];
-	if (isCompoundCondition(condition) && condition.operator === "OR") {
-		const branches = [];
-		for (const child of condition.children) branches.push(...collectOrBranches(child));
-		return branches;
-	}
-	return [condition];
+function modifierToParsed(state) {
+	return {
+		attribute: state.attribute,
+		value: state.value,
+		operator: state.operator,
+		negated: state.negated ?? false
+	};
 }
 /**
-* Expand OR conditions in exclusive entries AFTER buildExclusiveConditions.
-*
-* This handles ORs that arise from De Morgan expansion during negation:
-*   !(A & B) = !A | !B
-*
-* These ORs need to be made exclusive to avoid overlapping CSS rules:
-*   !A | !B  →  !A | (A & !B)
-*
-* This is logically equivalent but ensures each branch has proper context.
-*
-* Example:
-*   Input: { "": V1, "@supports(...) & :has()": V2 }
-*   V2's exclusive = @supports & :has
-*   V1's exclusive = !(@supports & :has) = !@supports | !:has
-*
-*   Without this fix: V1 gets two rules:
-*     - @supports (not ...) → V1  ✓
-*     - :not(:has()) → V1  ✗ (missing @supports context!)
-*
-*   With this fix: V1 gets two exclusive rules:
-*     - @supports (not ...) → V1  ✓
-*     - @supports (...) { :not(:has()) } → V1  ✓ (proper context!)
+* Convert parsed modifier to CSS selector string (for final output)
 */
-function expandExclusiveOrs(entries) {
-	const result = [];
-	for (const entry of entries) {
-		const expanded = expandExclusiveConditionOrs(entry);
-		result.push(...expanded);
-	}
-	return result;
+function modifierToCSS(mod) {
+	let selector;
+	if (mod.value !== void 0) {
+		const op = mod.operator || "=";
+		selector = `[${mod.attribute}${op}"${mod.value}"]`;
+	} else selector = `[${mod.attribute}]`;
+	if (mod.negated) return `:not(${selector})`;
+	return selector;
 }
 /**
-* Check if a condition involves at-rules (media, container, supports, starting)
+* Convert pseudo condition to parsed structure
 */
-function hasAtRuleContext(node) {
-	if (node.kind === "true" || node.kind === "false") return false;
-	if (node.kind === "state") return node.type === "media" || node.type === "container" || node.type === "supports" || node.type === "starting";
-	if (node.kind === "compound") return node.children.some(hasAtRuleContext);
-	return false;
+function pseudoToParsed(state) {
+	return {
+		pseudo: state.pseudo,
+		negated: state.negated ?? false
+	};
 }
 /**
-* Sort OR branches to prioritize at-rule conditions first.
+* Convert parsed pseudo to CSS selector string (for final output).
 *
-* This is critical for correct CSS generation. For `!A | !B` where A is at-rule
-* and B is modifier, we want:
-*   - Branch 0: !A (at-rule negation - covers "no @supports/media" case)
-*   - Branch 1: A & !B (modifier negation with at-rule context)
+* :not() is normalized to negated :is() at parse time, so pseudo.pseudo
+* never starts with ':not(' here. When negated:
+* - :is(X) → :not(X)     (unwrap :is)
+* - :where(X) → :not(X)  (unwrap :where)
+* - :has(X) → :not(:has(X))
+* - other → :not(other)
 *
-* If we process in wrong order (!B first), we'd get:
-*   - Branch 0: !B (modifier negation WITHOUT at-rule context - WRONG!)
-*   - Branch 1: B & !A (at-rule negation with modifier - incomplete coverage)
+* When not negated, single-argument :is()/:where() is unwrapped when the
+* inner content is a simple compound selector that can safely append to
+* the base selector (this happens after double-negation of :not()).
 */
-function sortOrBranchesForExpansion(branches) {
-	return [...branches].sort((a, b) => {
-		const aHasAtRule = hasAtRuleContext(a);
-		const bHasAtRule = hasAtRuleContext(b);
-		if (aHasAtRule && !bHasAtRule) return -1;
-		if (!aHasAtRule && bHasAtRule) return 1;
-		return 0;
-	});
+function pseudoToCSS(pseudo) {
+	const p = pseudo.pseudo;
+	if (pseudo.negated) {
+		if (p.startsWith(":is(") || p.startsWith(":where(")) return `:not(${p.slice(p.indexOf("(") + 1, -1)})`;
+		return `:not(${p})`;
+	}
+	if ((p.startsWith(":is(") || p.startsWith(":where(")) && !p.includes(",")) {
+		const inner = p.slice(p.indexOf("(") + 1, -1);
+		const ch = inner[0];
+		if ((ch === ":" || ch === "." || ch === "[" || ch === "#") && !/\s/.test(inner)) return inner;
+	}
+	return p;
 }
 /**
-* Expand ORs in a single entry's exclusive condition
+* Convert media condition to parsed structure(s)
+* Returns an array because negated ranges produce OR branches (two separate conditions)
 */
-function expandExclusiveConditionOrs(entry) {
-	let orBranches = collectOrBranches(entry.exclusiveCondition);
-	if (orBranches.length <= 1) return [entry];
-	orBranches = sortOrBranchesForExpansion(orBranches);
-	const result = [];
-	const priorBranches = [];
-	for (let i = 0; i < orBranches.length; i++) {
-		const branch = orBranches[i];
-		let exclusiveBranch = branch;
-		for (const prior of priorBranches) exclusiveBranch = and(exclusiveBranch, not(prior));
-		const simplified = simplifyCondition(exclusiveBranch);
-		if (simplified.kind === "false") {
-			priorBranches.push(branch);
-			continue;
-		}
-		result.push({
-			...entry,
-			stateKey: `${entry.stateKey}[or:${i}]`,
-			exclusiveCondition: simplified
-		});
-		priorBranches.push(branch);
-	}
-	return result;
+function mediaToParsed(state) {
+	if (state.subtype === "type") {
+		const mediaType = state.mediaType || "all";
+		return [{
+			subtype: "type",
+			negated: state.negated ?? false,
+			condition: mediaType,
+			mediaType: state.mediaType
+		}];
+	} else if (state.subtype === "feature") {
+		let condition;
+		if (state.featureValue) condition = `(${state.feature}: ${state.featureValue})`;
+		else condition = `(${state.feature})`;
+		return [{
+			subtype: "feature",
+			negated: state.negated ?? false,
+			condition,
+			feature: state.feature,
+			featureValue: state.featureValue
+		}];
+	} else return dimensionToMediaParsed(state.dimension || "width", state.lowerBound, state.upperBound, state.negated ?? false);
 }
-//#endregion
-//#region src/pipeline/materialize-contradictions.ts
 /**
-* Generic deduplication by a key extraction function.
-* Preserves insertion order, keeping the first occurrence of each key.
+* Convert dimension bounds to parsed media condition(s)
+* Uses CSS Media Queries Level 4 `not (condition)` syntax for negation.
 */
-function dedupeByKey(items, getKey) {
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const item of items) {
-		const key = getKey(item);
-		if (!seen.has(key)) {
-			seen.add(key);
-			result.push(item);
-		}
-	}
-	return result;
-}
-function dedupeMediaConditions(conditions) {
-	return dedupeByKey(conditions, (c) => `${c.subtype}|${c.condition}|${c.negated}`);
-}
-function dedupeContainerConditions(conditions) {
-	return dedupeByKey(conditions, (c) => `${c.name ?? ""}|${c.condition}|${c.negated}`);
+function dimensionToMediaParsed(dimension, lowerBound, upperBound, negated) {
+	let condition;
+	if (lowerBound && upperBound) {
+		const lowerOp = lowerBound.inclusive ? "<=" : "<";
+		const upperOp = upperBound.inclusive ? "<=" : "<";
+		condition = `(${lowerBound.value} ${lowerOp} ${dimension} ${upperOp} ${upperBound.value})`;
+	} else if (upperBound) condition = `(${dimension} ${upperBound.inclusive ? "<=" : "<"} ${upperBound.value})`;
+	else if (lowerBound) condition = `(${dimension} ${lowerBound.inclusive ? ">=" : ">"} ${lowerBound.value})`;
+	else condition = `(${dimension})`;
+	return [{
+		subtype: "dimension",
+		negated: negated ?? false,
+		condition,
+		dimension,
+		lowerBound,
+		upperBound
+	}];
 }
-function dedupeSupportsConditions(conditions) {
-	return dedupeByKey(conditions, (c) => `${c.subtype}|${c.condition}|${c.negated}`);
+/**
+* Convert container condition to parsed structure
+* This enables structured analysis for contradiction detection and condition combining
+*/
+function containerToParsed(state) {
+	let condition;
+	if (state.subtype === "style") if (state.propertyValue) condition = `style(--${state.property}: ${state.propertyValue})`;
+	else condition = `style(--${state.property})`;
+	else if (state.subtype === "raw") condition = state.rawCondition;
+	else condition = dimensionToContainerCondition(state.dimension || "width", state.lowerBound, state.upperBound);
+	return {
+		name: state.containerName,
+		condition,
+		negated: state.negated ?? false,
+		subtype: state.subtype,
+		property: state.property,
+		propertyValue: state.propertyValue
+	};
 }
 /**
-* Check if supports conditions contain contradictions
-* e.g., @supports(display: grid) AND NOT @supports(display: grid)
+* Convert dimension bounds to container query condition (single string)
+* Container queries support "not (condition)", so no need to invert manually
 */
-function hasSupportsContradiction(conditions) {
-	const conditionMap = /* @__PURE__ */ new Map();
-	for (const cond of conditions) {
-		const key = `${cond.subtype}|${cond.condition}`;
-		const existing = conditionMap.get(key);
-		if (existing !== void 0 && existing !== !cond.negated) return true;
-		conditionMap.set(key, !cond.negated);
-	}
-	return false;
+function dimensionToContainerCondition(dimension, lowerBound, upperBound) {
+	if (lowerBound && upperBound) {
+		const lowerOp = lowerBound.inclusive ? "<=" : "<";
+		const upperOp = upperBound.inclusive ? "<=" : "<";
+		return `(${lowerBound.value} ${lowerOp} ${dimension} ${upperOp} ${upperBound.value})`;
+	} else if (upperBound) return `(${dimension} ${upperBound.inclusive ? "<=" : "<"} ${upperBound.value})`;
+	else if (lowerBound) return `(${dimension} ${lowerBound.inclusive ? ">=" : ">"} ${lowerBound.value})`;
+	return "(width)";
 }
 /**
-* Check if a set of media conditions contains contradictions
-* e.g., (prefers-color-scheme: light) AND NOT (prefers-color-scheme: light)
-* or (width >= 900px) AND (width < 600px)
-*
-* Uses parsed media conditions for efficient analysis without regex parsing.
+* Convert supports condition to parsed structure
 */
-function hasMediaContradiction(conditions) {
-	const featureConditions = /* @__PURE__ */ new Map();
-	const typeConditions = /* @__PURE__ */ new Map();
-	const dimensionConditions = /* @__PURE__ */ new Map();
-	const dimensionsByDim = /* @__PURE__ */ new Map();
-	for (const cond of conditions) if (cond.subtype === "type") {
-		const key = cond.mediaType || "all";
-		const existing = typeConditions.get(key);
-		if (existing !== void 0 && existing !== !cond.negated) return true;
-		typeConditions.set(key, !cond.negated);
-	} else if (cond.subtype === "feature") {
-		const key = cond.condition;
-		const existing = featureConditions.get(key);
-		if (existing !== void 0 && existing !== !cond.negated) return true;
-		featureConditions.set(key, !cond.negated);
-	} else if (cond.subtype === "dimension") {
-		const condKey = cond.condition;
-		const existing = dimensionConditions.get(condKey);
-		if (existing !== void 0 && existing !== !cond.negated) return true;
-		dimensionConditions.set(condKey, !cond.negated);
-		if (!cond.negated) {
-			const dim = cond.dimension || "width";
-			let bounds = dimensionsByDim.get(dim);
-			if (!bounds) {
-				bounds = {
-					lowerBound: null,
-					upperBound: null
-				};
-				dimensionsByDim.set(dim, bounds);
-			}
-			if (cond.lowerBound?.valueNumeric != null) {
-				const value = cond.lowerBound.valueNumeric;
-				if (bounds.lowerBound === null || value > bounds.lowerBound) bounds.lowerBound = value;
-			}
-			if (cond.upperBound?.valueNumeric != null) {
-				const value = cond.upperBound.valueNumeric;
-				if (bounds.upperBound === null || value < bounds.upperBound) bounds.upperBound = value;
-			}
-			if (bounds.lowerBound !== null && bounds.upperBound !== null && bounds.lowerBound >= bounds.upperBound) return true;
-		}
-	}
-	return false;
+function supportsToParsed(state) {
+	return {
+		subtype: state.subtype,
+		condition: state.condition,
+		negated: state.negated ?? false
+	};
 }
 /**
-* Check if container conditions contain contradictions in style queries
-* e.g., style(--variant: danger) and style(--variant: success) together
-* Same property with different values = always false
-*
-* Uses parsed container conditions for efficient analysis without regex parsing.
+* Collect all modifier and pseudo conditions from a variant as a flat array.
 */
-function hasContainerStyleContradiction(conditions) {
-	const styleQueries = /* @__PURE__ */ new Map();
-	for (const cond of conditions) {
-		if (cond.subtype !== "style" || !cond.property) continue;
-		const property = cond.property;
-		const value = cond.propertyValue;
-		if (!styleQueries.has(property)) styleQueries.set(property, {
-			hasExistence: false,
-			values: /* @__PURE__ */ new Set(),
-			hasNegatedExistence: false
-		});
-		const entry = styleQueries.get(property);
-		if (cond.negated) {
-			if (value === void 0) entry.hasNegatedExistence = true;
-		} else if (value === void 0) entry.hasExistence = true;
-		else entry.values.add(value);
-	}
-	for (const [, entry] of styleQueries) {
-		if (entry.hasExistence && entry.hasNegatedExistence) return true;
-		if (entry.values.size > 1) return true;
-		if (entry.hasNegatedExistence && entry.values.size > 0) return true;
-	}
-	return false;
+function collectSelectorConditions(variant) {
+	return [...variant.modifierConditions, ...variant.pseudoConditions];
 }
-//#endregion
-//#region src/pipeline/materialize.ts
 /**
-* CSS Materialization
+* Convert an inner condition tree into a single SelectorVariant with
+* one SelectorGroup whose branches represent the inner OR alternatives.
+* Shared by @root() and @own().
 *
-* Converts condition trees into CSS selectors and at-rules.
-* This is the final stage that produces actual CSS output.
-*/
-const conditionCache = new Lru(3e3);
-/**
-* Convert a condition tree to CSS components
+* Both positive and negated cases produce one variant with one group.
+* Negation simply sets the `negated` flag, which swaps :is() for :not()
+* in the final CSS output — no De Morgan transformation is needed.
+*
+* This mirrors parentConditionToVariants: OR branches are kept inside
+* a single group and rendered as comma-separated arguments in
+* :is()/:not(), e.g. :root:is([a], [b]) or [el]:not([a], [b]).
 */
-function conditionToCSS(node) {
-	const key = getConditionUniqueId(node);
-	const cached = conditionCache.get(key);
-	if (cached) return cached;
-	const result = conditionToCSSInner(node);
-	conditionCache.set(key, result);
-	return result;
-}
-function emptyVariant() {
-	return {
-		modifierConditions: [],
-		pseudoConditions: [],
-		selectorGroups: [],
-		ownGroups: [],
-		mediaConditions: [],
-		containerConditions: [],
-		supportsConditions: [],
-		rootGroups: [],
-		parentGroups: [],
-		startingStyle: false
+function innerConditionToVariants(innerCondition, negated, target) {
+	const innerCSS = conditionToCSS(innerCondition);
+	if (innerCSS.isImpossible || innerCSS.variants.length === 0) return {
+		variants: [],
+		isImpossible: true
 	};
-}
-function conditionToCSSInner(node) {
-	if (node.kind === "true") return {
+	const branches = [];
+	for (const innerVariant of innerCSS.variants) {
+		const conditions = collectSelectorConditions(innerVariant);
+		if (conditions.length > 0) branches.push(conditions);
+	}
+	if (branches.length === 0) return {
 		variants: [emptyVariant()],
 		isImpossible: false
 	};
-	if (node.kind === "false") return {
+	const v = emptyVariant();
+	v[target].push({
+		branches,
+		negated
+	});
+	return {
+		variants: [v],
+		isImpossible: false
+	};
+}
+/**
+* Convert a @parent() inner condition into a single SelectorVariant with
+* one ParentGroup whose branches represent the inner OR alternatives.
+*
+* Both positive and negated cases produce one variant with one group.
+* Negation simply sets the `negated` flag, which swaps :is() for :not()
+* in the final CSS output — no structural transformation is needed.
+*/
+function parentConditionToVariants(innerCondition, negated, direct) {
+	const innerCSS = conditionToCSS(innerCondition);
+	if (innerCSS.isImpossible || innerCSS.variants.length === 0) return {
 		variants: [],
 		isImpossible: true
 	};
-	if (node.kind === "state") return stateToCSS(node);
-	if (node.kind === "compound") if (node.operator === "AND") return andToCSS(node.children);
-	else return orToCSS(node.children);
-	return {
+	const branches = [];
+	for (const innerVariant of innerCSS.variants) {
+		const conditions = collectSelectorConditions(innerVariant);
+		if (conditions.length > 0) branches.push(conditions);
+	}
+	if (branches.length === 0) return {
 		variants: [emptyVariant()],
 		isImpossible: false
 	};
+	const v = emptyVariant();
+	v.parentGroups.push({
+		branches,
+		direct,
+		negated
+	});
+	return {
+		variants: [v],
+		isImpossible: false
+	};
 }
 /**
-* Convert a state condition to CSS
+* Sort key for canonical condition output within selectors.
+*
+* Priority order:
+* 0: Boolean attribute selectors ([data-hovered])
+* 1: Value attribute selectors ([data-size="small"])
+* 2: Negated boolean attributes (:not([data-disabled]))
+* 3: Negated value attributes (:not([data-size="small"]))
+* 4: Pseudo-classes (:hover, :focus)
+* 5: Negated pseudo-classes (:not(:disabled))
+*
+* Secondary sort: alphabetical by attribute name / pseudo string.
 */
-function stateToCSS(state) {
-	switch (state.type) {
-		case "media": return {
-			variants: mediaToParsed(state).map((mediaCond) => {
-				const v = emptyVariant();
-				v.mediaConditions.push(mediaCond);
-				return v;
-			}),
-			isImpossible: false
-		};
-		case "root": return innerConditionToVariants(state.innerCondition, state.negated ?? false, "rootGroups");
-		case "parent": return parentConditionToVariants(state.innerCondition, state.negated ?? false, state.direct);
-		case "own": return innerConditionToVariants(state.innerCondition, state.negated ?? false, "ownGroups");
-		case "modifier": {
-			const v = emptyVariant();
-			v.modifierConditions.push(modifierToParsed(state));
-			return {
-				variants: [v],
-				isImpossible: false
-			};
-		}
-		case "pseudo": {
-			const v = emptyVariant();
-			v.pseudoConditions.push(pseudoToParsed(state));
-			return {
-				variants: [v],
-				isImpossible: false
-			};
-		}
-		case "container": {
-			const v = emptyVariant();
-			v.containerConditions.push(containerToParsed(state));
-			return {
-				variants: [v],
-				isImpossible: false
-			};
-		}
-		case "supports": {
-			const v = emptyVariant();
-			v.supportsConditions.push(supportsToParsed(state));
-			return {
-				variants: [v],
-				isImpossible: false
-			};
-		}
-		case "starting": {
-			const v = emptyVariant();
-			v.startingStyle = !state.negated;
-			return {
-				variants: [v],
-				isImpossible: false
-			};
-		}
+function conditionSortKey(cond) {
+	if ("attribute" in cond) {
+		const hasValue = cond.value !== void 0 ? 1 : 0;
+		return `${(cond.negated ? 2 : 0) + hasValue}|${cond.attribute}|${cond.value ?? ""}`;
 	}
+	return `${cond.negated ? 5 : 4}|${cond.pseudo}`;
+}
+function sortConditions(conditions) {
+	return conditions.toSorted((a, b) => conditionSortKey(a).localeCompare(conditionSortKey(b)));
+}
+function branchToCSS(branch) {
+	let parts = "";
+	for (const cond of sortConditions(branch)) parts += selectorConditionToCSS(cond);
+	return parts;
 }
 /**
-* Convert modifier condition to parsed structure
+* Wrap serialized selector arguments in :is() or :not().
+* Arguments are sorted for canonical output.
 */
-function modifierToParsed(state) {
-	return {
-		attribute: state.attribute,
-		value: state.value,
-		operator: state.operator,
-		negated: state.negated ?? false
-	};
+function wrapInIsOrNot(args, negated) {
+	return `${negated ? ":not" : ":is"}(${args.sort().join(", ")})`;
 }
 /**
-* Convert parsed modifier to CSS selector string (for final output)
+* Convert a selector group to a CSS selector fragment.
+*
+* Single-branch groups are unwrapped (no :is() wrapper).
+* Multi-branch groups use :is() or :not().
+* Negation swaps :is() for :not().
 */
-function modifierToCSS(mod) {
-	let selector;
-	if (mod.value !== void 0) {
-		const op = mod.operator || "=";
-		selector = `[${mod.attribute}${op}"${mod.value}"]`;
-	} else selector = `[${mod.attribute}]`;
-	if (mod.negated) return `:not(${selector})`;
-	return selector;
+function selectorGroupToCSS(group) {
+	if (group.branches.length === 0) return "";
+	if (group.branches.length === 1) {
+		const parts = branchToCSS(group.branches[0]);
+		if (group.negated) return `:not(${parts})`;
+		return parts;
+	}
+	return wrapInIsOrNot(group.branches.map(branchToCSS), group.negated);
 }
 /**
-* Convert pseudo condition to parsed structure
+* Collect facts about modifier conditions for subsumption analysis.
+* Tracks negated boolean attrs (:not([attr])) and positive exact values ([attr="X"]).
 */
-function pseudoToParsed(state) {
+function collectSubsumptionFacts(modifiers) {
+	const negatedBooleanAttrs = /* @__PURE__ */ new Set();
+	const positiveExactValuesByAttr = /* @__PURE__ */ new Map();
+	for (const mod of modifiers) {
+		if (mod.negated && mod.value === void 0) negatedBooleanAttrs.add(mod.attribute);
+		if (!mod.negated && mod.value !== void 0 && (mod.operator ?? "=") === "=") {
+			let vals = positiveExactValuesByAttr.get(mod.attribute);
+			if (!vals) {
+				vals = /* @__PURE__ */ new Set();
+				positiveExactValuesByAttr.set(mod.attribute, vals);
+			}
+			vals.add(mod.value);
+		}
+	}
 	return {
-		pseudo: state.pseudo,
-		negated: state.negated ?? false
+		negatedBooleanAttrs,
+		positiveExactValuesByAttr
 	};
 }
 /**
-* Convert parsed pseudo to CSS selector string (for final output).
-*
-* :not() is normalized to negated :is() at parse time, so pseudo.pseudo
-* never starts with ':not(' here. When negated:
-* - :is(X) → :not(X)     (unwrap :is)
-* - :where(X) → :not(X)  (unwrap :where)
-* - :has(X) → :not(:has(X))
-* - other → :not(other)
+* Check if a negated-value modifier is subsumed by stronger facts:
+* - :not([attr]) subsumes :not([attr="val"])
+* - [attr="X"] implies :not([attr="Y"]) is redundant (single exact value)
 *
-* When not negated, single-argument :is()/:where() is unwrapped when the
-* inner content is a simple compound selector that can safely append to
-* the base selector (this happens after double-negation of :not()).
+* Only applies to exact-match (=) operators; substring operators don't
+* imply exclusivity between values.
 */
-function pseudoToCSS(pseudo) {
-	const p = pseudo.pseudo;
-	if (pseudo.negated) {
-		if (p.startsWith(":is(") || p.startsWith(":where(")) return `:not(${p.slice(p.indexOf("(") + 1, -1)})`;
-		return `:not(${p})`;
-	}
-	if ((p.startsWith(":is(") || p.startsWith(":where(")) && !p.includes(",")) {
-		const inner = p.slice(p.indexOf("(") + 1, -1);
-		const ch = inner[0];
-		if ((ch === ":" || ch === "." || ch === "[" || ch === "#") && !/\s/.test(inner)) return inner;
+function isSubsumedNegatedModifier(mod, facts) {
+	if (!mod.negated || mod.value === void 0) return false;
+	if (facts.negatedBooleanAttrs.has(mod.attribute)) return true;
+	if ((mod.operator ?? "=") === "=") {
+		const posVals = facts.positiveExactValuesByAttr.get(mod.attribute);
+		if (posVals && posVals.size === 1 && !posVals.has(mod.value)) return true;
 	}
-	return p;
+	return false;
 }
 /**
-* Convert media condition to parsed structure(s)
-* Returns an array because negated ranges produce OR branches (two separate conditions)
+* Remove redundant single-condition groups that are subsumed by stronger
+* groups on the same attribute. O(n) — only inspects single-branch,
+* single-condition groups.
 */
-function mediaToParsed(state) {
-	if (state.subtype === "type") {
-		const mediaType = state.mediaType || "all";
-		return [{
-			subtype: "type",
-			negated: state.negated ?? false,
-			condition: mediaType,
-			mediaType: state.mediaType
-		}];
-	} else if (state.subtype === "feature") {
-		let condition;
-		if (state.featureValue) condition = `(${state.feature}: ${state.featureValue})`;
-		else condition = `(${state.feature})`;
-		return [{
-			subtype: "feature",
-			negated: state.negated ?? false,
-			condition,
-			feature: state.feature,
-			featureValue: state.featureValue
-		}];
-	} else return dimensionToMediaParsed(state.dimension || "width", state.lowerBound, state.upperBound, state.negated ?? false);
+function optimizeGroups(groups) {
+	if (groups.length <= 1) return groups;
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const g of groups) {
+		const key = getSelectorGroupKey(g);
+		if (!seen.has(key)) {
+			seen.add(key);
+			result.push(g);
+		}
+	}
+	if (result.length <= 1) return result;
+	const effectiveModifiers = [];
+	for (const g of result) {
+		if (g.branches.length !== 1 || g.branches[0].length !== 1) continue;
+		const cond = g.branches[0][0];
+		if (!("attribute" in cond)) continue;
+		effectiveModifiers.push({
+			...cond,
+			negated: g.negated !== cond.negated
+		});
+	}
+	const facts = collectSubsumptionFacts(effectiveModifiers);
+	if (facts.negatedBooleanAttrs.size === 0 && facts.positiveExactValuesByAttr.size === 0) return result;
+	return result.filter((g) => {
+		if (g.branches.length !== 1 || g.branches[0].length !== 1) return true;
+		const cond = g.branches[0][0];
+		if (!("attribute" in cond) || !g.negated || cond.negated || cond.value === void 0) return true;
+		return !isSubsumedNegatedModifier({
+			...cond,
+			negated: true
+		}, facts);
+	});
 }
 /**
-* Convert dimension bounds to parsed media condition(s)
-* Uses CSS Media Queries Level 4 `not (condition)` syntax for negation.
+* Convert root groups to CSS selector prefix (for final output)
 */
-function dimensionToMediaParsed(dimension, lowerBound, upperBound, negated) {
-	let condition;
-	if (lowerBound && upperBound) {
-		const lowerOp = lowerBound.inclusive ? "<=" : "<";
-		const upperOp = upperBound.inclusive ? "<=" : "<";
-		condition = `(${lowerBound.value} ${lowerOp} ${dimension} ${upperOp} ${upperBound.value})`;
-	} else if (upperBound) condition = `(${dimension} ${upperBound.inclusive ? "<=" : "<"} ${upperBound.value})`;
-	else if (lowerBound) condition = `(${dimension} ${lowerBound.inclusive ? ">=" : ">"} ${lowerBound.value})`;
-	else condition = `(${dimension})`;
-	return [{
-		subtype: "dimension",
-		negated: negated ?? false,
-		condition,
-		dimension,
-		lowerBound,
-		upperBound
-	}];
+function rootGroupsToCSS(groups) {
+	if (groups.length === 0) return void 0;
+	const optimized = optimizeGroups(groups);
+	if (optimized.length === 0) return void 0;
+	let prefix = ":root";
+	for (const group of optimized) prefix += selectorGroupToCSS(group);
+	return prefix;
 }
 /**
-* Convert container condition to parsed structure
-* This enables structured analysis for contradiction detection and condition combining
+* Convert parent groups to CSS selector fragments (for final output).
+* Each group produces its own :is()/:not() wrapper with a combinator
+* suffix (` *` or ` > *`) appended to each branch.
 */
-function containerToParsed(state) {
-	let condition;
-	if (state.subtype === "style") if (state.propertyValue) condition = `style(--${state.property}: ${state.propertyValue})`;
-	else condition = `style(--${state.property})`;
-	else if (state.subtype === "raw") condition = state.rawCondition;
-	else condition = dimensionToContainerCondition(state.dimension || "width", state.lowerBound, state.upperBound);
-	return {
-		name: state.containerName,
-		condition,
-		negated: state.negated ?? false,
-		subtype: state.subtype,
-		property: state.property,
-		propertyValue: state.propertyValue
-	};
+function parentGroupsToCSS(groups) {
+	let result = "";
+	for (const group of groups) {
+		const combinator = group.direct ? " > *" : " *";
+		const args = group.branches.map((branch) => branchToCSS(branch) + combinator);
+		result += wrapInIsOrNot(args, group.negated);
+	}
+	return result;
 }
 /**
-* Convert dimension bounds to container query condition (single string)
-* Container queries support "not (condition)", so no need to invert manually
+* Convert a modifier or pseudo condition to a CSS selector fragment
 */
-function dimensionToContainerCondition(dimension, lowerBound, upperBound) {
-	if (lowerBound && upperBound) {
-		const lowerOp = lowerBound.inclusive ? "<=" : "<";
-		const upperOp = upperBound.inclusive ? "<=" : "<";
-		return `(${lowerBound.value} ${lowerOp} ${dimension} ${upperOp} ${upperBound.value})`;
-	} else if (upperBound) return `(${dimension} ${upperBound.inclusive ? "<=" : "<"} ${upperBound.value})`;
-	else if (lowerBound) return `(${dimension} ${lowerBound.inclusive ? ">=" : ">"} ${lowerBound.value})`;
-	return "(width)";
+function selectorConditionToCSS(cond) {
+	if ("attribute" in cond) return modifierToCSS(cond);
+	return pseudoToCSS(cond);
 }
 /**
-* Convert supports condition to parsed structure
+* Get unique key for a modifier condition
 */
-function supportsToParsed(state) {
-	return {
-		subtype: state.subtype,
-		condition: state.condition,
-		negated: state.negated ?? false
-	};
+function getModifierKey(mod) {
+	const base = mod.value ? `${mod.attribute}${mod.operator || "="}${mod.value}` : mod.attribute;
+	return mod.negated ? `!${base}` : base;
 }
 /**
-* Collect all modifier and pseudo conditions from a variant as a flat array.
+* Get unique key for a pseudo condition
 */
-function collectSelectorConditions(variant) {
-	return [...variant.modifierConditions, ...variant.pseudoConditions];
+function getPseudoKey(pseudo) {
+	return pseudo.negated ? `!${pseudo.pseudo}` : pseudo.pseudo;
 }
 /**
-* Convert an inner condition tree into a single SelectorVariant with
-* one SelectorGroup whose branches represent the inner OR alternatives.
-* Shared by @root() and @own().
-*
-* Both positive and negated cases produce one variant with one group.
-* Negation simply sets the `negated` flag, which swaps :is() for :not()
-* in the final CSS output — no De Morgan transformation is needed.
-*
-* This mirrors parentConditionToVariants: OR branches are kept inside
-* a single group and rendered as comma-separated arguments in
-* :is()/:not(), e.g. :root:is([a], [b]) or [el]:not([a], [b]).
+* Get unique key for any selector condition (modifier or pseudo)
 */
-function innerConditionToVariants(innerCondition, negated, target) {
-	const innerCSS = conditionToCSS(innerCondition);
-	if (innerCSS.isImpossible || innerCSS.variants.length === 0) return {
-		variants: [],
-		isImpossible: true
-	};
-	const branches = [];
-	for (const innerVariant of innerCSS.variants) {
-		const conditions = collectSelectorConditions(innerVariant);
-		if (conditions.length > 0) branches.push(conditions);
-	}
-	if (branches.length === 0) return {
-		variants: [emptyVariant()],
-		isImpossible: false
-	};
-	const v = emptyVariant();
-	v[target].push({
-		branches,
-		negated
-	});
-	return {
-		variants: [v],
-		isImpossible: false
-	};
+function getSelectorConditionKey(cond) {
+	return "attribute" in cond ? `mod:${getModifierKey(cond)}` : `pseudo:${getPseudoKey(cond)}`;
 }
 /**
-* Convert a @parent() inner condition into a single SelectorVariant with
-* one ParentGroup whose branches represent the inner OR alternatives.
-*
-* Both positive and negated cases produce one variant with one group.
-* Negation simply sets the `negated` flag, which swaps :is() for :not()
-* in the final CSS output — no structural transformation is needed.
+* Deduplicate selector conditions (modifiers or pseudos).
+* Shared by root, parent, and own conditions.
 */
-function parentConditionToVariants(innerCondition, negated, direct) {
-	const innerCSS = conditionToCSS(innerCondition);
-	if (innerCSS.isImpossible || innerCSS.variants.length === 0) return {
-		variants: [],
-		isImpossible: true
-	};
-	const branches = [];
-	for (const innerVariant of innerCSS.variants) {
-		const conditions = collectSelectorConditions(innerVariant);
-		if (conditions.length > 0) branches.push(conditions);
+function dedupeSelectorConditions(conditions) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const c of conditions) {
+		const key = getSelectorConditionKey(c);
+		if (!seen.has(key)) {
+			seen.add(key);
+			result.push(c);
+		}
 	}
-	if (branches.length === 0) return {
-		variants: [emptyVariant()],
-		isImpossible: false
-	};
-	const v = emptyVariant();
-	v.parentGroups.push({
-		branches,
-		direct,
-		negated
+	const facts = collectSubsumptionFacts(result.filter((c) => "attribute" in c));
+	if (facts.negatedBooleanAttrs.size === 0 && facts.positiveExactValuesByAttr.size === 0) return result;
+	return result.filter((c) => {
+		if (!("attribute" in c)) return true;
+		if (isSubsumedNegatedModifier(c, facts)) return false;
+		if (!c.negated && c.value === void 0 && facts.positiveExactValuesByAttr.has(c.attribute)) return false;
+		return true;
 	});
-	return {
-		variants: [v],
-		isImpossible: false
-	};
 }
 /**
-* Sort key for canonical condition output within selectors.
-*
-* Priority order:
-* 0: Boolean attribute selectors ([data-hovered])
-* 1: Value attribute selectors ([data-size="small"])
-* 2: Negated boolean attributes (:not([data-disabled]))
-* 3: Negated value attributes (:not([data-size="small"]))
-* 4: Pseudo-classes (:hover, :focus)
-* 5: Negated pseudo-classes (:not(:disabled))
-*
-* Secondary sort: alphabetical by attribute name / pseudo string.
+* Check for modifier contradiction: same attribute with opposite negation
 */
-function conditionSortKey(cond) {
-	if ("attribute" in cond) {
-		const hasValue = cond.value !== void 0 ? 1 : 0;
-		return `${(cond.negated ? 2 : 0) + hasValue}|${cond.attribute}|${cond.value ?? ""}`;
+function hasModifierContradiction(conditions) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const mod of conditions) {
+		const baseKey = mod.value ? `${mod.attribute}${mod.operator || "="}${mod.value}` : mod.attribute;
+		const existing = byKey.get(baseKey);
+		if (existing !== void 0 && existing !== !mod.negated) return true;
+		byKey.set(baseKey, !mod.negated);
 	}
-	return `${cond.negated ? 5 : 4}|${cond.pseudo}`;
-}
-function sortConditions(conditions) {
-	return conditions.toSorted((a, b) => conditionSortKey(a).localeCompare(conditionSortKey(b)));
-}
-function branchToCSS(branch) {
-	let parts = "";
-	for (const cond of sortConditions(branch)) parts += selectorConditionToCSS(cond);
-	return parts;
-}
-/**
-* Wrap serialized selector arguments in :is() or :not().
-* Arguments are sorted for canonical output.
-*/
-function wrapInIsOrNot(args, negated) {
-	return `${negated ? ":not" : ":is"}(${args.sort().join(", ")})`;
-}
-/**
-* Convert a selector group to a CSS selector fragment.
-*
-* Single-branch groups are unwrapped (no :is() wrapper).
-* Multi-branch groups use :is() or :not().
-* Negation swaps :is() for :not().
-*/
-function selectorGroupToCSS(group) {
-	if (group.branches.length === 0) return "";
-	if (group.branches.length === 1) {
-		const parts = branchToCSS(group.branches[0]);
-		if (group.negated) return `:not(${parts})`;
-		return parts;
-	}
-	return wrapInIsOrNot(group.branches.map(branchToCSS), group.negated);
-}
-/**
-* Collect facts about modifier conditions for subsumption analysis.
-* Tracks negated boolean attrs (:not([attr])) and positive exact values ([attr="X"]).
-*/
-function collectSubsumptionFacts(modifiers) {
-	const negatedBooleanAttrs = /* @__PURE__ */ new Set();
-	const positiveExactValuesByAttr = /* @__PURE__ */ new Map();
-	for (const mod of modifiers) {
-		if (mod.negated && mod.value === void 0) negatedBooleanAttrs.add(mod.attribute);
-		if (!mod.negated && mod.value !== void 0 && (mod.operator ?? "=") === "=") {
-			let vals = positiveExactValuesByAttr.get(mod.attribute);
-			if (!vals) {
-				vals = /* @__PURE__ */ new Set();
-				positiveExactValuesByAttr.set(mod.attribute, vals);
-			}
-			vals.add(mod.value);
-		}
-	}
-	return {
-		negatedBooleanAttrs,
-		positiveExactValuesByAttr
-	};
-}
-/**
-* Check if a negated-value modifier is subsumed by stronger facts:
-* - :not([attr]) subsumes :not([attr="val"])
-* - [attr="X"] implies :not([attr="Y"]) is redundant (single exact value)
-*
-* Only applies to exact-match (=) operators; substring operators don't
-* imply exclusivity between values.
-*/
-function isSubsumedNegatedModifier(mod, facts) {
-	if (!mod.negated || mod.value === void 0) return false;
-	if (facts.negatedBooleanAttrs.has(mod.attribute)) return true;
-	if ((mod.operator ?? "=") === "=") {
-		const posVals = facts.positiveExactValuesByAttr.get(mod.attribute);
-		if (posVals && posVals.size === 1 && !posVals.has(mod.value)) return true;
-	}
-	return false;
-}
-/**
-* Remove redundant single-condition groups that are subsumed by stronger
-* groups on the same attribute. O(n) — only inspects single-branch,
-* single-condition groups.
-*/
-function optimizeGroups(groups) {
-	if (groups.length <= 1) return groups;
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const g of groups) {
-		const key = getSelectorGroupKey(g);
-		if (!seen.has(key)) {
-			seen.add(key);
-			result.push(g);
-		}
-	}
-	if (result.length <= 1) return result;
-	const effectiveModifiers = [];
-	for (const g of result) {
-		if (g.branches.length !== 1 || g.branches[0].length !== 1) continue;
-		const cond = g.branches[0][0];
-		if (!("attribute" in cond)) continue;
-		effectiveModifiers.push({
-			...cond,
-			negated: g.negated !== cond.negated
-		});
-	}
-	const facts = collectSubsumptionFacts(effectiveModifiers);
-	if (facts.negatedBooleanAttrs.size === 0 && facts.positiveExactValuesByAttr.size === 0) return result;
-	return result.filter((g) => {
-		if (g.branches.length !== 1 || g.branches[0].length !== 1) return true;
-		const cond = g.branches[0][0];
-		if (!("attribute" in cond) || !g.negated || cond.negated || cond.value === void 0) return true;
-		return !isSubsumedNegatedModifier({
-			...cond,
-			negated: true
-		}, facts);
-	});
-}
-/**
-* Convert root groups to CSS selector prefix (for final output)
-*/
-function rootGroupsToCSS(groups) {
-	if (groups.length === 0) return void 0;
-	const optimized = optimizeGroups(groups);
-	if (optimized.length === 0) return void 0;
-	let prefix = ":root";
-	for (const group of optimized) prefix += selectorGroupToCSS(group);
-	return prefix;
-}
-/**
-* Convert parent groups to CSS selector fragments (for final output).
-* Each group produces its own :is()/:not() wrapper with a combinator
-* suffix (` *` or ` > *`) appended to each branch.
-*/
-function parentGroupsToCSS(groups) {
-	let result = "";
-	for (const group of groups) {
-		const combinator = group.direct ? " > *" : " *";
-		const args = group.branches.map((branch) => branchToCSS(branch) + combinator);
-		result += wrapInIsOrNot(args, group.negated);
-	}
-	return result;
-}
-/**
-* Convert a modifier or pseudo condition to a CSS selector fragment
-*/
-function selectorConditionToCSS(cond) {
-	if ("attribute" in cond) return modifierToCSS(cond);
-	return pseudoToCSS(cond);
-}
-/**
-* Get unique key for a modifier condition
-*/
-function getModifierKey(mod) {
-	const base = mod.value ? `${mod.attribute}${mod.operator || "="}${mod.value}` : mod.attribute;
-	return mod.negated ? `!${base}` : base;
-}
-/**
-* Get unique key for a pseudo condition
-*/
-function getPseudoKey(pseudo) {
-	return pseudo.negated ? `!${pseudo.pseudo}` : pseudo.pseudo;
-}
-/**
-* Get unique key for any selector condition (modifier or pseudo)
-*/
-function getSelectorConditionKey(cond) {
-	return "attribute" in cond ? `mod:${getModifierKey(cond)}` : `pseudo:${getPseudoKey(cond)}`;
-}
-/**
-* Deduplicate selector conditions (modifiers or pseudos).
-* Shared by root, parent, and own conditions.
-*/
-function dedupeSelectorConditions(conditions) {
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const c of conditions) {
-		const key = getSelectorConditionKey(c);
-		if (!seen.has(key)) {
-			seen.add(key);
-			result.push(c);
-		}
-	}
-	const facts = collectSubsumptionFacts(result.filter((c) => "attribute" in c));
-	if (facts.negatedBooleanAttrs.size === 0 && facts.positiveExactValuesByAttr.size === 0) return result;
-	return result.filter((c) => {
-		if (!("attribute" in c)) return true;
-		if (isSubsumedNegatedModifier(c, facts)) return false;
-		if (!c.negated && c.value === void 0 && facts.positiveExactValuesByAttr.has(c.attribute)) return false;
-		return true;
-	});
-}
-/**
-* Check for modifier contradiction: same attribute with opposite negation
-*/
-function hasModifierContradiction(conditions) {
-	const byKey = /* @__PURE__ */ new Map();
-	for (const mod of conditions) {
-		const baseKey = mod.value ? `${mod.attribute}${mod.operator || "="}${mod.value}` : mod.attribute;
-		const existing = byKey.get(baseKey);
-		if (existing !== void 0 && existing !== !mod.negated) return true;
-		byKey.set(baseKey, !mod.negated);
-	}
-	return false;
+	return false;
 }
 /**
 * Check for pseudo contradiction: same pseudo with opposite negation
@@ -8132,346 +7754,748 @@ function isModifierConditionsSuperset(a, b) {
 function isPseudoConditionsSuperset(a, b) {
 	return isConditionsSuperset(a, b, getPseudoKey);
 }
-function isSelectorGroupsSuperset(a, b) {
-	if (a.length < b.length) return false;
-	return isConditionsSuperset(a, b, getSelectorGroupKey);
+function isSelectorGroupsSuperset(a, b) {
+	if (a.length < b.length) return false;
+	return isConditionsSuperset(a, b, getSelectorGroupKey);
+}
+/**
+* Check if parent groups A is a superset of B.
+* Each group in B must have a matching group in A.
+*/
+function isParentGroupsSuperset(a, b) {
+	if (a.length < b.length) return false;
+	return isConditionsSuperset(a, b, getParentGroupKey);
+}
+function getParentGroupKey(g) {
+	return `${g.negated ? "!" : ""}${g.direct ? ">" : ""}(${getBranchesKey(g.branches)})`;
+}
+/**
+* Deduplicate variants
+*
+* Removes:
+* 1. Exact duplicates (same key)
+* 2. Superset variants (more restrictive selectors that are redundant)
+*/
+function dedupeVariants(variants) {
+	if (variants.length <= 1) return variants;
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const v of variants) {
+		const key = getVariantKey(v);
+		if (!seen.has(key)) {
+			seen.add(key);
+			result.push(v);
+		}
+	}
+	if (result.length <= 1) return result;
+	result.sort((a, b) => variantConditionCount(a) - variantConditionCount(b));
+	const filtered = [];
+	for (const candidate of result) {
+		let isRedundant = false;
+		for (const kept of filtered) if (isVariantSuperset(candidate, kept)) {
+			isRedundant = true;
+			break;
+		}
+		if (!isRedundant) filtered.push(candidate);
+	}
+	return filtered;
+}
+/**
+* Combine AND conditions into CSS
+*
+* AND of conditions means cartesian product of variants:
+* (A1 | A2) & (B1 | B2) = A1&B1 | A1&B2 | A2&B1 | A2&B2
+*
+* Variants that result in contradictions (e.g., conflicting media rules)
+* are filtered out.
+*/
+function andToCSS(children) {
+	const exclusiveChildren = makeOrBranchesExclusive(children);
+	let currentVariants = [emptyVariant()];
+	for (const child of exclusiveChildren) {
+		const childCSS = conditionToCSSInner(child);
+		if (childCSS.isImpossible || childCSS.variants.length === 0) return {
+			variants: [],
+			isImpossible: true
+		};
+		const newVariants = [];
+		for (const current of currentVariants) for (const childVariant of childCSS.variants) {
+			const merged = mergeVariants(current, childVariant);
+			if (merged !== null) newVariants.push(merged);
+		}
+		if (newVariants.length === 0) return {
+			variants: [],
+			isImpossible: true
+		};
+		currentVariants = dedupeVariants(newVariants);
+	}
+	return {
+		variants: currentVariants,
+		isImpossible: false
+	};
+}
+/**
+* Make OR branches within AND children mutually exclusive.
+*
+* For an AND child that is OR(A, B), transforms it to OR(A, B & !A)
+* so that when andToCSS does a Cartesian product, the resulting
+* CSS variants don't overlap.
+*
+* Only transforms OR children whose branches actually produce
+* different at-rule contexts when materialized. This avoids
+* breaking cases where contradiction detection in the Cartesian
+* product naturally handles deduplication.
+*/
+function makeOrBranchesExclusive(children) {
+	return children.map((child) => {
+		if (!isCompoundCondition(child) || child.operator !== "OR") return child;
+		if (child.children.length <= 1) return child;
+		if (!branchesProduceDifferentContexts(child.children)) return child;
+		const exclusiveBranches = [];
+		const priorBranches = [];
+		for (const branch of child.children) {
+			if (priorBranches.length === 0) exclusiveBranches.push(branch);
+			else {
+				let exclusive = branch;
+				for (const prior of priorBranches) exclusive = and(exclusive, not(prior));
+				const simplified = simplifyCondition(exclusive);
+				if (simplified.kind !== "false") exclusiveBranches.push(simplified);
+			}
+			priorBranches.push(branch);
+		}
+		if (exclusiveBranches.length === 0) return child;
+		if (exclusiveBranches.length === 1) return exclusiveBranches[0];
+		return {
+			kind: "compound",
+			operator: "OR",
+			children: exclusiveBranches
+		};
+	});
+}
+/**
+* Check if OR branches produce different at-rule contexts when
+* materialized. If so, the Cartesian product in andToCSS will
+* create overlapping CSS variants that need exclusive expansion.
+*
+* Exported so Stage 2a (`expandOrConditions` in `exclusive.ts`) can
+* reuse the same heuristic and skip OR expansion when every branch
+* lives in the same at-rule/root/parent/own context — pure-selector
+* ORs are better collapsed into `:is(...)` at materialization time
+* than expanded into mutually-exclusive `A | (B & !A) | …` cascades.
+*/
+function branchesProduceDifferentContexts(branches) {
+	const contextKeys = /* @__PURE__ */ new Set();
+	for (const branch of branches) {
+		const css = conditionToCSSInner(branch);
+		if (css.isImpossible) continue;
+		for (const v of css.variants) contextKeys.add(getVariantContextKey(v));
+	}
+	return contextKeys.size > 1;
+}
+/**
+* Combine OR conditions into CSS
+*
+* OR in CSS means multiple selector variants (DNF).
+* After deduplication, variants that differ only in their base
+* modifier/pseudo conditions are merged into :is() groups.
+*
+* Note: OR exclusivity is handled at the pipeline level (expandOrConditions),
+* so here we just collect all variants. Any remaining ORs in the condition
+* tree (e.g., from De Morgan expansion) are handled as simple alternatives.
+*/
+function orToCSS(children) {
+	const allVariants = [];
+	for (const child of children) {
+		const childCSS = conditionToCSSInner(child);
+		if (childCSS.isImpossible) continue;
+		allVariants.push(...childCSS.variants);
+	}
+	if (allVariants.length === 0) return {
+		variants: [],
+		isImpossible: true
+	};
+	return {
+		variants: dedupeVariants(allVariants),
+		isImpossible: false
+	};
+}
+/**
+* Find keys present in ALL condition arrays.
+*/
+function findCommonKeys(conditionSets, getKey) {
+	if (conditionSets.length === 0) return /* @__PURE__ */ new Set();
+	const common = new Set(conditionSets[0].map(getKey));
+	for (let i = 1; i < conditionSets.length; i++) {
+		const keys = new Set(conditionSets[i].map(getKey));
+		for (const key of common) if (!keys.has(key)) common.delete(key);
+	}
+	return common;
+}
+/**
+* Merge OR variants that share the same "context" (at-rules, root, parent,
+* own, starting) into a single variant with a SelectorGroup.
+*
+* Variants with no modifier/pseudo conditions are kept separate (they match
+* unconditionally and can't be expressed inside :is()).
+*/
+function mergeVariantsIntoSelectorGroups(variants) {
+	if (variants.length <= 1) return variants;
+	const groups = /* @__PURE__ */ new Map();
+	for (const v of variants) {
+		const key = getVariantContextKey(v);
+		const group = groups.get(key);
+		if (group) group.push(v);
+		else groups.set(key, [v]);
+	}
+	const result = [];
+	for (const group of groups.values()) {
+		if (group.length === 1) {
+			result.push(group[0]);
+			continue;
+		}
+		const withSelectors = [];
+		const withoutSelectors = [];
+		for (const v of group) if (v.modifierConditions.length === 0 && v.pseudoConditions.length === 0) withoutSelectors.push(v);
+		else withSelectors.push(v);
+		result.push(...withoutSelectors);
+		if (withSelectors.length <= 1) {
+			result.push(...withSelectors);
+			continue;
+		}
+		result.push(factorAndGroup(withSelectors));
+	}
+	return result;
+}
+/**
+* Factor common modifier/pseudo conditions out of variants and create
+* a single variant with a SelectorGroup for the remaining (differing)
+* conditions.
+*
+* Precondition: all variants must share the same context key (identical
+* at-rules, root/parent/own/selector groups, startingStyle).
+*/
+function factorAndGroup(variants) {
+	{
+		const key0 = getVariantContextKey(variants[0]);
+		for (let i = 1; i < variants.length; i++) {
+			const keyI = getVariantContextKey(variants[i]);
+			if (keyI !== key0) throw new Error(`factorAndGroup: context key mismatch at index ${i}.\n  expected: ${key0}\n  got:      ${keyI}`);
+		}
+	}
+	const commonModKeys = findCommonKeys(variants.map((v) => v.modifierConditions), getModifierKey);
+	const commonPseudoKeys = findCommonKeys(variants.map((v) => v.pseudoConditions), getPseudoKey);
+	const commonModifiers = variants[0].modifierConditions.filter((m) => commonModKeys.has(getModifierKey(m)));
+	const commonPseudos = variants[0].pseudoConditions.filter((p) => commonPseudoKeys.has(getPseudoKey(p)));
+	const branches = [];
+	let hasEmptyBranch = false;
+	for (const v of variants) {
+		const branch = [];
+		for (const mod of v.modifierConditions) if (!commonModKeys.has(getModifierKey(mod))) branch.push(mod);
+		for (const pseudo of v.pseudoConditions) if (!commonPseudoKeys.has(getPseudoKey(pseudo))) branch.push(pseudo);
+		if (branch.length > 0) branches.push(branch);
+		else hasEmptyBranch = true;
+	}
+	if (hasEmptyBranch) return {
+		...variants[0],
+		modifierConditions: commonModifiers,
+		pseudoConditions: commonPseudos
+	};
+	const factoredGroups = tryFactorIntoDimensions(branches);
+	if (factoredGroups) return {
+		modifierConditions: commonModifiers,
+		pseudoConditions: commonPseudos,
+		selectorGroups: [...variants[0].selectorGroups, ...factoredGroups],
+		ownGroups: [...variants[0].ownGroups],
+		mediaConditions: [...variants[0].mediaConditions],
+		containerConditions: [...variants[0].containerConditions],
+		supportsConditions: [...variants[0].supportsConditions],
+		rootGroups: [...variants[0].rootGroups],
+		parentGroups: [...variants[0].parentGroups],
+		startingStyle: variants[0].startingStyle
+	};
+	return {
+		modifierConditions: commonModifiers,
+		pseudoConditions: commonPseudos,
+		selectorGroups: [...variants[0].selectorGroups, {
+			branches,
+			negated: false
+		}],
+		ownGroups: [...variants[0].ownGroups],
+		mediaConditions: [...variants[0].mediaConditions],
+		containerConditions: [...variants[0].containerConditions],
+		supportsConditions: [...variants[0].supportsConditions],
+		rootGroups: [...variants[0].rootGroups],
+		parentGroups: [...variants[0].parentGroups],
+		startingStyle: variants[0].startingStyle
+	};
+}
+/**
+* Detect when branches form a complete Cartesian product of independent
+* modifier attribute dimensions and return one SelectorGroup per dimension.
+*
+* Example: 4 branches for 2 attributes × 2 values each →
+*   :is(A1, A2):is(B1, B2)  instead of  :is(A1B1, A1B2, A2B1, A2B2)
+*/
+function tryFactorIntoDimensions(branches) {
+	if (branches.length < 4) return null;
+	const dimensions = /* @__PURE__ */ new Map();
+	for (const branch of branches) for (const cond of branch) {
+		if (!("attribute" in cond)) return null;
+		if (!dimensions.has(cond.attribute)) dimensions.set(cond.attribute, /* @__PURE__ */ new Map());
+		dimensions.get(cond.attribute).set(getModifierKey(cond), cond);
+	}
+	if (dimensions.size < 2) return null;
+	for (const branch of branches) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const cond of branch) {
+			const attr = cond.attribute;
+			if (seen.has(attr)) return null;
+			seen.add(attr);
+		}
+		if (seen.size !== dimensions.size) return null;
+	}
+	let expectedCount = 1;
+	for (const vals of dimensions.values()) expectedCount *= vals.size;
+	if (branches.length !== expectedCount) return null;
+	return [...dimensions.values()].map((vals) => ({
+		branches: [...vals.values()].map((cond) => [cond]),
+		negated: false
+	}));
+}
+/**
+* Build at-rules array from a variant
+*/
+function buildAtRulesFromVariant(variant) {
+	const atRules = [];
+	if (variant.mediaConditions.length > 0) {
+		const conditionParts = variant.mediaConditions.map((c) => {
+			if (c.subtype === "type") return c.negated ? `not ${c.condition}` : c.condition;
+			else return c.negated ? `(not ${c.condition})` : c.condition;
+		});
+		atRules.push(`@media ${conditionParts.sort().join(" and ")}`);
+	}
+	if (variant.containerConditions.length > 0) {
+		const byName = /* @__PURE__ */ new Map();
+		for (const cond of variant.containerConditions) {
+			const group = byName.get(cond.name) || [];
+			group.push(cond);
+			byName.set(cond.name, group);
+		}
+		for (const [name, conditions] of byName) {
+			const conditionParts = conditions.map((c) => c.negated ? `(not ${c.condition})` : c.condition);
+			const namePrefix = name ? `${name} ` : "";
+			atRules.push(`@container ${namePrefix}${conditionParts.join(" and ")}`);
+		}
+	}
+	if (variant.supportsConditions.length > 0) {
+		const conditionParts = variant.supportsConditions.map((c) => {
+			if (c.subtype === "selector") {
+				const selectorCond = `selector(${c.condition})`;
+				return c.negated ? `(not ${selectorCond})` : selectorCond;
+			} else {
+				const featureCond = `(${c.condition})`;
+				return c.negated ? `(not ${featureCond})` : featureCond;
+			}
+		});
+		atRules.push(`@supports ${conditionParts.join(" and ")}`);
+	}
+	return atRules;
+}
+//#endregion
+//#region src/pipeline/exclusive.ts
+/**
+* Build exclusive conditions for a list of parsed style entries.
+*
+* The entries should be ordered by priority (highest priority first).
+*
+* For each entry, we compute:
+*   exclusiveCondition = condition & !prior[0] & !prior[1] & ...
+*
+* This ensures exactly one condition matches at any time.
+*
+* Example:
+*   Input (ordered highest to lowest priority):
+*     A: value1 (priority 2)
+*     B: value2 (priority 1)
+*     C: value3 (priority 0)
+*
+*   Output:
+*     A: A
+*     B: B & !A
+*     C: C & !A & !B
+*
+* @param entries Parsed style entries ordered by priority (highest first)
+* @returns Entries with exclusive conditions, filtered to remove impossible ones
+*/
+function buildExclusiveConditions(entries) {
+	const result = [];
+	const priorConditions = [];
+	for (const entry of entries) {
+		let exclusive = entry.condition;
+		for (const prior of priorConditions) if (prior.kind !== "true") exclusive = and(exclusive, not(prior));
+		const simplified = simplifyCondition(exclusive);
+		if (simplified.kind === "false") continue;
+		result.push({
+			...entry,
+			exclusiveCondition: simplified
+		});
+		if (entry.condition.kind !== "true") priorConditions.push(entry.condition);
+	}
+	return result;
+}
+/**
+* Parse style entries from a value mapping object.
+*
+* @param styleKey The style key (e.g., 'padding')
+* @param valueMap The value mapping { '': '2x', 'compact': '1x', '@media(w < 768px)': '0.5x' }
+* @param parseCondition Function to parse state keys into conditions
+* @returns Parsed entries ordered by priority (highest first)
+*/
+function parseStyleEntries(styleKey, valueMap, parseCondition) {
+	const entries = [];
+	Object.keys(valueMap).forEach((stateKey, index) => {
+		const value = valueMap[stateKey];
+		const condition = stateKey === "" ? trueCondition() : parseCondition(stateKey);
+		entries.push({
+			styleKey,
+			stateKey,
+			value,
+			condition,
+			priority: index
+		});
+	});
+	entries.reverse();
+	return entries;
+}
+/**
+* Merge parsed entries that share the same value.
+*
+* When multiple **non-default** state keys map to the same value, their
+* conditions can be combined with OR and treated as a single entry.
+* This must happen **before** exclusive expansion and OR branch splitting
+* to avoid combinatorial explosion and duplicate CSS output.
+*
+* Default (TRUE) entries are **never** merged with non-default entries.
+* Merging `TRUE | X` collapses to `TRUE`, destroying the non-default
+* condition's participation in exclusive building. That causes
+* intermediate-priority states to lose their `:not(X)` negation,
+* breaking mutual exclusivity when X and an intermediate state are
+* both active. Stage 6 `mergeByValue` handles combining rules with
+* identical CSS output after exclusive conditions are correctly built.
+*
+* Example: `{ '@dark': 'red', '@dark & @hc': 'red' }` merges into a
+* single entry with condition `@dark | (@dark & @hc)` = `@dark`.
+*
+* Entries are ordered highest-priority-first. The merged entry keeps the
+* highest priority of the group.
+*/
+function mergeEntriesByValue(entries) {
+	if (entries.length <= 1) return entries;
+	const groups = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const valueKey = serializeValue(entry.value);
+		const group = groups.get(valueKey);
+		if (group) {
+			group.entries.push(entry);
+			group.maxPriority = Math.max(group.maxPriority, entry.priority);
+		} else groups.set(valueKey, {
+			entries: [entry],
+			maxPriority: entry.priority
+		});
+	}
+	if (groups.size === entries.length) return entries;
+	const merged = [];
+	for (const [, group] of groups) {
+		if (group.entries.length === 1) {
+			merged.push(group.entries[0]);
+			continue;
+		}
+		const defaultEntries = group.entries.filter((e) => e.condition.kind === "true");
+		const nonDefaultEntries = group.entries.filter((e) => e.condition.kind !== "true");
+		for (const entry of defaultEntries) merged.push(entry);
+		if (nonDefaultEntries.length === 1) merged.push(nonDefaultEntries[0]);
+		else if (nonDefaultEntries.length >= 2) {
+			const combinedCondition = simplifyCondition(or(...nonDefaultEntries.map((e) => e.condition)));
+			const combinedStateKey = nonDefaultEntries.map((e) => e.stateKey).join(" | ");
+			merged.push({
+				styleKey: nonDefaultEntries[0].styleKey,
+				stateKey: combinedStateKey,
+				value: nonDefaultEntries[0].value,
+				condition: combinedCondition,
+				priority: group.maxPriority
+			});
+		}
+	}
+	merged.sort((a, b) => b.priority - a.priority);
+	return merged;
+}
+function serializeValue(value) {
+	if (value === null || value === void 0) return "null";
+	if (typeof value === "string" || typeof value === "number") return String(value);
+	return JSON.stringify(value);
 }
 /**
-* Check if parent groups A is a superset of B.
-* Each group in B must have a matching group in A.
+* Eliminate redundant state dimensions from a value map.
+*
+* When a value map contains compound AND state keys (e.g. `@dark & @hc`),
+* checks whether any state atom is a "don't-care" variable — i.e. the
+* value is the same whether that atom is present or absent. Redundant
+* atoms are removed from all keys and duplicate entries are collapsed.
+*
+* This runs **before** condition parsing so that downstream stages
+* (`mergeEntriesByValue`, `buildExclusiveConditions`, materialization)
+* never see the irrelevant dimension, producing simpler, smaller CSS.
+*
+* Only pure top-level AND combinations are eligible. Keys that contain
+* `|`, `^`, or `,` at the top level are treated as opaque single atoms.
+*
+* @example
+*   { '': A, '@dark': B, '@hc': A, '@dark & @hc': B }
+*   // @hc is redundant → { '': A, '@dark': B }
 */
-function isParentGroupsSuperset(a, b) {
-	if (a.length < b.length) return false;
-	return isConditionsSuperset(a, b, getParentGroupKey);
-}
-function getParentGroupKey(g) {
-	return `${g.negated ? "!" : ""}${g.direct ? ">" : ""}(${getBranchesKey(g.branches)})`;
+function extractCompoundStates(valueMap) {
+	const keys = Object.keys(valueMap);
+	if (keys.length < 3 || !keys.some((k) => k.includes("&"))) return valueMap;
+	const entries = keys.map((key) => {
+		return {
+			atoms: splitTopLevelAnd(key) ?? [key],
+			value: valueMap[key]
+		};
+	});
+	const allAtoms = /* @__PURE__ */ new Set();
+	for (const e of entries) for (const a of e.atoms) allAtoms.add(a);
+	const redundant = /* @__PURE__ */ new Set();
+	for (const atom of allAtoms) if (isAtomRedundant(entries, atom)) redundant.add(atom);
+	if (redundant.size === 0) return valueMap;
+	const newMap = {};
+	for (const e of entries) {
+		const newKey = e.atoms.filter((a) => !redundant.has(a)).join(" & ");
+		if (!(newKey in newMap)) newMap[newKey] = e.value;
+	}
+	return newMap;
 }
 /**
-* Deduplicate variants
+* Split a state key by top-level `&` operators.
 *
-* Removes:
-* 1. Exact duplicates (same key)
-* 2. Superset variants (more restrictive selectors that are redundant)
+* Returns `null` if the key contains `|`, `^`, or `,` at the top level
+* (making it ineligible for atom-level extraction).
+* Returns `[]` for the empty string (default key).
 */
-function dedupeVariants(variants) {
-	if (variants.length <= 1) return variants;
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const v of variants) {
-		const key = getVariantKey(v);
-		if (!seen.has(key)) {
-			seen.add(key);
-			result.push(v);
-		}
-	}
-	if (result.length <= 1) return result;
-	result.sort((a, b) => variantConditionCount(a) - variantConditionCount(b));
-	const filtered = [];
-	for (const candidate of result) {
-		let isRedundant = false;
-		for (const kept of filtered) if (isVariantSuperset(candidate, kept)) {
-			isRedundant = true;
-			break;
+function splitTopLevelAnd(key) {
+	if (key === "") return [];
+	const parts = [];
+	let depth = 0;
+	let current = "";
+	for (const ch of key) {
+		if (ch === "(" || ch === "[") depth++;
+		else if (ch === ")" || ch === "]") depth--;
+		if (depth === 0) {
+			if (ch === "&") {
+				const trimmed = current.trim();
+				if (trimmed) parts.push(trimmed);
+				current = "";
+				continue;
+			}
+			if (ch === "|" || ch === "^" || ch === ",") return null;
 		}
-		if (!isRedundant) filtered.push(candidate);
+		current += ch;
 	}
-	return filtered;
+	const trimmed = current.trim();
+	if (trimmed) parts.push(trimmed);
+	return parts;
 }
 /**
-* Combine AND conditions into CSS
-*
-* AND of conditions means cartesian product of variants:
-* (A1 | A2) & (B1 | B2) = A1&B1 | A1&B2 | A2&B1 | A2&B2
-*
-* Variants that result in contradictions (e.g., conflicting media rules)
-* are filtered out.
+* An atom is redundant when every entry that contains it has a matching
+* partner (same remaining atoms, atom absent) with the same value.
 */
-function andToCSS(children) {
-	const exclusiveChildren = makeOrBranchesExclusive(children);
-	let currentVariants = [emptyVariant()];
-	for (const child of exclusiveChildren) {
-		const childCSS = conditionToCSSInner(child);
-		if (childCSS.isImpossible || childCSS.variants.length === 0) return {
-			variants: [],
-			isImpossible: true
-		};
-		const newVariants = [];
-		for (const current of currentVariants) for (const childVariant of childCSS.variants) {
-			const merged = mergeVariants(current, childVariant);
-			if (merged !== null) newVariants.push(merged);
-		}
-		if (newVariants.length === 0) return {
-			variants: [],
-			isImpossible: true
-		};
-		currentVariants = dedupeVariants(newVariants);
+function isAtomRedundant(entries, atom) {
+	const withAtom = entries.filter((e) => e.atoms.includes(atom));
+	if (withAtom.length === 0) return false;
+	for (const wa of withAtom) {
+		const remaining = wa.atoms.filter((a) => a !== atom);
+		const pair = entries.find((e) => !e.atoms.includes(atom) && e.atoms.length === remaining.length && remaining.every((r) => e.atoms.includes(r)));
+		if (!pair) return false;
+		if (serializeValue(wa.value) !== serializeValue(pair.value)) return false;
 	}
-	return {
-		variants: currentVariants,
-		isImpossible: false
-	};
+	return true;
 }
 /**
-* Make OR branches within AND children mutually exclusive.
-*
-* For an AND child that is OR(A, B), transforms it to OR(A, B & !A)
-* so that when andToCSS does a Cartesian product, the resulting
-* CSS variants don't overlap.
-*
-* Only transforms OR children whose branches actually produce
-* different at-rule contexts when materialized. This avoids
-* breaking cases where contradiction detection in the Cartesian
-* product naturally handles deduplication.
+* Check if a value is a style value mapping (object with state keys)
 */
-function makeOrBranchesExclusive(children) {
-	return children.map((child) => {
-		if (!isCompoundCondition(child) || child.operator !== "OR") return child;
-		if (child.children.length <= 1) return child;
-		if (!branchesProduceDifferentContexts(child.children)) return child;
-		const exclusiveBranches = [];
-		const priorBranches = [];
-		for (const branch of child.children) {
-			if (priorBranches.length === 0) exclusiveBranches.push(branch);
-			else {
-				let exclusive = branch;
-				for (const prior of priorBranches) exclusive = and(exclusive, not(prior));
-				const simplified = simplifyCondition(exclusive);
-				if (simplified.kind !== "false") exclusiveBranches.push(simplified);
-			}
-			priorBranches.push(branch);
-		}
-		if (exclusiveBranches.length === 0) return child;
-		if (exclusiveBranches.length === 1) return exclusiveBranches[0];
-		return {
-			kind: "compound",
-			operator: "OR",
-			children: exclusiveBranches
-		};
-	});
+function isValueMapping(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
 }
 /**
-* Check if OR branches produce different at-rule contexts when
-* materialized. If so, the Cartesian product in andToCSS will
-* create overlapping CSS variants that need exclusive expansion.
+* Expand OR conditions in parsed entries into multiple exclusive entries.
+*
+* For an entry with condition `A | B | C`, this creates 3 entries:
+*   - condition: A
+*   - condition: B & !A
+*   - condition: C & !A & !B
+*
+* This ensures OR branches are mutually exclusive BEFORE the main
+* exclusive condition building pass.
+*
+* @param entries Parsed entries (may contain OR conditions)
+* @returns Expanded entries with OR branches made exclusive
 */
-function branchesProduceDifferentContexts(branches) {
-	const contextKeys = /* @__PURE__ */ new Set();
-	for (const branch of branches) {
-		const css = conditionToCSSInner(branch);
-		if (css.isImpossible) continue;
-		for (const v of css.variants) contextKeys.add(getVariantContextKey(v));
+function expandOrConditions(entries) {
+	const result = [];
+	for (const entry of entries) {
+		const expanded = expandSingleEntry(entry);
+		result.push(...expanded);
 	}
-	return contextKeys.size > 1;
+	return result;
 }
 /**
-* Combine OR conditions into CSS
+* Expand a single entry's OR condition into multiple exclusive entries.
 *
-* OR in CSS means multiple selector variants (DNF).
-* After deduplication, variants that differ only in their base
-* modifier/pseudo conditions are merged into :is() groups.
+* Note: branches are NOT sorted by at-rule context here (unlike the
+* `expandExclusiveOrs` pass below). User-authored ORs in state keys aren't
+* the product of De Morgan negation, so each branch is expected to render
+* independently in its own scope and at-rule sort isn't load-bearing.
+* The post-build pass needs the sort because it has to preserve at-rule
+* wrapping across branches that came from negating a compound at-rule.
 *
-* Note: OR exclusivity is handled at the pipeline level (expandOrConditions),
-* so here we just collect all variants. Any remaining ORs in the condition
-* tree (e.g., from De Morgan expansion) are handled as simple alternatives.
+* Skip optimisation: when every branch renders into the same at-rule /
+* root / parent / own context (see "Key Design Decision #2" in
+* `docs/pipeline.md`), forcing mutual exclusivity here produces dead
+* `B & !A`-style branches that materialization later folds back into
+* `:is(A, B)`. Bail out and let `materialize.ts` collapse the OR via
+* `mergeVariantsIntoSelectorGroups`. Cross-entry exclusivity is still
+* enforced by `buildExclusiveConditions`; the post-build `expandExclusiveOrs`
+* pass still handles De Morgan ORs whose branches actually differ in
+* context.
 */
-function orToCSS(children) {
-	const allVariants = [];
-	for (const child of children) {
-		const childCSS = conditionToCSSInner(child);
-		if (childCSS.isImpossible) continue;
-		allVariants.push(...childCSS.variants);
+function expandSingleEntry(entry) {
+	const orBranches = collectOrBranches(entry.condition);
+	if (orBranches.length <= 1) return [entry];
+	if (!branchesProduceDifferentContexts(orBranches)) return [entry];
+	const result = [];
+	const priorBranches = [];
+	for (let i = 0; i < orBranches.length; i++) {
+		const branch = orBranches[i];
+		let exclusiveBranch = branch;
+		for (const prior of priorBranches) exclusiveBranch = and(exclusiveBranch, not(prior));
+		const simplified = simplifyCondition(exclusiveBranch);
+		if (simplified.kind === "false") {
+			priorBranches.push(branch);
+			continue;
+		}
+		result.push({
+			...entry,
+			stateKey: `${entry.stateKey}[${i}]`,
+			condition: simplified
+		});
+		priorBranches.push(branch);
 	}
-	if (allVariants.length === 0) return {
-		variants: [],
-		isImpossible: true
-	};
-	return {
-		variants: dedupeVariants(allVariants),
-		isImpossible: false
-	};
+	return result;
 }
 /**
-* Find keys present in ALL condition arrays.
+* Collect top-level OR branches from a condition.
+*
+* For `A | B | C`, returns [A, B, C]
+* For `A & B`, returns [A & B] (single branch)
+* For `A | (B & C)`, returns [A, B & C]
 */
-function findCommonKeys(conditionSets, getKey) {
-	if (conditionSets.length === 0) return /* @__PURE__ */ new Set();
-	const common = new Set(conditionSets[0].map(getKey));
-	for (let i = 1; i < conditionSets.length; i++) {
-		const keys = new Set(conditionSets[i].map(getKey));
-		for (const key of common) if (!keys.has(key)) common.delete(key);
+function collectOrBranches(condition) {
+	if (condition.kind === "true" || condition.kind === "false") return [condition];
+	if (isCompoundCondition(condition) && condition.operator === "OR") {
+		const branches = [];
+		for (const child of condition.children) branches.push(...collectOrBranches(child));
+		return branches;
 	}
-	return common;
+	return [condition];
 }
 /**
-* Merge OR variants that share the same "context" (at-rules, root, parent,
-* own, starting) into a single variant with a SelectorGroup.
+* Expand OR conditions in exclusive entries AFTER buildExclusiveConditions.
 *
-* Variants with no modifier/pseudo conditions are kept separate (they match
-* unconditionally and can't be expressed inside :is()).
+* This handles ORs that arise from De Morgan expansion during negation:
+*   !(A & B) = !A | !B
+*
+* These ORs need to be made exclusive to avoid overlapping CSS rules:
+*   !A | !B  →  !A | (A & !B)
+*
+* This is logically equivalent but ensures each branch has proper context.
+*
+* Example:
+*   Input: { "": V1, "@supports(...) & :has()": V2 }
+*   V2's exclusive = @supports & :has
+*   V1's exclusive = !(@supports & :has) = !@supports | !:has
+*
+*   Without this fix: V1 gets two rules:
+*     - @supports (not ...) → V1  ✓
+*     - :not(:has()) → V1  ✗ (missing @supports context!)
+*
+*   With this fix: V1 gets two exclusive rules:
+*     - @supports (not ...) → V1  ✓
+*     - @supports (...) { :not(:has()) } → V1  ✓ (proper context!)
 */
-function mergeVariantsIntoSelectorGroups(variants) {
-	if (variants.length <= 1) return variants;
-	const groups = /* @__PURE__ */ new Map();
-	for (const v of variants) {
-		const key = getVariantContextKey(v);
-		const group = groups.get(key);
-		if (group) group.push(v);
-		else groups.set(key, [v]);
-	}
+function expandExclusiveOrs(entries) {
 	const result = [];
-	for (const group of groups.values()) {
-		if (group.length === 1) {
-			result.push(group[0]);
-			continue;
-		}
-		const withSelectors = [];
-		const withoutSelectors = [];
-		for (const v of group) if (v.modifierConditions.length === 0 && v.pseudoConditions.length === 0) withoutSelectors.push(v);
-		else withSelectors.push(v);
-		result.push(...withoutSelectors);
-		if (withSelectors.length <= 1) {
-			result.push(...withSelectors);
-			continue;
-		}
-		result.push(factorAndGroup(withSelectors));
+	for (const entry of entries) {
+		const expanded = expandExclusiveConditionOrs(entry);
+		result.push(...expanded);
 	}
 	return result;
 }
 /**
-* Factor common modifier/pseudo conditions out of variants and create
-* a single variant with a SelectorGroup for the remaining (differing)
-* conditions.
-*
-* Precondition: all variants must share the same context key (identical
-* at-rules, root/parent/own/selector groups, startingStyle).
+* Check if a condition involves at-rules (media, container, supports, starting)
 */
-function factorAndGroup(variants) {
-	{
-		const key0 = getVariantContextKey(variants[0]);
-		for (let i = 1; i < variants.length; i++) {
-			const keyI = getVariantContextKey(variants[i]);
-			if (keyI !== key0) throw new Error(`factorAndGroup: context key mismatch at index ${i}.\n  expected: ${key0}\n  got:      ${keyI}`);
-		}
-	}
-	const commonModKeys = findCommonKeys(variants.map((v) => v.modifierConditions), getModifierKey);
-	const commonPseudoKeys = findCommonKeys(variants.map((v) => v.pseudoConditions), getPseudoKey);
-	const commonModifiers = variants[0].modifierConditions.filter((m) => commonModKeys.has(getModifierKey(m)));
-	const commonPseudos = variants[0].pseudoConditions.filter((p) => commonPseudoKeys.has(getPseudoKey(p)));
-	const branches = [];
-	let hasEmptyBranch = false;
-	for (const v of variants) {
-		const branch = [];
-		for (const mod of v.modifierConditions) if (!commonModKeys.has(getModifierKey(mod))) branch.push(mod);
-		for (const pseudo of v.pseudoConditions) if (!commonPseudoKeys.has(getPseudoKey(pseudo))) branch.push(pseudo);
-		if (branch.length > 0) branches.push(branch);
-		else hasEmptyBranch = true;
-	}
-	if (hasEmptyBranch) return {
-		...variants[0],
-		modifierConditions: commonModifiers,
-		pseudoConditions: commonPseudos
-	};
-	const factoredGroups = tryFactorIntoDimensions(branches);
-	if (factoredGroups) return {
-		modifierConditions: commonModifiers,
-		pseudoConditions: commonPseudos,
-		selectorGroups: [...variants[0].selectorGroups, ...factoredGroups],
-		ownGroups: [...variants[0].ownGroups],
-		mediaConditions: [...variants[0].mediaConditions],
-		containerConditions: [...variants[0].containerConditions],
-		supportsConditions: [...variants[0].supportsConditions],
-		rootGroups: [...variants[0].rootGroups],
-		parentGroups: [...variants[0].parentGroups],
-		startingStyle: variants[0].startingStyle
-	};
-	return {
-		modifierConditions: commonModifiers,
-		pseudoConditions: commonPseudos,
-		selectorGroups: [...variants[0].selectorGroups, {
-			branches,
-			negated: false
-		}],
-		ownGroups: [...variants[0].ownGroups],
-		mediaConditions: [...variants[0].mediaConditions],
-		containerConditions: [...variants[0].containerConditions],
-		supportsConditions: [...variants[0].supportsConditions],
-		rootGroups: [...variants[0].rootGroups],
-		parentGroups: [...variants[0].parentGroups],
-		startingStyle: variants[0].startingStyle
-	};
+function hasAtRuleContext(node) {
+	if (node.kind === "true" || node.kind === "false") return false;
+	if (node.kind === "state") return node.type === "media" || node.type === "container" || node.type === "supports" || node.type === "starting";
+	if (node.kind === "compound") return node.children.some(hasAtRuleContext);
+	return false;
 }
 /**
-* Detect when branches form a complete Cartesian product of independent
-* modifier attribute dimensions and return one SelectorGroup per dimension.
+* Sort OR branches to prioritize at-rule conditions first.
 *
-* Example: 4 branches for 2 attributes × 2 values each →
-*   :is(A1, A2):is(B1, B2)  instead of  :is(A1B1, A1B2, A2B1, A2B2)
+* This is critical for correct CSS generation. For `!A | !B` where A is at-rule
+* and B is modifier, we want:
+*   - Branch 0: !A (at-rule negation - covers "no @supports/media" case)
+*   - Branch 1: A & !B (modifier negation with at-rule context)
+*
+* If we process in wrong order (!B first), we'd get:
+*   - Branch 0: !B (modifier negation WITHOUT at-rule context - WRONG!)
+*   - Branch 1: B & !A (at-rule negation with modifier - incomplete coverage)
 */
-function tryFactorIntoDimensions(branches) {
-	if (branches.length < 4) return null;
-	const dimensions = /* @__PURE__ */ new Map();
-	for (const branch of branches) for (const cond of branch) {
-		if (!("attribute" in cond)) return null;
-		if (!dimensions.has(cond.attribute)) dimensions.set(cond.attribute, /* @__PURE__ */ new Map());
-		dimensions.get(cond.attribute).set(getModifierKey(cond), cond);
-	}
-	if (dimensions.size < 2) return null;
-	for (const branch of branches) {
-		const seen = /* @__PURE__ */ new Set();
-		for (const cond of branch) {
-			const attr = cond.attribute;
-			if (seen.has(attr)) return null;
-			seen.add(attr);
-		}
-		if (seen.size !== dimensions.size) return null;
-	}
-	let expectedCount = 1;
-	for (const vals of dimensions.values()) expectedCount *= vals.size;
-	if (branches.length !== expectedCount) return null;
-	return [...dimensions.values()].map((vals) => ({
-		branches: [...vals.values()].map((cond) => [cond]),
-		negated: false
-	}));
+function sortOrBranchesForExpansion(branches) {
+	return [...branches].sort((a, b) => {
+		const aHasAtRule = hasAtRuleContext(a);
+		const bHasAtRule = hasAtRuleContext(b);
+		if (aHasAtRule && !bHasAtRule) return -1;
+		if (!aHasAtRule && bHasAtRule) return 1;
+		return 0;
+	});
 }
 /**
-* Build at-rules array from a variant
+* Expand ORs in a single entry's exclusive condition
 */
-function buildAtRulesFromVariant(variant) {
-	const atRules = [];
-	if (variant.mediaConditions.length > 0) {
-		const conditionParts = variant.mediaConditions.map((c) => {
-			if (c.subtype === "type") return c.negated ? `not ${c.condition}` : c.condition;
-			else return c.negated ? `(not ${c.condition})` : c.condition;
-		});
-		atRules.push(`@media ${conditionParts.sort().join(" and ")}`);
-	}
-	if (variant.containerConditions.length > 0) {
-		const byName = /* @__PURE__ */ new Map();
-		for (const cond of variant.containerConditions) {
-			const group = byName.get(cond.name) || [];
-			group.push(cond);
-			byName.set(cond.name, group);
-		}
-		for (const [name, conditions] of byName) {
-			const conditionParts = conditions.map((c) => c.negated ? `(not ${c.condition})` : c.condition);
-			const namePrefix = name ? `${name} ` : "";
-			atRules.push(`@container ${namePrefix}${conditionParts.join(" and ")}`);
+function expandExclusiveConditionOrs(entry) {
+	let orBranches = collectOrBranches(entry.exclusiveCondition);
+	if (orBranches.length <= 1) return [entry];
+	if (!branchesProduceDifferentContexts(orBranches)) return [entry];
+	orBranches = sortOrBranchesForExpansion(orBranches);
+	const result = [];
+	const priorBranches = [];
+	for (let i = 0; i < orBranches.length; i++) {
+		const branch = orBranches[i];
+		let exclusiveBranch = branch;
+		for (const prior of priorBranches) exclusiveBranch = and(exclusiveBranch, not(prior));
+		const simplified = simplifyCondition(exclusiveBranch);
+		if (simplified.kind === "false") {
+			priorBranches.push(branch);
+			continue;
 		}
-	}
-	if (variant.supportsConditions.length > 0) {
-		const conditionParts = variant.supportsConditions.map((c) => {
-			if (c.subtype === "selector") {
-				const selectorCond = `selector(${c.condition})`;
-				return c.negated ? `(not ${selectorCond})` : selectorCond;
-			} else {
-				const featureCond = `(${c.condition})`;
-				return c.negated ? `(not ${featureCond})` : featureCond;
-			}
+		result.push({
+			...entry,
+			stateKey: `${entry.stateKey}[or:${i}]`,
+			exclusiveCondition: simplified
 		});
-		atRules.push(`@supports ${conditionParts.join(" and ")}`);
+		priorBranches.push(branch);
 	}
-	return atRules;
+	return result;
 }
 //#endregion
 //#region src/utils/case-converter.ts
@@ -8538,6 +8562,15 @@ function emitWarning(code, message) {
 const MAX_XOR_CHAIN_LENGTH = 4;
 const parseCache = new Lru(5e3);
 /**
+* Chrome-internal pseudo-classes (e.g. `:-internal-autofill-selected`,
+* `:-internal-autofill-previewed`) cannot be targeted from user CSS and
+* may invalidate the surrounding rule in Safari even when wrapped in
+* forgiving `:is(...)`. The regex matches both bare uses and references
+* inside enhanced pseudo arguments like `:is(:-webkit-autofill,
+* :-internal-autofill-selected)`.
+*/
+const INTERNAL_PSEUDO_PATTERN = /:-internal-[a-z0-9-]+/g;
+/**
 * Pattern for tokenizing state notation.
 * Matches: operators, parentheses, @-prefixed states, value mods, boolean mods,
 * pseudo-classes, class selectors, and attribute selectors.
@@ -8955,6 +8988,14 @@ function parseStateKey(stateKey, options = {}) {
 	const cacheKey = trimmed + "\0" + (options.isSubElement ? "1" : "0") + "\0" + localStatesKey;
 	const cached = parseCache.get(cacheKey);
 	if (cached) return cached;
+	if (isDevEnv()) {
+		INTERNAL_PSEUDO_PATTERN.lastIndex = 0;
+		const internalMatches = trimmed.match(INTERNAL_PSEUDO_PATTERN);
+		if (internalMatches && internalMatches.length > 0) {
+			const unique = Array.from(new Set(internalMatches));
+			emitWarning("INTERNAL_PSEUDO_USED", `State key "${trimmed}" references internal pseudo-class${unique.length > 1 ? "es" : ""} ${unique.map((p) => `\`${p}\``).join(", ")}. These are unmatchable from user CSS and can invalidate the surrounding rule in Safari (even inside \`:is(...)\`). Use \`:-webkit-autofill | :autofill\` instead for autofill states.`);
+		}
+	}
 	const result = new Parser(tokenize(trimmed), options).parse();
 	parseCache.set(cacheKey, result);
 	return result;
@@ -9024,7 +9065,15 @@ function runPipeline(styles, parserContext) {
 function processStyles(styles, selectorSuffix, parserContext, allRules) {
 	const keys = Object.keys(styles);
 	const selectorKeys = keys.filter((key) => isSelector(key));
-	const styleKeys = keys.filter((key) => !isSelector(key) && !key.startsWith("@"));
+	const styleKeys = [];
+	for (const key of keys) {
+		if (isSelector(key) || key.startsWith("@")) continue;
+		if (key.startsWith(":")) {
+			emitWarning("INVALID_TOP_LEVEL_PSEUDO_KEY", `Style key "${key}" starts with ':' which is not a valid Tasty style key. Use "&${key}" for nested-selector form, or move the state into a value map (e.g. \`{ color: { '${key}': value } }\`). The key has been ignored.`);
+			continue;
+		}
+		styleKeys.push(key);
+	}
 	processNestedSelectors(styles, selectorKeys, selectorSuffix, parserContext, allRules);
 	processHandlerQueue(buildHandlerQueue(styleKeys, styles), selectorSuffix, parserContext, allRules);
 }
@@ -10348,4 +10397,4 @@ function resetConfig() {
 //#endregion
 export { parseColor as $, StyleInjector as A, strToRgb as At, styleHandlers as B, parseStateKey as C, getColorSpaceFunc as Ct, extractPredefinedStateRefs as D, getRgbValuesFromRgbaString as Dt, extractLocalPredefinedStates as E, getNamedColorHex as Et, fontFaceContentHash as F, CUSTOM_UNITS as G, warn as H, formatFontFaceRule as I, filterMods as J, DIRECTIONS as K, hasLocalFontFace as L, formatCounterStyleRule as M, hasLocalCounterStyle as N, getGlobalPredefinedStates as O, hexToRgb as Ot, extractLocalFontFace as P, normalizeColorTokenValue as Q, SheetManager as R, renderStyles as S, getColorSpaceComponents as St, createStateParserContext as T, getComponentPropertySyntax as Tt, createStyle as U, deprecationWarning as V, PropertyTypeResolver as W, getGlobalParser as X, getGlobalFuncs as Y, getGlobalPredefinedTokens as Z, markStylesGenerated as _, extractLocalProperties as _t, getGlobalCounterStyle as a, okhslPlugin as at, hasPipelineCacheEntry as b, parsePropertyToken as bt, getGlobalKeyframes as c, DEFAULT_NAME_PREFIX as ct, getNamePrefix as d, makeCounterStyleName as dt, parseStyle as et, hasGlobalKeyframes as f, makeKeyframeName as ft, isTestEnvironment as g, hashString as gt, isConfigLocked as h, isDevEnv as ht, getGlobalConfigTokens as i, okhslFunc as it, extractLocalCounterStyle as j, Lru as jt, setGlobalPredefinedStates as k, hslToRgbValues as kt, getGlobalRecipes as l, DEFAULT_ZERO_NAME_PREFIX as lt, hasStylesGenerated as m, validateNamePrefix as mt, getConfig as n, setGlobalPredefinedTokens as nt, getGlobalFontFace as o, StyleParser as ot, hasGlobalRecipes as p, tastyClassRegex as pt, customFunc as q, getEffectiveProperties as r, stringifyStyles as rt, getGlobalInjector as s, Bucket as st, configure as t, resetGlobalPredefinedTokens as tt, getGlobalStyles as u, makeClassName as ut, resetConfig as v, getEffectiveDefinition as vt, camelToKebab as w, getColorSpaceSuffix as wt, isSelector as x, colorInitialValueToComponents as xt, generateTypographyTokens as y, hasLocalProperties as yt, STYLE_HANDLER_MAP as z };
 
-//# sourceMappingURL=config-JokB1Lc8.js.map
+//# sourceMappingURL=config-D0ZQMdY8.js.map