@tenphi/tasty 2.0.2 → 2.0.4

package/dist/pipeline/materialize.js

@@ -1,1157 +0,0 @@
-import { Lru } from "../parser/lru.js";
-import { and, getConditionUniqueId, isCompoundCondition, not } from "./conditions.js";
-import { simplifyCondition } from "./simplify.js";
-//#region src/pipeline/materialize.ts
-/**
-* CSS Materialization
-*
-* 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
-*/
-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
-	};
-}
-/**
-* Convert a state condition to CSS
-*/
-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
-			};
-		}
-	}
-}
-/**
-* Convert modifier condition to parsed structure
-*/
-function modifierToParsed(state) {
-	return {
-		attribute: state.attribute,
-		value: state.value,
-		operator: state.operator,
-		negated: state.negated ?? false
-	};
-}
-/**
-* Convert parsed modifier to CSS selector string (for final output)
-*/
-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;
-}
-/**
-* Convert pseudo condition to parsed structure
-*/
-function pseudoToParsed(state) {
-	return {
-		pseudo: state.pseudo,
-		negated: state.negated ?? false
-	};
-}
-/**
-* 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 (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;
-}
-/**
-* Convert media condition to parsed structure(s)
-* Returns an array because negated ranges produce OR branches (two separate conditions)
-*/
-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);
-}
-/**
-* Convert dimension bounds to parsed media condition(s)
-* Uses CSS Media Queries Level 4 `not (condition)` syntax for negation.
-*/
-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
-	}];
-}
-/**
-* 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
-	};
-}
-/**
-* Convert dimension bounds to container query condition (single string)
-* Container queries support "not (condition)", so no need to invert manually
-*/
-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)";
-}
-/**
-* Convert supports condition to parsed structure
-*/
-function supportsToParsed(state) {
-	return {
-		subtype: state.subtype,
-		condition: state.condition,
-		negated: state.negated ?? false
-	};
-}
-/**
-* Collect all modifier and pseudo conditions from a variant as a flat array.
-*/
-function collectSelectorConditions(variant) {
-	return [...variant.modifierConditions, ...variant.pseudoConditions];
-}
-/**
-* 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(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
-	};
-}
-/**
-* 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
-	};
-	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
-	};
-}
-/**
-* 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 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;
-		return !isSubsumedNegatedModifier(c, facts);
-	});
-}
-/**
-* 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;
-}
-/**
-* Check for pseudo contradiction: same pseudo with opposite negation
-*/
-function hasPseudoContradiction(conditions) {
-	const byKey = /* @__PURE__ */ new Map();
-	for (const pseudo of conditions) {
-		const existing = byKey.get(pseudo.pseudo);
-		if (existing !== void 0 && existing !== !pseudo.negated) return true;
-		byKey.set(pseudo.pseudo, !pseudo.negated);
-	}
-	return false;
-}
-/**
-* Check for selector condition contradiction (modifier or pseudo with opposite negation).
-* Shared by root, parent, and own conditions.
-*/
-function hasSelectorConditionContradiction(conditions) {
-	const modifiers = [];
-	const pseudos = [];
-	for (const c of conditions) if ("attribute" in c) modifiers.push(c);
-	else pseudos.push(c);
-	return hasModifierContradiction(modifiers) || hasPseudoContradiction(pseudos);
-}
-/**
-* Check for parent group contradiction: same target (direct + 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 ? ">" : ""}(${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);
-	}
-	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 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 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]);
-	if (hasSupportsContradiction(mergedSupports)) return null;
-	return {
-		modifierConditions: mergedModifiers,
-		pseudoConditions: mergedPseudos,
-		selectorGroups: mergedSelectorGroups,
-		ownGroups: mergedOwnGroups,
-		mediaConditions: mergedMedia,
-		containerConditions: mergedContainers,
-		supportsConditions: mergedSupports,
-		rootGroups: mergedRootGroups,
-		parentGroups: mergedParentGroups,
-		startingStyle: a.startingStyle || b.startingStyle
-	};
-}
-/**
-* Generic deduplication by a key extraction function.
-* Preserves insertion order, keeping the first occurrence of each key.
-*/
-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 dedupeSupportsConditions(conditions) {
-	return dedupeByKey(conditions, (c) => `${c.subtype}|${c.condition}|${c.negated}`);
-}
-/**
-* Check if supports conditions contain contradictions
-* e.g., @supports(display: grid) AND NOT @supports(display: grid)
-*/
-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;
-}
-/**
-* 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.
-*/
-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;
-}
-/**
-* 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);
-	}
-	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;
-}
-const variantKeyCache = /* @__PURE__ */ new WeakMap();
-/**
-* Get a unique key for a variant (for deduplication).
-* Cached via WeakMap since variants are compared multiple times during
-* deduplication and sorting.
-*/
-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("|"),
-		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.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
-* because B already covers the same cases (and more).
-*
-* Example:
-*   A: :not([size=large]):not([size=medium]):not([size=small])
-*   B: :not([size=large])
-*   A is a superset of B, so A is redundant when B exists.
-*/
-function isVariantSuperset(a, b) {
-	if (a.startingStyle !== b.startingStyle) 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 (!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);
-}
-/**
-* Generic superset check: true if every item in B has a matching key in A.
-*/
-function isConditionsSuperset(a, b, getKey) {
-	const aKeys = new Set(a.map(getKey));
-	return b.every((c) => aKeys.has(getKey(c)));
-}
-function isMediaConditionsSuperset(a, b) {
-	return isConditionsSuperset(a, b, (c) => `${c.subtype}|${c.condition}|${c.negated}`);
-}
-function isContainerConditionsSuperset(a, b) {
-	return isConditionsSuperset(a, b, (c) => `${c.name ?? ""}|${c.condition}|${c.negated}`);
-}
-function isSupportsConditionsSuperset(a, b) {
-	return isConditionsSuperset(a, b, (c) => `${c.subtype}|${c.condition}|${c.negated}`);
-}
-function isModifierConditionsSuperset(a, b) {
-	return isConditionsSuperset(a, b, getModifierKey);
-}
-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);
-}
-/**
-* 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.
-*/
-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
-	};
-	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) {
-	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.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
-export { branchToCSS, buildAtRulesFromVariant, conditionToCSS, mergeVariantsIntoSelectorGroups, optimizeGroups, parentGroupsToCSS, rootGroupsToCSS, selectorGroupToCSS };
-
-//# sourceMappingURL=materialize.js.map