@tenphi/tasty 0.0.0-snapshot.b3fbcbb → 0.0.0-snapshot.bae20d4

package/dist/pipeline/materialize.js

@@ -1,5 +1,5 @@
 import { Lru } from "../parser/lru.js";
-import { getConditionUniqueId, not } from "./conditions.js";
+import { getConditionUniqueId } from "./conditions.js";
 
 //#region src/pipeline/materialize.ts
 /**
@@ -24,11 +24,12 @@ function emptyVariant() {
 	return {
 		modifierConditions: [],
 		pseudoConditions: [],
-		ownConditions: [],
+		selectorGroups: [],
+		ownGroups: [],
 		mediaConditions: [],
 		containerConditions: [],
 		supportsConditions: [],
-		rootConditions: [],
+		rootGroups: [],
 		parentGroups: [],
 		startingStyle: false
 	};
@@ -63,9 +64,9 @@ function stateToCSS(state) {
 			}),
 			isImpossible: false
 		};
-		case "root": return innerConditionToVariants(state.innerCondition, state.negated ?? false, "rootConditions");
+		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, "ownConditions");
+		case "own": return innerConditionToVariants(state.innerCondition, state.negated ?? false, "ownGroups");
 		case "modifier": {
 			const v = emptyVariant();
 			v.modifierConditions.push(modifierToParsed(state));
@@ -141,14 +142,31 @@ function pseudoToParsed(state) {
 	};
 }
 /**
-* Convert parsed pseudo to CSS selector string (for final output)
+* 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)
+*
+* 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 pseudoToCSS(pseudo) {
+	const p = pseudo.pseudo;
 	if (pseudo.negated) {
-		if (pseudo.pseudo.startsWith(":not(")) return pseudo.pseudo.slice(5, -1);
-		return `:not(${pseudo.pseudo})`;
+		if (p.startsWith(":is(") || p.startsWith(":where(")) return `:not(${p.slice(p.indexOf("(") + 1, -1)})`;
+		return `:not(${p})`;
 	}
-	return pseudo.pseudo;
+	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;
 }
 /**
 * Convert media condition to parsed structure(s)
@@ -247,40 +265,50 @@ function collectSelectorConditions(variant) {
 	return [...variant.modifierConditions, ...variant.pseudoConditions];
 }
 /**
-* Convert an inner condition tree into SelectorVariants.
-* Each inner OR branch becomes a separate variant, preserving disjunction.
+* 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]).
 */
 function innerConditionToVariants(innerCondition, negated, target) {
-	const innerCSS = conditionToCSS(negated ? not(innerCondition) : innerCondition);
+	const innerCSS = conditionToCSS(innerCondition);
 	if (innerCSS.isImpossible || innerCSS.variants.length === 0) return {
 		variants: [],
 		isImpossible: true
 	};
-	const variants = [];
+	const branches = [];
 	for (const innerVariant of innerCSS.variants) {
 		const conditions = collectSelectorConditions(innerVariant);
-		if (conditions.length > 0) {
-			const v = emptyVariant();
-			v[target].push(...conditions);
-			variants.push(v);
-		}
+		if (conditions.length > 0) branches.push(conditions);
 	}
-	if (variants.length === 0) return {
+	if (branches.length === 0) return {
 		variants: [emptyVariant()],
 		isImpossible: false
 	};
+	const v = emptyVariant();
+	v[target].push({
+		branches,
+		negated
+	});
 	return {
-		variants,
+		variants: [v],
 		isImpossible: false
 	};
 }
 /**
-* Convert a @parent() inner condition into SelectorVariants with ParentGroups.
+* Convert a @parent() inner condition into a single SelectorVariant with
+* one ParentGroup whose branches represent the inner OR alternatives.
 *
-* Positive: each inner OR branch becomes a separate variant with one :is() group.
-* Negated: !(A | B) = !A & !B — all branches become :not() groups collected
-* into a single variant so they produce :not([a] *):not([b] *) on one element.
+* 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);
@@ -288,68 +316,178 @@ function parentConditionToVariants(innerCondition, negated, direct) {
 		variants: [],
 		isImpossible: true
 	};
-	if (negated) {
-		const v = emptyVariant();
-		for (const innerVariant of innerCSS.variants) {
-			const conditions = collectSelectorConditions(innerVariant);
-			if (conditions.length > 0) v.parentGroups.push({
-				conditions,
-				direct,
-				negated: true
-			});
-		}
-		if (v.parentGroups.length === 0) return {
-			variants: [emptyVariant()],
-			isImpossible: false
-		};
-		return {
-			variants: [v],
-			isImpossible: false
-		};
-	}
-	const variants = [];
+	const branches = [];
 	for (const innerVariant of innerCSS.variants) {
 		const conditions = collectSelectorConditions(innerVariant);
-		if (conditions.length > 0) {
-			const v = emptyVariant();
-			v.parentGroups.push({
-				conditions,
-				direct,
-				negated: false
-			});
-			variants.push(v);
-		}
+		if (conditions.length > 0) branches.push(conditions);
 	}
-	if (variants.length === 0) return {
+	if (branches.length === 0) return {
 		variants: [emptyVariant()],
 		isImpossible: false
 	};
+	const v = emptyVariant();
+	v.parentGroups.push({
+		branches,
+		direct,
+		negated
+	});
 	return {
-		variants,
+		variants: [v],
 		isImpossible: false
 	};
 }
 /**
-* Convert parsed root conditions to CSS selector prefix (for final output)
+* 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 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;
+}
+/**
+* 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 rootConditionsToCSS(roots) {
-	if (roots.length === 0) return void 0;
+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 cond of roots) prefix += selectorConditionToCSS(cond);
+	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() wrapper.
+* 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 ? " > *" : " *";
-		let parts = "";
-		for (const cond of group.conditions) parts += selectorConditionToCSS(cond);
-		const wrapper = group.negated ? ":not" : ":is";
-		result += `${wrapper}(${parts}${combinator})`;
+		const args = group.branches.map((branch) => branchToCSS(branch) + combinator);
+		result += wrapInIsOrNot(args, group.negated);
 	}
 	return result;
 }
@@ -385,7 +523,7 @@ function getSelectorConditionKey(cond) {
 */
 function dedupeSelectorConditions(conditions) {
 	const seen = /* @__PURE__ */ new Set();
-	let result = [];
+	const result = [];
 	for (const c of conditions) {
 		const key = getSelectorConditionKey(c);
 		if (!seen.has(key)) {
@@ -393,30 +531,12 @@ function dedupeSelectorConditions(conditions) {
 			result.push(c);
 		}
 	}
-	const negatedBooleanAttrs = /* @__PURE__ */ new Set();
-	const positiveExactValuesByAttr = /* @__PURE__ */ new Map();
-	for (const c of result) {
-		if (!("attribute" in c)) continue;
-		if (c.negated && c.value === void 0) negatedBooleanAttrs.add(c.attribute);
-		const op = c.operator ?? "=";
-		if (!c.negated && c.value !== void 0 && op === "=") {
-			let values = positiveExactValuesByAttr.get(c.attribute);
-			if (!values) {
-				values = /* @__PURE__ */ new Set();
-				positiveExactValuesByAttr.set(c.attribute, values);
-			}
-			values.add(c.value);
-		}
-	}
-	result = result.filter((c) => {
-		if (!("attribute" in c) || !c.negated || c.value === void 0) return true;
-		if (negatedBooleanAttrs.has(c.attribute)) return false;
-		if ((c.operator ?? "=") !== "=") return true;
-		const positiveValues = positiveExactValuesByAttr.get(c.attribute);
-		if (positiveValues !== void 0 && positiveValues.size === 1 && !positiveValues.has(c.value)) return false;
-		return true;
+	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;
+		return !isSubsumedNegatedModifier(c, facts);
 	});
-	return result;
 }
 /**
 * Check for modifier contradiction: same attribute with opposite negation
@@ -459,10 +579,32 @@ function hasSelectorConditionContradiction(conditions) {
 * with opposite negation. E.g. :not([data-hovered] *) and :is([data-hovered] *)
 * in the same variant is impossible.
 */
+function getBranchesKey(branches) {
+	if (branches.length === 1) {
+		const b = branches[0];
+		if (b.length === 1) return getSelectorConditionKey(b[0]);
+		return b.map(getSelectorConditionKey).sort().join("+");
+	}
+	return branches.map((b) => b.map(getSelectorConditionKey).sort().join("+")).sort().join(",");
+}
 function hasParentGroupContradiction(groups) {
 	const byBaseKey = /* @__PURE__ */ new Map();
 	for (const g of groups) {
-		const baseKey = `${g.direct ? ">" : ""}(${g.conditions.map(getSelectorConditionKey).sort().join(",")})`;
+		const baseKey = `${g.direct ? ">" : ""}(${getBranchesKey(g.branches)})`;
+		const existing = byBaseKey.get(baseKey);
+		if (existing !== void 0 && existing !== !g.negated) return true;
+		byBaseKey.set(baseKey, !g.negated);
+	}
+	return false;
+}
+/**
+* Check for selector group contradiction: same branches with opposite negation.
+* E.g. :is([data-a]) and :not([data-a]) in the same variant is impossible.
+*/
+function hasSelectorGroupContradiction(groups) {
+	const byBaseKey = /* @__PURE__ */ new Map();
+	for (const g of groups) {
+		const baseKey = getBranchesKey(g.branches);
 		const existing = byBaseKey.get(baseKey);
 		if (existing !== void 0 && existing !== !g.negated) return true;
 		byBaseKey.set(baseKey, !g.negated);
@@ -476,15 +618,17 @@ function hasParentGroupContradiction(groups) {
 function mergeVariants(a, b) {
 	const mergedMedia = dedupeMediaConditions([...a.mediaConditions, ...b.mediaConditions]);
 	if (hasMediaContradiction(mergedMedia)) return null;
-	const mergedRoots = dedupeSelectorConditions([...a.rootConditions, ...b.rootConditions]);
-	if (hasSelectorConditionContradiction(mergedRoots)) return null;
+	const mergedRootGroups = optimizeGroups([...a.rootGroups, ...b.rootGroups]);
+	if (hasSelectorGroupContradiction(mergedRootGroups)) return null;
 	const mergedModifiers = dedupeSelectorConditions([...a.modifierConditions, ...b.modifierConditions]);
 	const mergedPseudos = dedupeSelectorConditions([...a.pseudoConditions, ...b.pseudoConditions]);
 	if (hasSelectorConditionContradiction([...mergedModifiers, ...mergedPseudos])) return null;
+	const mergedSelectorGroups = optimizeGroups([...a.selectorGroups, ...b.selectorGroups]);
+	if (hasSelectorGroupContradiction(mergedSelectorGroups)) return null;
 	const mergedParentGroups = [...a.parentGroups, ...b.parentGroups];
 	if (hasParentGroupContradiction(mergedParentGroups)) return null;
-	const mergedOwn = dedupeSelectorConditions([...a.ownConditions, ...b.ownConditions]);
-	if (hasSelectorConditionContradiction(mergedOwn)) return null;
+	const mergedOwnGroups = optimizeGroups([...a.ownGroups, ...b.ownGroups]);
+	if (hasSelectorGroupContradiction(mergedOwnGroups)) return null;
 	const mergedContainers = dedupeContainerConditions([...a.containerConditions, ...b.containerConditions]);
 	if (hasContainerStyleContradiction(mergedContainers)) return null;
 	const mergedSupports = dedupeSupportsConditions([...a.supportsConditions, ...b.supportsConditions]);
@@ -492,11 +636,12 @@ function mergeVariants(a, b) {
 	return {
 		modifierConditions: mergedModifiers,
 		pseudoConditions: mergedPseudos,
-		ownConditions: mergedOwn,
+		selectorGroups: mergedSelectorGroups,
+		ownGroups: mergedOwnGroups,
 		mediaConditions: mergedMedia,
 		containerConditions: mergedContainers,
 		supportsConditions: mergedSupports,
-		rootConditions: mergedRoots,
+		rootGroups: mergedRootGroups,
 		parentGroups: mergedParentGroups,
 		startingStyle: a.startingStyle || b.startingStyle
 	};
@@ -627,28 +772,45 @@ const variantKeyCache = /* @__PURE__ */ new WeakMap();
 * Cached via WeakMap since variants are compared multiple times during
 * deduplication and sorting.
 */
-function getVariantKey(v) {
-	const cached = variantKeyCache.get(v);
-	if (cached !== void 0) return cached;
-	const modifierKey = v.modifierConditions.map(getModifierKey).sort().join("|");
-	const pseudoKey = v.pseudoConditions.map(getPseudoKey).sort().join("|");
-	const ownKey = v.ownConditions.map(getSelectorConditionKey).sort().join("|");
-	const containerKey = v.containerConditions.map((c) => `${c.name ?? ""}:${c.negated ? "!" : ""}${c.condition}`).sort().join("|");
-	const key = [
-		modifierKey,
-		pseudoKey,
-		ownKey,
+function getSelectorGroupKey(g) {
+	return `${g.negated ? "!" : ""}(${getBranchesKey(g.branches)})`;
+}
+/**
+* Get a context key for a variant — everything except flat modifier/pseudo
+* conditions. Variants with the same context key can be merged into an
+* :is() group. Also used by getVariantKey as the shared non-selector portion.
+*/
+function getVariantContextKey(v) {
+	return [
 		v.mediaConditions.map((c) => `${c.subtype}:${c.negated ? "!" : ""}${c.condition}`).sort().join("|"),
-		containerKey,
+		v.containerConditions.map((c) => `${c.name ?? ""}:${c.negated ? "!" : ""}${c.condition}`).sort().join("|"),
 		v.supportsConditions.map((c) => `${c.subtype}:${c.negated ? "!" : ""}${c.condition}`).sort().join("|"),
-		v.rootConditions.map(getSelectorConditionKey).sort().join("|"),
+		v.rootGroups.map(getSelectorGroupKey).sort().join("|"),
 		v.parentGroups.map(getParentGroupKey).sort().join("|"),
+		v.ownGroups.map(getSelectorGroupKey).sort().join("|"),
+		v.selectorGroups.map(getSelectorGroupKey).sort().join("|"),
 		v.startingStyle ? "1" : "0"
 	].join("###");
+}
+function getVariantKey(v) {
+	const cached = variantKeyCache.get(v);
+	if (cached !== void 0) return cached;
+	const modifierKey = v.modifierConditions.map(getModifierKey).sort().join("|");
+	const pseudoKey = v.pseudoConditions.map(getPseudoKey).sort().join("|");
+	const key = modifierKey + "###" + pseudoKey + "###" + getVariantContextKey(v);
 	variantKeyCache.set(v, key);
 	return key;
 }
 /**
+* Total number of leaf conditions in a variant (for superset / dedup comparisons).
+*/
+function groupConditionCount(groups) {
+	return groups.reduce((sum, g) => sum + g.branches.reduce((s, b) => s + b.length, 0), 0);
+}
+function variantConditionCount(v) {
+	return v.modifierConditions.length + v.pseudoConditions.length + groupConditionCount(v.selectorGroups) + groupConditionCount(v.ownGroups) + v.mediaConditions.length + v.containerConditions.length + v.supportsConditions.length + groupConditionCount(v.rootGroups) + groupConditionCount(v.parentGroups);
+}
+/**
 * Check if variant A is a superset of variant B (A is more restrictive)
 *
 * If A has all of B's conditions plus more, then A is redundant
@@ -661,16 +823,16 @@ function getVariantKey(v) {
 */
 function isVariantSuperset(a, b) {
 	if (a.startingStyle !== b.startingStyle) return false;
-	if (!isSelectorConditionsSuperset(a.rootConditions, b.rootConditions)) return false;
+	if (!isSelectorGroupsSuperset(a.rootGroups, b.rootGroups)) return false;
 	if (!isMediaConditionsSuperset(a.mediaConditions, b.mediaConditions)) return false;
 	if (!isContainerConditionsSuperset(a.containerConditions, b.containerConditions)) return false;
 	if (!isSupportsConditionsSuperset(a.supportsConditions, b.supportsConditions)) return false;
 	if (!isModifierConditionsSuperset(a.modifierConditions, b.modifierConditions)) return false;
 	if (!isPseudoConditionsSuperset(a.pseudoConditions, b.pseudoConditions)) return false;
-	if (!isSelectorConditionsSuperset(a.ownConditions, b.ownConditions)) return false;
+	if (!isSelectorGroupsSuperset(a.selectorGroups, b.selectorGroups)) return false;
+	if (!isSelectorGroupsSuperset(a.ownGroups, b.ownGroups)) return false;
 	if (!isParentGroupsSuperset(a.parentGroups, b.parentGroups)) return false;
-	const parentConditionCount = (groups) => groups.reduce((sum, g) => sum + g.conditions.length, 0);
-	return a.mediaConditions.length + a.containerConditions.length + a.supportsConditions.length + a.modifierConditions.length + a.pseudoConditions.length + a.rootConditions.length + parentConditionCount(a.parentGroups) + a.ownConditions.length > b.mediaConditions.length + b.containerConditions.length + b.supportsConditions.length + b.modifierConditions.length + b.pseudoConditions.length + b.rootConditions.length + parentConditionCount(b.parentGroups) + b.ownConditions.length;
+	return variantConditionCount(a) > variantConditionCount(b);
 }
 /**
 * Generic superset check: true if every item in B has a matching key in A.
@@ -694,8 +856,9 @@ function isModifierConditionsSuperset(a, b) {
 function isPseudoConditionsSuperset(a, b) {
 	return isConditionsSuperset(a, b, getPseudoKey);
 }
-function isSelectorConditionsSuperset(a, b) {
-	return isConditionsSuperset(a, b, getSelectorConditionKey);
+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.
@@ -706,7 +869,7 @@ function isParentGroupsSuperset(a, b) {
 	return isConditionsSuperset(a, b, getParentGroupKey);
 }
 function getParentGroupKey(g) {
-	return `${g.negated ? "!" : ""}${g.direct ? ">" : ""}(${g.conditions.map(getSelectorConditionKey).sort().join(",")})`;
+	return `${g.negated ? "!" : ""}${g.direct ? ">" : ""}(${getBranchesKey(g.branches)})`;
 }
 /**
 * Deduplicate variants
@@ -716,6 +879,7 @@ function getParentGroupKey(g) {
 * 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) {
@@ -725,7 +889,7 @@ function dedupeVariants(variants) {
 			result.push(v);
 		}
 	}
-	const variantConditionCount = (v) => v.modifierConditions.length + v.pseudoConditions.length + v.ownConditions.length + v.mediaConditions.length + v.containerConditions.length + v.supportsConditions.length + v.rootConditions.length + v.parentGroups.reduce((sum, g) => sum + g.conditions.length, 0);
+	if (result.length <= 1) return result;
 	result.sort((a, b) => variantConditionCount(a) - variantConditionCount(b));
 	const filtered = [];
 	for (const candidate of result) {
@@ -775,8 +939,8 @@ function andToCSS(children) {
 * Combine OR conditions into CSS
 *
 * OR in CSS means multiple selector variants (DNF).
-* Each variant becomes a separate selector in the comma-separated list,
-* or multiple CSS rules if they have different at-rules.
+* 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
@@ -799,6 +963,103 @@ function orToCSS(children) {
 	};
 }
 /**
+* 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
+	};
+	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
+	};
+}
+/**
 * Build at-rules array from a variant
 */
 function buildAtRulesFromVariant(variant) {
@@ -840,5 +1101,5 @@ function buildAtRulesFromVariant(variant) {
 }
 
 //#endregion
-export { buildAtRulesFromVariant, conditionToCSS, modifierToCSS, parentGroupsToCSS, pseudoToCSS, rootConditionsToCSS, selectorConditionToCSS };
+export { branchToCSS, buildAtRulesFromVariant, conditionToCSS, mergeVariantsIntoSelectorGroups, optimizeGroups, parentGroupsToCSS, rootGroupsToCSS, selectorGroupToCSS };
 //# sourceMappingURL=materialize.js.map