@tenphi/tasty 2.0.3 → 2.0.4

package/dist/pipeline/simplify.js

@@ -1,725 +0,0 @@
-import { Lru } from "../parser/lru.js";
-import { and, createOwnCondition, createParentCondition, createRootCondition, falseCondition, getConditionUniqueId, not, or, trueCondition } from "./conditions.js";
-//#region src/pipeline/simplify.ts
-/**
-* Condition Simplification Engine
-*
-* Simplifies condition trees by applying boolean algebra rules,
-* detecting contradictions, merging ranges, and deduplicating terms.
-*
-* This is critical for:
-* 1. Detecting invalid combinations (A & !A → FALSE)
-* 2. Reducing CSS output size
-* 3. Producing cleaner selectors
-*/
-const simplifyCache = new Lru(5e3);
-/**
-* Simplify a condition tree aggressively.
-*
-* This applies all possible simplification rules:
-* - Boolean algebra (identity, annihilator, idempotent, absorption)
-* - Contradiction detection (A & !A → FALSE)
-* - Tautology detection (A | !A → TRUE)
-* - Range intersection for numeric queries
-* - Attribute value conflict detection
-* - Deduplication and sorting
-*/
-function simplifyCondition(node) {
-	const key = getConditionUniqueId(node);
-	const cached = simplifyCache.get(key);
-	if (cached) return cached;
-	const result = simplifyInner(node);
-	simplifyCache.set(key, result);
-	return result;
-}
-function simplifyInner(node) {
-	if (node.kind === "true" || node.kind === "false") return node;
-	if (node.kind === "state") {
-		if ((node.type === "root" || node.type === "own" || node.type === "parent") && !node.negated) {
-			const simplifiedInner = simplifyInner(node.innerCondition);
-			if (simplifiedInner.kind === "false") return falseCondition();
-			if (simplifiedInner === node.innerCondition) return node;
-			if (node.type === "root") return createRootCondition(simplifiedInner, false, node.raw);
-			if (node.type === "own") return createOwnCondition(simplifiedInner, false, node.raw);
-			return createParentCondition(simplifiedInner, node.direct, false, node.raw);
-		}
-		return node;
-	}
-	if (node.kind === "compound") {
-		const simplifiedChildren = node.children.map((c) => simplifyInner(c));
-		if (node.operator === "AND") return simplifyAnd(simplifiedChildren);
-		else return simplifyOr(simplifiedChildren);
-	}
-	return node;
-}
-function simplifyAnd(children) {
-	let terms = [];
-	for (const child of children) {
-		if (child.kind === "false") return falseCondition();
-		if (child.kind === "true") continue;
-		if (child.kind === "compound" && child.operator === "AND") terms.push(...child.children);
-		else terms.push(child);
-	}
-	if (terms.length === 0) return trueCondition();
-	if (terms.length === 1) return terms[0];
-	if (hasContradiction(terms)) return falseCondition();
-	if (hasRangeContradiction(terms)) return falseCondition();
-	if (hasAttributeConflict(terms)) return falseCondition();
-	if (hasContainerStyleConflict(terms)) return falseCondition();
-	terms = removeImpliedNegations(terms);
-	terms = deduplicateTerms(terms);
-	terms = mergeRanges(terms);
-	terms = sortTerms(terms);
-	terms = applyAbsorptionAnd(terms);
-	terms = applyConsensusAnd(terms);
-	if (terms.length === 0) return trueCondition();
-	if (terms.length === 1) return terms[0];
-	return {
-		kind: "compound",
-		operator: "AND",
-		children: terms
-	};
-}
-function simplifyOr(children) {
-	let terms = [];
-	for (const child of children) {
-		if (child.kind === "true") return trueCondition();
-		if (child.kind === "false") continue;
-		if (child.kind === "compound" && child.operator === "OR") terms.push(...child.children);
-		else terms.push(child);
-	}
-	if (terms.length === 0) return falseCondition();
-	if (terms.length === 1) return terms[0];
-	if (hasTautology(terms)) return trueCondition();
-	terms = deduplicateTerms(terms);
-	terms = sortTerms(terms);
-	terms = applyAbsorptionOr(terms);
-	terms = applyComplementaryFactoring(terms);
-	if (terms.length === 0) return falseCondition();
-	if (terms.length === 1) return terms[0];
-	return {
-		kind: "compound",
-		operator: "OR",
-		children: terms
-	};
-}
-/**
-* Check if any pair of terms has complementary negation (A and !A).
-* Used for both contradiction detection (in AND) and tautology detection (in OR),
-* since the underlying check is identical: the context determines the semantics.
-*/
-function hasComplementaryPair(terms) {
-	const uniqueIds = /* @__PURE__ */ new Set();
-	for (const term of terms) {
-		if (term.kind !== "state") continue;
-		const id = term.uniqueId;
-		const negatedId = term.negated ? id.slice(1) : `!${id}`;
-		if (uniqueIds.has(negatedId)) return true;
-		uniqueIds.add(id);
-	}
-	return false;
-}
-const hasContradiction = hasComplementaryPair;
-const hasTautology = hasComplementaryPair;
-/**
-* Check for range contradictions in media/container queries
-* e.g., @media(w < 400px) & @media(w > 800px) → FALSE
-*
-* Also handles negated conditions:
-* - Single-bound negations are inverted (not (w < 600px) → w >= 600px)
-* - Range negations create excluded ranges that are checked against positive bounds
-*/
-function hasRangeContradiction(terms) {
-	const mediaByDim = /* @__PURE__ */ new Map();
-	const containerByDim = /* @__PURE__ */ new Map();
-	for (const term of terms) {
-		if (term.kind !== "state") continue;
-		if (term.type === "media" && term.subtype === "dimension") {
-			const key = term.dimension || "width";
-			if (!mediaByDim.has(key)) mediaByDim.set(key, {
-				positive: [],
-				negated: []
-			});
-			const group = mediaByDim.get(key);
-			if (term.negated) group.negated.push(term);
-			else group.positive.push(term);
-		}
-		if (term.type === "container" && term.subtype === "dimension") {
-			const key = `${term.containerName || "_"}:${term.dimension || "width"}`;
-			if (!containerByDim.has(key)) containerByDim.set(key, {
-				positive: [],
-				negated: []
-			});
-			const group = containerByDim.get(key);
-			if (term.negated) group.negated.push(term);
-			else group.positive.push(term);
-		}
-	}
-	for (const group of mediaByDim.values()) if (rangesAreImpossibleWithNegations(group.positive, group.negated)) return true;
-	for (const group of containerByDim.values()) if (rangesAreImpossibleWithNegations(group.positive, group.negated)) return true;
-	return false;
-}
-/**
-* Check if conditions are impossible, including negated conditions.
-*
-* For negated single-bound conditions:
-*   not (w < 600px) → w >= 600px (inverted to lower bound)
-*   not (w >= 800px) → w < 800px (inverted to upper bound)
-*
-* For negated range conditions:
-*   not (400px <= w < 800px) → excludes [400, 800)
-*   If the effective bounds fall entirely within an excluded range, it's impossible.
-*/
-function rangesAreImpossibleWithNegations(positive, negated) {
-	const bounds = computeEffectiveBounds(positive);
-	const excludedRanges = [];
-	for (const cond of negated) {
-		const hasLower = cond.lowerBound?.valueNumeric != null;
-		const hasUpper = cond.upperBound?.valueNumeric != null;
-		if (hasLower && hasUpper) excludedRanges.push({
-			lower: cond.lowerBound.valueNumeric,
-			lowerInclusive: cond.lowerBound.inclusive,
-			upper: cond.upperBound.valueNumeric,
-			upperInclusive: cond.upperBound.inclusive
-		});
-		else if (hasUpper) {
-			const value = cond.upperBound.valueNumeric;
-			const inclusive = !cond.upperBound.inclusive;
-			if (bounds.lowerBound === null || value > bounds.lowerBound) {
-				bounds.lowerBound = value;
-				bounds.lowerInclusive = inclusive;
-			} else if (value === bounds.lowerBound && !inclusive) bounds.lowerInclusive = false;
-		} else if (hasLower) {
-			const value = cond.lowerBound.valueNumeric;
-			const inclusive = !cond.lowerBound.inclusive;
-			if (bounds.upperBound === null || value < bounds.upperBound) {
-				bounds.upperBound = value;
-				bounds.upperInclusive = inclusive;
-			} else if (value === bounds.upperBound && !inclusive) bounds.upperInclusive = false;
-		}
-	}
-	if (bounds.lowerBound !== null && bounds.upperBound !== null) {
-		if (bounds.lowerBound > bounds.upperBound) return true;
-		if (bounds.lowerBound === bounds.upperBound && (!bounds.lowerInclusive || !bounds.upperInclusive)) return true;
-	}
-	if (bounds.lowerBound !== null && bounds.upperBound !== null && excludedRanges.length > 0) {
-		for (const excluded of excludedRanges) if (boundsWithinExcludedRange(bounds, excluded)) return true;
-	}
-	return false;
-}
-/**
-* Compute effective bounds from positive (non-negated) conditions
-*/
-function computeEffectiveBounds(conditions) {
-	let lowerBound = null;
-	let lowerInclusive = false;
-	let upperBound = null;
-	let upperInclusive = false;
-	for (const cond of conditions) {
-		if (cond.lowerBound?.valueNumeric != null) {
-			const value = cond.lowerBound.valueNumeric;
-			const inclusive = cond.lowerBound.inclusive;
-			if (lowerBound === null || value > lowerBound) {
-				lowerBound = value;
-				lowerInclusive = inclusive;
-			} else if (value === lowerBound && !inclusive) lowerInclusive = false;
-		}
-		if (cond.upperBound?.valueNumeric != null) {
-			const value = cond.upperBound.valueNumeric;
-			const inclusive = cond.upperBound.inclusive;
-			if (upperBound === null || value < upperBound) {
-				upperBound = value;
-				upperInclusive = inclusive;
-			} else if (value === upperBound && !inclusive) upperInclusive = false;
-		}
-	}
-	return {
-		lowerBound,
-		lowerInclusive,
-		upperBound,
-		upperInclusive
-	};
-}
-/**
-* Check if effective bounds fall entirely within an excluded range.
-*
-* For example:
-*   Effective: [400, 800)
-*   Excluded:  [400, 800)
-*   → bounds fall entirely within excluded range → impossible
-*/
-function boundsWithinExcludedRange(bounds, excluded) {
-	if (bounds.lowerBound === null || bounds.upperBound === null) return false;
-	let lowerOk = false;
-	if (bounds.lowerBound > excluded.lower) lowerOk = true;
-	else if (bounds.lowerBound === excluded.lower) lowerOk = excluded.lowerInclusive || !bounds.lowerInclusive;
-	let upperOk = false;
-	if (bounds.upperBound < excluded.upper) upperOk = true;
-	else if (bounds.upperBound === excluded.upper) upperOk = excluded.upperInclusive || !bounds.upperInclusive;
-	return lowerOk && upperOk;
-}
-/**
-* Check for attribute value conflicts
-* e.g., [data-theme="dark"] & [data-theme="light"] → FALSE
-* e.g., [data-theme="dark"] & ![data-theme] → FALSE
-*/
-/**
-* Generic value-conflict checker for grouped conditions.
-*
-* Groups terms by a key, splits into positive/negated, then checks:
-*   1. Multiple distinct positive values → conflict
-*   2. Positive value + negated existence (value === undefined) → conflict
-*   3. Positive value + negated same value → conflict
-*/
-function hasGroupedValueConflict(terms, match, groupKey, getValue) {
-	const groups = /* @__PURE__ */ new Map();
-	for (const term of terms) {
-		const matched = match(term);
-		if (!matched) continue;
-		const key = groupKey(matched);
-		let group = groups.get(key);
-		if (!group) {
-			group = {
-				positive: [],
-				negated: []
-			};
-			groups.set(key, group);
-		}
-		if (matched.negated) group.negated.push(matched);
-		else group.positive.push(matched);
-	}
-	for (const [, group] of groups) {
-		const positiveValues = group.positive.map(getValue).filter((v) => v !== void 0);
-		if (new Set(positiveValues).size > 1) return true;
-		const hasPositiveValue = positiveValues.length > 0;
-		const hasNegatedExistence = group.negated.some((t) => getValue(t) === void 0);
-		if (hasPositiveValue && hasNegatedExistence) return true;
-		for (const pos of group.positive) {
-			const posVal = getValue(pos);
-			if (posVal !== void 0) {
-				for (const neg of group.negated) if (getValue(neg) === posVal) return true;
-			}
-		}
-	}
-	return false;
-}
-function hasAttributeConflict(terms) {
-	if (hasGroupedValueConflict(terms, (t) => t.kind === "state" && t.type === "modifier" ? t : null, (t) => t.attribute, (t) => t.value)) return true;
-	if (hasNestedModifierConflict(terms, "root")) return true;
-	if (hasNestedModifierConflict(terms, "own")) return true;
-	return false;
-}
-/**
-* Collect modifier conditions inside non-negated state wrappers of `kind`
-* and check for the same value-conflict pattern as the top-level pass.
-*
-* Modifiers from multiple sibling wrappers are combined — both wrappers
-* scope to the same element (one :root, one own scope), so an attribute
-* conflict across wrappers is still impossible.
-*/
-function hasNestedModifierConflict(terms, wrapperType) {
-	const innerTerms = [];
-	for (const term of terms) if (term.kind === "state" && term.type === wrapperType && !term.negated) flattenAndIntoArray(term.innerCondition, innerTerms);
-	if (innerTerms.length < 2) return false;
-	return hasGroupedValueConflict(innerTerms, (t) => t.kind === "state" && t.type === "modifier" ? t : null, (t) => t.attribute, (t) => t.value);
-}
-/**
-* Flatten a top-level AND tree into a flat list of conjuncts. Non-AND nodes
-* are pushed as-is.
-*/
-function flattenAndIntoArray(node, into) {
-	if (node.kind === "compound" && node.operator === "AND") for (const child of node.children) flattenAndIntoArray(child, into);
-	else into.push(node);
-}
-function hasContainerStyleConflict(terms) {
-	return hasGroupedValueConflict(terms, (t) => t.kind === "state" && t.type === "container" && t.subtype === "style" ? t : null, (t) => `${t.containerName || "_"}:${t.property}`, (t) => t.propertyValue);
-}
-/**
-* Remove negations that are implied by positive terms.
-*
-* Key optimizations:
-* 1. style(--variant: danger) implies NOT style(--variant: success)
-*    → If we have style(--variant: danger) & not style(--variant: success),
-*      the negation is redundant and can be removed.
-*
-* 2. [data-theme="dark"] implies NOT [data-theme="light"]
-*    → Same logic for attribute selectors.
-*
-* This produces cleaner CSS:
-*   Before: @container style(--variant: danger) and (not style(--variant: success))
-*   After:  @container style(--variant: danger)
-*/
-/**
-* Collect positive values from terms and build a "is this negation implied?" check.
-*
-* A negation is implied (redundant) when a positive term for the same group
-* already pins a specific value, making "NOT other-value" obvious.
-* e.g. style(--variant: danger) implies NOT style(--variant: success).
-*/
-function buildImpliedNegationCheck(terms) {
-	const positiveValues = /* @__PURE__ */ new Map();
-	for (const term of terms) {
-		if (term.kind !== "state" || term.negated) continue;
-		if (term.type === "container" && term.subtype === "style") {
-			if (term.propertyValue !== void 0) positiveValues.set(`c:${term.containerName || "_"}:${term.property}`, term.propertyValue);
-		} else if (term.type === "modifier" && term.value !== void 0) positiveValues.set(`m:${term.attribute}`, term.value);
-	}
-	return (term) => {
-		if (term.kind !== "state" || !term.negated) return false;
-		if (term.type === "container" && term.subtype === "style") {
-			if (term.propertyValue === void 0) return false;
-			const pos = positiveValues.get(`c:${term.containerName || "_"}:${term.property}`);
-			return pos !== void 0 && term.propertyValue !== pos;
-		}
-		if (term.type === "modifier" && term.value !== void 0) {
-			const pos = positiveValues.get(`m:${term.attribute}`);
-			return pos !== void 0 && term.value !== pos;
-		}
-		return false;
-	};
-}
-function removeImpliedNegations(terms) {
-	const isImplied = buildImpliedNegationCheck(terms);
-	return terms.filter((t) => !isImplied(t));
-}
-function deduplicateTerms(terms) {
-	const seen = /* @__PURE__ */ new Set();
-	const result = [];
-	for (const term of terms) {
-		const id = getConditionUniqueId(term);
-		if (!seen.has(id)) {
-			seen.add(id);
-			result.push(term);
-		}
-	}
-	return result;
-}
-/**
-* Merge compatible range conditions
-* e.g., @media(w >= 400px) & @media(w <= 800px) → @media(400px <= w <= 800px)
-*/
-function mergeRanges(terms) {
-	const mediaByDim = /* @__PURE__ */ new Map();
-	const containerByDim = /* @__PURE__ */ new Map();
-	terms.forEach((term, index) => {
-		if (term.kind !== "state") return;
-		if (term.type === "media" && term.subtype === "dimension" && !term.negated) {
-			const key = term.dimension || "width";
-			if (!mediaByDim.has(key)) mediaByDim.set(key, {
-				conditions: [],
-				indices: []
-			});
-			const group = mediaByDim.get(key);
-			group.conditions.push(term);
-			group.indices.push(index);
-		}
-		if (term.type === "container" && term.subtype === "dimension" && !term.negated) {
-			const key = `${term.containerName || "_"}:${term.dimension || "width"}`;
-			if (!containerByDim.has(key)) containerByDim.set(key, {
-				conditions: [],
-				indices: []
-			});
-			const group = containerByDim.get(key);
-			group.conditions.push(term);
-			group.indices.push(index);
-		}
-	});
-	const indicesToRemove = /* @__PURE__ */ new Set();
-	const mergedTerms = [];
-	for (const [_dim, group] of mediaByDim) if (group.conditions.length > 1) {
-		const merged = mergeMediaRanges(group.conditions);
-		if (merged) {
-			group.indices.forEach((i) => indicesToRemove.add(i));
-			mergedTerms.push(merged);
-		}
-	}
-	for (const [, group] of containerByDim) if (group.conditions.length > 1) {
-		const merged = mergeContainerRanges(group.conditions);
-		if (merged) {
-			group.indices.forEach((i) => indicesToRemove.add(i));
-			mergedTerms.push(merged);
-		}
-	}
-	const result = [];
-	terms.forEach((term, index) => {
-		if (!indicesToRemove.has(index)) result.push(term);
-	});
-	result.push(...mergedTerms);
-	return result;
-}
-/**
-* Tighten bounds by picking the most restrictive lower and upper bounds
-* from a set of conditions that have lowerBound/upperBound fields.
-*/
-function tightenBounds(conditions) {
-	let lowerBound;
-	let upperBound;
-	for (const cond of conditions) {
-		if (cond.lowerBound) {
-			if (!lowerBound || (cond.lowerBound.valueNumeric ?? -Infinity) > (lowerBound.valueNumeric ?? -Infinity)) lowerBound = cond.lowerBound;
-		}
-		if (cond.upperBound) {
-			if (!upperBound || (cond.upperBound.valueNumeric ?? Infinity) < (upperBound.valueNumeric ?? Infinity)) upperBound = cond.upperBound;
-		}
-	}
-	return {
-		lowerBound,
-		upperBound
-	};
-}
-function appendBoundsToUniqueId(parts, lowerBound, upperBound) {
-	if (lowerBound) {
-		parts.push(lowerBound.inclusive ? ">=" : ">");
-		parts.push(lowerBound.value);
-	}
-	if (upperBound) {
-		parts.push(upperBound.inclusive ? "<=" : "<");
-		parts.push(upperBound.value);
-	}
-}
-function mergeDimensionRanges(conditions, idPrefix) {
-	if (conditions.length === 0) return null;
-	const { lowerBound, upperBound } = tightenBounds(conditions);
-	const base = conditions[0];
-	const parts = [...idPrefix];
-	appendBoundsToUniqueId(parts, lowerBound, upperBound);
-	return {
-		...base,
-		negated: false,
-		raw: buildMergedRaw(base.dimension || "width", lowerBound, upperBound),
-		uniqueId: parts.join(":"),
-		lowerBound,
-		upperBound
-	};
-}
-function mergeMediaRanges(conditions) {
-	return mergeDimensionRanges(conditions, [
-		"media",
-		"dim",
-		conditions[0]?.dimension ?? "width"
-	]);
-}
-function mergeContainerRanges(conditions) {
-	const base = conditions[0];
-	if (!base) return null;
-	return mergeDimensionRanges(conditions, [
-		"container",
-		"dim",
-		base.containerName || "_",
-		base.dimension ?? "width"
-	]);
-}
-function buildMergedRaw(dimension, lowerBound, upperBound) {
-	if (lowerBound && upperBound) {
-		const lowerOp = lowerBound.inclusive ? "<=" : "<";
-		const upperOp = upperBound.inclusive ? "<=" : "<";
-		return `@media(${lowerBound.value} ${lowerOp} ${dimension} ${upperOp} ${upperBound.value})`;
-	} else if (upperBound) return `@media(${dimension} ${upperBound.inclusive ? "<=" : "<"} ${upperBound.value})`;
-	else if (lowerBound) return `@media(${dimension} ${lowerBound.inclusive ? ">=" : ">"} ${lowerBound.value})`;
-	return "@media()";
-}
-/**
-* Apply complementary factoring: (A & B) | (A & !B) → A
-*
-* Finds pairs of AND compounds that share all children except one,
-* where the differing child is complementary (X vs !X).
-* Replaces the pair with the common terms.
-*
-* This is applied iteratively until no more reductions are possible,
-* since factoring can expose further simplification opportunities.
-*/
-function applyComplementaryFactoring(terms) {
-	let changed = true;
-	while (changed) {
-		changed = false;
-		for (let i = 0; i < terms.length; i++) {
-			const a = terms[i];
-			if (a.kind !== "compound" || a.operator !== "AND") continue;
-			for (let j = i + 1; j < terms.length; j++) {
-				const b = terms[j];
-				if (b.kind !== "compound" || b.operator !== "AND") continue;
-				const factored = tryFactorPair(a.children, b.children);
-				if (factored) {
-					const replacement = simplifyInner(factored);
-					terms = [
-						...terms.slice(0, i),
-						...terms.slice(i + 1, j),
-						...terms.slice(j + 1),
-						replacement
-					];
-					changed = true;
-					break;
-				}
-			}
-			if (changed) break;
-		}
-	}
-	return terms;
-}
-/**
-* Try to factor two AND children lists.
-*
-* Extracts the common children (by uniqueId). If the remaining
-* (non-common) parts of each side OR to TRUE, the common part alone
-* is sufficient: `(common & restA) | (common & restB) → common`
-* when `restA | restB → TRUE`.
-*
-* Also handles the simpler case where exactly one child is
-* complementary: `[A, B, C]` and `[A, !B, C]` → `AND(A, C)`.
-*/
-function tryFactorPair(aChildren, bChildren) {
-	const aIds = aChildren.map((c) => getConditionUniqueId(c));
-	const bIds = bChildren.map((c) => getConditionUniqueId(c));
-	const bIdSet = new Set(bIds);
-	const aIdSet = new Set(aIds);
-	const commonIndicesA = [];
-	const restIndicesA = [];
-	for (let i = 0; i < aIds.length; i++) if (bIdSet.has(aIds[i])) commonIndicesA.push(i);
-	else restIndicesA.push(i);
-	const restIndicesB = [];
-	for (let i = 0; i < bIds.length; i++) if (!aIdSet.has(bIds[i])) restIndicesB.push(i);
-	if (commonIndicesA.length === 0) return null;
-	if (restIndicesA.length === 0 && restIndicesB.length === 0) return null;
-	const restA = restIndicesA.length === 0 ? trueCondition() : restIndicesA.length === 1 ? aChildren[restIndicesA[0]] : and(...restIndicesA.map((i) => aChildren[i]));
-	const restB = restIndicesB.length === 0 ? trueCondition() : restIndicesB.length === 1 ? bChildren[restIndicesB[0]] : and(...restIndicesB.map((i) => bChildren[i]));
-	if (simplifyInner({
-		kind: "compound",
-		operator: "OR",
-		children: [restA, restB]
-	}).kind !== "true") {
-		const simplifiedRestB = simplifyInner(restB);
-		if (getConditionUniqueId(simplifyInner(not(restA))) !== getConditionUniqueId(simplifiedRestB)) return null;
-	}
-	const common = commonIndicesA.map((i) => aChildren[i]);
-	if (common.length === 0) return trueCondition();
-	if (common.length === 1) return common[0];
-	return and(...common);
-}
-function sortTerms(terms) {
-	const withIds = terms.map((t) => [getConditionUniqueId(t), t]);
-	withIds.sort((a, b) => a[0].localeCompare(b[0]));
-	return withIds.map(([, t]) => t);
-}
-/**
-* Apply the absorption law: removes compound terms that are absorbed by
-* another term already present (simple or compound).
-*
-* For AND context: A & (A | B) → A  (absorbs OR compounds)
-* For OR  context: A | (A & B) → A  (absorbs AND compounds)
-*
-* After flattening, a compound A = OR(X, Y) becomes [X, Y, ...] in the
-* outer OR. A child AND(A, B) = AND(OR(X, Y), B) still references the
-* original un-flattened compound. We reconstruct possible compound
-* absorbers from the flattened terms so absorption works across nesting.
-*/
-function applyAbsorption(terms, absorbedOperator) {
-	const absorberIds = /* @__PURE__ */ new Set();
-	for (const term of terms) absorberIds.add(getConditionUniqueId(term));
-	let changed = true;
-	while (changed) {
-		changed = false;
-		for (const term of terms) {
-			if (term.kind !== "compound" || term.operator !== absorbedOperator) continue;
-			for (const child of term.children) {
-				if (child.kind !== "compound") continue;
-				const childId = getConditionUniqueId(child);
-				if (absorberIds.has(childId)) continue;
-				if (child.children.every((c) => absorberIds.has(getConditionUniqueId(c)))) {
-					absorberIds.add(childId);
-					changed = true;
-				}
-			}
-		}
-	}
-	return terms.filter((term) => {
-		if (term.kind === "compound" && term.operator === absorbedOperator) {
-			for (const child of term.children) if (absorberIds.has(getConditionUniqueId(child))) return false;
-		}
-		return true;
-	});
-}
-function applyAbsorptionAnd(terms) {
-	return applyAbsorption(terms, "OR");
-}
-function applyAbsorptionOr(terms) {
-	return applyAbsorption(terms, "AND");
-}
-/**
-* Apply the consensus/resolution rule for AND:
-*   (A | B) & (A | !B) → A
-*
-* This is the dual of complementary factoring in OR context:
-*   (A & B) | (A & !B) → A
-*
-* Extracts common children from two OR terms. If the remaining
-* parts of each side AND to FALSE, the common part alone is
-* sufficient.
-*/
-function applyConsensusAnd(terms) {
-	let changed = true;
-	while (changed) {
-		changed = false;
-		for (let i = 0; i < terms.length; i++) {
-			const a = terms[i];
-			if (a.kind !== "compound" || a.operator !== "OR") continue;
-			for (let j = i + 1; j < terms.length; j++) {
-				const b = terms[j];
-				if (b.kind !== "compound" || b.operator !== "OR") continue;
-				const resolved = tryResolvePair(a.children, b.children);
-				if (resolved) {
-					const replacement = simplifyInner(resolved);
-					terms = [
-						...terms.slice(0, i),
-						...terms.slice(i + 1, j),
-						...terms.slice(j + 1),
-						replacement
-					];
-					changed = true;
-					break;
-				}
-			}
-			if (changed) break;
-		}
-	}
-	return terms;
-}
-/**
-* Try to resolve two OR children lists.
-*
-* Extracts common children (by uniqueId). If the remaining
-* (non-common) parts AND to FALSE, the common part alone
-* is sufficient: `(common | restA) & (common | restB) → common`
-* when `restA & restB → FALSE`.
-*/
-function tryResolvePair(aChildren, bChildren) {
-	const aIds = aChildren.map((c) => getConditionUniqueId(c));
-	const bIds = bChildren.map((c) => getConditionUniqueId(c));
-	const bIdSet = new Set(bIds);
-	const aIdSet = new Set(aIds);
-	const commonIndicesA = [];
-	const restIndicesA = [];
-	for (let i = 0; i < aIds.length; i++) if (bIdSet.has(aIds[i])) commonIndicesA.push(i);
-	else restIndicesA.push(i);
-	const restIndicesB = [];
-	for (let i = 0; i < bIds.length; i++) if (!aIdSet.has(bIds[i])) restIndicesB.push(i);
-	if (commonIndicesA.length === 0) return null;
-	if (restIndicesA.length === 0 && restIndicesB.length === 0) return null;
-	const restA = restIndicesA.length === 0 ? falseCondition() : restIndicesA.length === 1 ? aChildren[restIndicesA[0]] : or(...restIndicesA.map((i) => aChildren[i]));
-	const restB = restIndicesB.length === 0 ? falseCondition() : restIndicesB.length === 1 ? bChildren[restIndicesB[0]] : or(...restIndicesB.map((i) => bChildren[i]));
-	if (simplifyInner({
-		kind: "compound",
-		operator: "AND",
-		children: [restA, restB]
-	}).kind !== "false") {
-		const simplifiedRestB = simplifyInner(restB);
-		if (getConditionUniqueId(simplifyInner(not(restA))) !== getConditionUniqueId(simplifiedRestB)) return null;
-	}
-	const common = commonIndicesA.map((i) => aChildren[i]);
-	if (common.length === 0) return falseCondition();
-	if (common.length === 1) return common[0];
-	return or(...common);
-}
-//#endregion
-export { simplifyCondition };
-
-//# sourceMappingURL=simplify.js.map