@tenphi/tasty 0.12.0 → 0.13.1

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));
@@ -264,31 +265,40 @@ 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
 	};
 }
@@ -327,29 +337,157 @@ function parentConditionToVariants(innerCondition, negated, direct) {
 	};
 }
 /**
-* 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 rootConditionsToCSS(roots) {
-	if (roots.length === 0) return void 0;
+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 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 ? " > *" : " *";
-		const selectorArgs = group.branches.map((branch) => {
-			let parts = "";
-			for (const cond of branch) parts += selectorConditionToCSS(cond);
-			return parts + combinator;
-		});
-		const wrapper = group.negated ? ":not" : ":is";
-		result += `${wrapper}(${selectorArgs.join(", ")})`;
+		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
@@ -478,21 +598,37 @@ function hasParentGroupContradiction(groups) {
 	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);
+	}
+	return false;
+}
+/**
 * Merge two selector variants (AND operation)
 * Deduplicates conditions and checks for contradictions
 */
 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]);
@@ -500,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
 	};
@@ -635,32 +772,43 @@ 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 + v.ownConditions.length + v.mediaConditions.length + v.containerConditions.length + v.supportsConditions.length + v.rootConditions.length + v.parentGroups.reduce((sum, g) => sum + g.branches.reduce((s, b) => s + b.length, 0), 0);
+	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)
@@ -675,13 +823,14 @@ function variantConditionCount(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;
 	return variantConditionCount(a) > variantConditionCount(b);
 }
@@ -707,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.
@@ -729,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) {
@@ -738,6 +889,7 @@ function dedupeVariants(variants) {
 			result.push(v);
 		}
 	}
+	if (result.length <= 1) return result;
 	result.sort((a, b) => variantConditionCount(a) - variantConditionCount(b));
 	const filtered = [];
 	for (const candidate of result) {
@@ -787,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
@@ -811,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) {
@@ -852,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