fashionable 0.0.0 → 0.2.0

package/dist/shared/calc-Cih4o2r7.mjs

@@ -0,0 +1,1145 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { Pipeable, dual, invariant } from "../utils.mjs";
+import { i as equals$2, n as HashTypeId, o as hashNumber, r as combine, s as hashString, t as EqualTypeId } from "./equal-U9G5LhtL.mjs";
+import { a as specFidelity, i as specEquals, r as formatWith, t as DEFAULT_FORMAT } from "./format-B9jsmCER.mjs";
+import { i as toSpec, n as isPrecision$1, r as significant$1, t as decimals$1 } from "./precision.internal-0lv1nEpF.mjs";
+//#region src/internal/refs.ts
+/**
+* Runtime helpers for the unbound-reference sets carried by expression
+* values. The matching type-level machinery (the phantom `Refs` parameter
+* and `ApplyBindings`) lives with the public types in calc/calc.ts;
+* container modules extract refs from heterogeneous members with
+* conditionals over their member unions (`RuleSet.MemberRefs`).
+*/
+/** @internal */
+const unionRefs = (...sets) => {
+	const merged = /* @__PURE__ */ new Set();
+	for (const set of sets) for (const ref of set) merged.add(ref);
+	return merged;
+};
+/** @internal */
+const EMPTY_REFS = /* @__PURE__ */ new Set();
+//#endregion
+//#region src/calc/calc.internal.ts
+const CalcTypeId = Symbol.for("fashionable/calc");
+const isConstant = (node) => node._tag === "Constant";
+const constantNode = (value, precision, unit = void 0, kind = "number") => {
+	invariant(Number.isFinite(value), `Constant value must be a finite number, got ${value}`);
+	return {
+		_tag: "Constant",
+		value,
+		precision,
+		unit,
+		kind
+	};
+};
+/**
+* The shared (unit, kind) of a run of constants, or `undefined` when they mix
+* units and so cannot fold to a single constant (`10px + 5vw` stays symbolic).
+*/
+const commonDimension = (nodes) => {
+	const first = nodes[0];
+	if (first === void 0) return {
+		unit: void 0,
+		kind: "number"
+	};
+	for (const node of nodes) if (node.unit !== first.unit) return;
+	return {
+		unit: first.unit,
+		kind: first.kind
+	};
+};
+const bestPrecision = (nodes) => {
+	let best;
+	for (const node of nodes) if (specFidelity(node.precision) > specFidelity(best)) best = node.precision;
+	return best;
+};
+const addNode = (terms) => {
+	if (terms.every(isConstant)) {
+		const dim = commonDimension(terms);
+		if (dim !== void 0) return constantNode(terms.reduce((total, term) => total + term.value, 0), bestPrecision(terms), dim.unit, dim.kind);
+	}
+	return {
+		_tag: "Add",
+		terms
+	};
+};
+const subtractNode = (left, right) => {
+	if (isConstant(left) && isConstant(right) && left.unit === right.unit) return constantNode(left.value - right.value, bestPrecision([left, right]), left.unit, left.kind);
+	return {
+		_tag: "Subtract",
+		left,
+		right
+	};
+};
+const multiplyNode = (left, right) => {
+	if (isConstant(left) && isConstant(right)) {
+		if (left.unit === void 0) return constantNode(left.value * right.value, bestPrecision([left, right]), right.unit, right.kind);
+		if (right.unit === void 0) return constantNode(left.value * right.value, bestPrecision([left, right]), left.unit, left.kind);
+	}
+	return {
+		_tag: "Multiply",
+		left,
+		right
+	};
+};
+const divideNode = (left, right) => {
+	if (isConstant(left) && isConstant(right)) {
+		if (left.unit === right.unit) return constantNode(left.value / right.value, bestPrecision([left, right]));
+		if (right.unit === void 0) return constantNode(left.value / right.value, bestPrecision([left, right]), left.unit, left.kind);
+	}
+	return {
+		_tag: "Divide",
+		left,
+		right
+	};
+};
+const modNode = (left, right) => {
+	if (isConstant(left) && isConstant(right) && left.unit === right.unit) return constantNode(left.value - right.value * Math.floor(left.value / right.value), bestPrecision([left, right]), left.unit, left.kind);
+	return {
+		_tag: "Mod",
+		left,
+		right
+	};
+};
+const powNode = (base, exponent) => {
+	if (isConstant(base) && isConstant(exponent)) return constantNode(base.value ** exponent.value, bestPrecision([base, exponent]));
+	return {
+		_tag: "Pow",
+		base,
+		exponent
+	};
+};
+const signedPowNode = (base, exponent) => {
+	if (isConstant(base) && isConstant(exponent)) return constantNode(Math.abs(base.value) ** exponent.value * Math.sign(base.value), bestPrecision([base, exponent]));
+	return {
+		_tag: "SignedPow",
+		base,
+		exponent
+	};
+};
+const naryNode = (tag, compute) => (args) => {
+	if (args.every(isConstant)) {
+		const dim = commonDimension(args);
+		if (dim !== void 0) return constantNode(compute(args.map((arg) => arg.value)), bestPrecision(args), dim.unit, dim.kind);
+	}
+	return {
+		_tag: tag,
+		args
+	};
+};
+const minNode = naryNode("Min", (values) => Math.min(...values));
+const maxNode = naryNode("Max", (values) => Math.max(...values));
+const clampNode = (minimum, value, maximum) => {
+	if (isConstant(minimum) && isConstant(value) && isConstant(maximum)) {
+		const dim = commonDimension([
+			minimum,
+			value,
+			maximum
+		]);
+		if (dim !== void 0) return constantNode(Math.max(minimum.value, Math.min(value.value, maximum.value)), bestPrecision([
+			minimum,
+			value,
+			maximum
+		]), dim.unit, dim.kind);
+	}
+	return {
+		_tag: "Clamp",
+		minimum,
+		value,
+		maximum
+	};
+};
+/**
+* Per-function data for the unary math nodes — the single source of truth the
+* fold constructor, the evaluator, and the serializer all read:
+*
+* - `fn` both folds a constant operand and lowers the node under `solve`, so the
+*   construction-time and solve-time numerics can never drift.
+* - `css` is the math-function name serialization emits.
+* - `result` is the folded constant's dimension: `sign`/`sin`/`cos`/`tan`
+*   produce a plain `number`; `abs` preserves the operand's; `acos` returns
+*   radians, so its constant composes with `Angle.rad` terms and stays valid CSS
+*   with no plain-number-beside-angle hack.
+*/
+const UNARY = {
+	Abs: {
+		fn: Math.abs,
+		css: "abs",
+		result: "preserve"
+	},
+	Sign: {
+		fn: Math.sign,
+		css: "sign",
+		result: "number"
+	},
+	Sin: {
+		fn: Math.sin,
+		css: "sin",
+		result: "number"
+	},
+	Cos: {
+		fn: Math.cos,
+		css: "cos",
+		result: "number"
+	},
+	Tan: {
+		fn: Math.tan,
+		css: "tan",
+		result: "number"
+	},
+	Acos: {
+		fn: Math.acos,
+		css: "acos",
+		result: "rad"
+	}
+};
+const foldUnary = (tag, argument) => {
+	if (!isConstant(argument)) return {
+		_tag: tag,
+		argument
+	};
+	const { fn, result } = UNARY[tag];
+	const value = fn(argument.value);
+	switch (result) {
+		case "number": return constantNode(value, argument.precision);
+		case "preserve": return constantNode(value, argument.precision, argument.unit, argument.kind);
+		case "rad": return constantNode(value, argument.precision, "rad", "angle");
+	}
+};
+const atan2Node = (y, x) => {
+	if (isConstant(y) && isConstant(x) && y.unit === x.unit) return constantNode(Math.atan2(y.value, x.value), bestPrecision([y, x]), "rad", "angle");
+	return {
+		_tag: "Atan2",
+		y,
+		x
+	};
+};
+/** @internal */
+const substituteNode = (node, bindings) => {
+	switch (node._tag) {
+		case "Constant": return node;
+		case "Ref": return bindings[node.name] ?? node;
+		case "Ident": return node;
+		case "Add": return addNode(node.terms.map((term) => substituteNode(term, bindings)));
+		case "Subtract": return subtractNode(substituteNode(node.left, bindings), substituteNode(node.right, bindings));
+		case "Multiply": return multiplyNode(substituteNode(node.left, bindings), substituteNode(node.right, bindings));
+		case "Divide": return divideNode(substituteNode(node.left, bindings), substituteNode(node.right, bindings));
+		case "Mod": return modNode(substituteNode(node.left, bindings), substituteNode(node.right, bindings));
+		case "Pow": return powNode(substituteNode(node.base, bindings), substituteNode(node.exponent, bindings));
+		case "SignedPow": return signedPowNode(substituteNode(node.base, bindings), substituteNode(node.exponent, bindings));
+		case "Min": return minNode(node.args.map((arg) => substituteNode(arg, bindings)));
+		case "Max": return maxNode(node.args.map((arg) => substituteNode(arg, bindings)));
+		case "Clamp": return clampNode(substituteNode(node.minimum, bindings), substituteNode(node.value, bindings), substituteNode(node.maximum, bindings));
+		case "Abs":
+		case "Sign":
+		case "Sin":
+		case "Cos":
+		case "Tan":
+		case "Acos": return foldUnary(node._tag, substituteNode(node.argument, bindings));
+		case "Atan2": return atan2Node(substituteNode(node.y, bindings), substituteNode(node.x, bindings));
+	}
+};
+/**
+* The units that lower with no caller-supplied ratio: `px` is the pixel base
+* (`1`), a radian is already the numeric measure of its angle (`1`), and a
+* degree is a fixed `pi / 180` of one. Every other unit is context-dependent
+* and must appear in the solve context.
+*
+* @internal
+*/
+const DEFAULT_RATIOS = {
+	px: 1,
+	rad: 1,
+	deg: Math.PI / 180
+};
+/** @internal */
+const evaluateNode = (node, context) => {
+	switch (node._tag) {
+		case "Constant": {
+			if (node.unit === void 0) return node.value;
+			const ratio = context[node.unit] ?? DEFAULT_RATIOS[node.unit];
+			invariant(ratio !== void 0, `Cannot evaluate ${node.value}${node.unit}: no ratio for '${node.unit}' in the unit context`);
+			return node.value * ratio;
+		}
+		case "Ref": throw new Error(`Cannot evaluate non-constant reference: ${node.name}`);
+		case "Ident": {
+			const value = context[node.name];
+			invariant(value !== void 0, `Cannot evaluate '${node.name}': no value for it in the solve context`);
+			return value;
+		}
+		case "Add": return node.terms.reduce((total, term) => total + evaluateNode(term, context), 0);
+		case "Subtract": return evaluateNode(node.left, context) - evaluateNode(node.right, context);
+		case "Multiply": return evaluateNode(node.left, context) * evaluateNode(node.right, context);
+		case "Divide": return evaluateNode(node.left, context) / evaluateNode(node.right, context);
+		case "Mod": {
+			const dividend = evaluateNode(node.left, context);
+			const divisor = evaluateNode(node.right, context);
+			return dividend - divisor * Math.floor(dividend / divisor);
+		}
+		case "Pow": return evaluateNode(node.base, context) ** evaluateNode(node.exponent, context);
+		case "SignedPow": {
+			const base = evaluateNode(node.base, context);
+			return Math.abs(base) ** evaluateNode(node.exponent, context) * Math.sign(base);
+		}
+		case "Min": return Math.min(...node.args.map((arg) => evaluateNode(arg, context)));
+		case "Max": return Math.max(...node.args.map((arg) => evaluateNode(arg, context)));
+		case "Clamp": return Math.max(evaluateNode(node.minimum, context), Math.min(evaluateNode(node.value, context), evaluateNode(node.maximum, context)));
+		case "Abs":
+		case "Sign":
+		case "Sin":
+		case "Cos":
+		case "Tan":
+		case "Acos": return UNARY[node._tag].fn(evaluateNode(node.argument, context));
+		case "Atan2": return Math.atan2(evaluateNode(node.y, context), evaluateNode(node.x, context));
+	}
+};
+/**
+* True for the arithmetic forms that need a `calc()` wrapper when they
+* stand alone; function forms and leaves never do.
+*
+* @internal
+*/
+const needsCalcWrap = (node) => node._tag === "Add" || node._tag === "Subtract" || node._tag === "Multiply" || node._tag === "Divide" || node._tag === "SignedPow";
+const PI_TOLERANCE = 1e-10;
+const formatConstant = (node, insideMath, context) => {
+	if (node.unit === void 0 && insideMath && Math.abs(node.value - Math.PI) < PI_TOLERANCE) return "pi";
+	const text = formatWith(node.value, node.precision ?? context.precision);
+	return node.unit !== void 0 ? `${text}${node.unit}` : text;
+};
+const wrapOperand = (node, serialized) => node._tag === "Add" || node._tag === "Subtract" ? `(${serialized})` : serialized;
+const hasNegativeCoefficient = (node) => {
+	if (isConstant(node)) return node.value < 0;
+	if (node._tag === "Multiply" || node._tag === "Divide") return isConstant(node.left) && node.left.value < 0;
+	return false;
+};
+/**
+* Serializes the negation of a term whose leading coefficient is a
+* negative constant, so `a + (-k * x)` renders as `a - k * x`.
+*/
+const serializeNegated = (node, insideMath, context) => {
+	if (isConstant(node)) return formatConstant(constantNode(-node.value, node.precision, node.unit, node.kind), insideMath, context);
+	const binary = node;
+	const left = binary.left;
+	const negated = {
+		_tag: binary._tag,
+		left: constantNode(-left.value, left.precision, left.unit, left.kind),
+		right: binary.right
+	};
+	return serializeNode(negated, insideMath, context);
+};
+/** @internal */
+const serializeNode = (node, insideMath, context) => {
+	switch (node._tag) {
+		case "Constant": return formatConstant(node, insideMath, context);
+		case "Ref": return `var(--${node.name})`;
+		case "Ident": return node.name;
+		case "Add": {
+			let out = "";
+			for (const [index, term] of node.terms.entries()) if (index === 0) out = serializeNode(term, insideMath, context);
+			else if (hasNegativeCoefficient(term)) out += ` - ${serializeNegated(term, insideMath, context)}`;
+			else out += ` + ${serializeNode(term, insideMath, context)}`;
+			return out;
+		}
+		case "Subtract": {
+			const left = serializeNode(node.left, insideMath, context);
+			if (hasNegativeCoefficient(node.right)) return `${left} + ${serializeNegated(node.right, insideMath, context)}`;
+			return `${left} - ${serializeNode(node.right, insideMath, context)}`;
+		}
+		case "Multiply": return `${wrapOperand(node.left, serializeNode(node.left, insideMath, context))} * ${wrapOperand(node.right, serializeNode(node.right, insideMath, context))}`;
+		case "Divide": return `${wrapOperand(node.left, serializeNode(node.left, insideMath, context))} / ${wrapOperand(node.right, serializeNode(node.right, insideMath, context))}`;
+		case "Mod": return `mod(${serializeNode(node.left, true, context)}, ${serializeNode(node.right, true, context)})`;
+		case "Pow": return `pow(${serializeNode(node.base, true, context)}, ${serializeNode(node.exponent, true, context)})`;
+		case "SignedPow": {
+			const base = serializeNode(node.base, true, context);
+			return `pow(abs(${base}), ${serializeNode(node.exponent, true, context)}) * sign(${base})`;
+		}
+		case "Min": return `min(${node.args.map((arg) => serializeNode(arg, true, context)).join(", ")})`;
+		case "Max": return `max(${node.args.map((arg) => serializeNode(arg, true, context)).join(", ")})`;
+		case "Clamp": return `clamp(${serializeNode(node.minimum, true, context)}, ${serializeNode(node.value, true, context)}, ${serializeNode(node.maximum, true, context)})`;
+		case "Abs":
+		case "Sign":
+		case "Sin":
+		case "Cos":
+		case "Tan":
+		case "Acos": return `${UNARY[node._tag].css}(${serializeNode(node.argument, true, context)})`;
+		case "Atan2": return `atan2(${serializeNode(node.y, true, context)}, ${serializeNode(node.x, true, context)})`;
+	}
+};
+/** @internal */
+const serializeTop = (node, precision) => {
+	const wrap = needsCalcWrap(node);
+	const body = serializeNode(node, wrap, { precision });
+	return wrap ? `calc(${body})` : body;
+};
+const nodeArrayEquals = (a, b) => a.length === b.length && a.every((node, index) => nodeEquals(node, b[index]));
+/** @internal */
+const nodeEquals = (a, b) => {
+	if (a === b) return true;
+	if (a._tag !== b._tag) return false;
+	switch (a._tag) {
+		case "Constant": {
+			const other = b;
+			return a.value === other.value && a.unit === other.unit && specEquals(a.precision, other.precision);
+		}
+		case "Ref": return a.name === b.name;
+		case "Ident": return a.name === b.name;
+		case "Add": return nodeArrayEquals(a.terms, b.terms);
+		case "Subtract":
+		case "Multiply":
+		case "Divide":
+		case "Mod": {
+			const other = b;
+			return nodeEquals(a.left, other.left) && nodeEquals(a.right, other.right);
+		}
+		case "Pow":
+		case "SignedPow": {
+			const other = b;
+			return nodeEquals(a.base, other.base) && nodeEquals(a.exponent, other.exponent);
+		}
+		case "Min":
+		case "Max": return nodeArrayEquals(a.args, b.args);
+		case "Clamp": {
+			const other = b;
+			return nodeEquals(a.minimum, other.minimum) && nodeEquals(a.value, other.value) && nodeEquals(a.maximum, other.maximum);
+		}
+		case "Abs":
+		case "Sign":
+		case "Sin":
+		case "Cos":
+		case "Tan":
+		case "Acos": return nodeEquals(a.argument, b.argument);
+		case "Atan2": {
+			const other = b;
+			return nodeEquals(a.y, other.y) && nodeEquals(a.x, other.x);
+		}
+	}
+};
+const hashNodeArray = (tag, nodes) => {
+	let h = hashString(tag);
+	for (const node of nodes) h = combine(h, nodeHash(node));
+	return h;
+};
+/** @internal */
+const nodeHash = (node) => {
+	switch (node._tag) {
+		case "Constant": {
+			const precision = node.precision === void 0 ? 0 : combine(hashString(node.precision.mode), node.precision.digits | 0);
+			const unit = node.unit === void 0 ? 0 : hashString(node.unit);
+			return combine(hashString("Constant"), combine(combine(hashNumber(node.value), precision), unit));
+		}
+		case "Ref": return combine(hashString("Ref"), hashString(node.name));
+		case "Ident": return combine(hashString("Ident"), hashString(node.name));
+		case "Add": return hashNodeArray("Add", node.terms);
+		case "Subtract":
+		case "Multiply":
+		case "Divide":
+		case "Mod": return hashNodeArray(node._tag, [node.left, node.right]);
+		case "Pow":
+		case "SignedPow": return hashNodeArray(node._tag, [node.base, node.exponent]);
+		case "Min":
+		case "Max": return hashNodeArray(node._tag, node.args);
+		case "Clamp": return hashNodeArray("Clamp", [
+			node.minimum,
+			node.value,
+			node.maximum
+		]);
+		case "Abs":
+		case "Sign":
+		case "Sin":
+		case "Cos":
+		case "Tan":
+		case "Acos": return hashNodeArray(node._tag, [node.argument]);
+		case "Atan2": return hashNodeArray("Atan2", [node.y, node.x]);
+	}
+};
+var CalcImpl = class extends Pipeable {
+	[CalcTypeId] = CalcTypeId;
+	node;
+	refSet;
+	#hash;
+	constructor(node, refSet) {
+		super();
+		this.node = node;
+		this.refSet = refSet;
+	}
+	[EqualTypeId](that) {
+		return isCalc$1(that) && nodeEquals(this.node, nodeOf(that));
+	}
+	[HashTypeId]() {
+		this.#hash ??= combine(hashString("fashionable/calc"), nodeHash(this.node));
+		return this.#hash;
+	}
+	get [Symbol.toStringTag]() {
+		return `Calc(${serializeTop(this.node, DEFAULT_FORMAT)})`;
+	}
+	get [Symbol.for("nodejs.util.inspect.custom")]() {
+		return this[Symbol.toStringTag];
+	}
+};
+/** @internal */
+const isCalc$1 = (u) => typeof u === "object" && u !== null && CalcTypeId in u;
+/** @internal */
+const nodeOf = (expr) => expr.node;
+/** @internal */
+const refsOf = (expr) => expr.refSet;
+const collectIdents = (node, into) => {
+	switch (node._tag) {
+		case "Ident":
+			into.add(node.name);
+			return;
+		case "Constant":
+		case "Ref": return;
+		case "Add":
+			for (const term of node.terms) collectIdents(term, into);
+			return;
+		case "Min":
+		case "Max":
+			for (const arg of node.args) collectIdents(arg, into);
+			return;
+		case "Subtract":
+		case "Multiply":
+		case "Divide":
+		case "Mod":
+			collectIdents(node.left, into);
+			collectIdents(node.right, into);
+			return;
+		case "Pow":
+		case "SignedPow":
+			collectIdents(node.base, into);
+			collectIdents(node.exponent, into);
+			return;
+		case "Clamp":
+			collectIdents(node.minimum, into);
+			collectIdents(node.value, into);
+			collectIdents(node.maximum, into);
+			return;
+		case "Abs":
+		case "Sign":
+		case "Sin":
+		case "Cos":
+		case "Tan":
+		case "Acos":
+			collectIdents(node.argument, into);
+			return;
+		case "Atan2":
+			collectIdents(node.y, into);
+			collectIdents(node.x, into);
+			return;
+	}
+};
+/** @internal */
+const identsOf = (node) => {
+	const set = /* @__PURE__ */ new Set();
+	collectIdents(node, set);
+	return set;
+};
+const makeCalc = (node, refSet) => new CalcImpl(node, refSet);
+/** @internal */
+const toCalc = (input) => typeof input === "number" ? of$1(input) : input;
+const mergeRefs = (exprs) => {
+	const merged = /* @__PURE__ */ new Set();
+	for (const expr of exprs) for (const name of refsOf(expr)) merged.add(name);
+	return merged;
+};
+/** @internal */
+function of$1(value, precision) {
+	return makeCalc(constantNode(value, precision === void 0 ? void 0 : toSpec(precision)), EMPTY_REFS);
+}
+/**
+* Builds a dimensioned constant. The `data` module's `Length`/`Angle`
+* constructors call this and cast the result to the precise leaf-branded type;
+* the calc core stays unit-agnostic, carrying `unit` and `kind` as given.
+*
+* @internal
+*/
+function dimension(value, unit, kind, precision) {
+	return makeCalc(constantNode(value, precision === void 0 ? void 0 : toSpec(precision), unit, kind), EMPTY_REFS);
+}
+const refCache = /* @__PURE__ */ new Map();
+/** @internal */
+function ref$1(name) {
+	const cached = refCache.get(name);
+	if (cached) return cached;
+	invariant(name.length > 0, "Reference name must be a non-empty string");
+	const expr = makeCalc({
+		_tag: "Ref",
+		name
+	}, /* @__PURE__ */ new Set([name]));
+	refCache.set(name, expr);
+	return expr;
+}
+/**
+* Builds a bare-identifier constant — a leaf serializing as `name`, carrying no
+* references. The `data` module's `Channel` keywords call this; the identifier
+* text is opaque to the calc core, resolved by whatever CSS context surrounds
+* it (a relative-color function today).
+*
+* @internal
+*/
+function ident(name) {
+	invariant(name.length > 0, "Identifier name must be a non-empty string");
+	return makeCalc({
+		_tag: "Ident",
+		name
+	}, EMPTY_REFS);
+}
+const liftNary = (construct) => (args) => {
+	const exprs = args.map(toCalc);
+	return makeCalc(construct(exprs.map(nodeOf)), mergeRefs(exprs));
+};
+const addImpl = liftNary(addNode);
+const minImpl = liftNary(minNode);
+const maxImpl = liftNary(maxNode);
+const naryCombinator = (impl) => ((...args) => impl(args));
+/** @internal */
+const add$1 = naryCombinator(addImpl);
+/** @internal */
+const min$1 = naryCombinator(minImpl);
+/** @internal */
+const max$1 = naryCombinator(maxImpl);
+const liftBinary = (construct) => (left, right) => {
+	const l = toCalc(left);
+	const r = toCalc(right);
+	return makeCalc(construct(nodeOf(l), nodeOf(r)), mergeRefs([l, r]));
+};
+const subtractImpl = liftBinary(subtractNode);
+const multiplyImpl = liftBinary(multiplyNode);
+const divideImpl = liftBinary(divideNode);
+const modImpl = liftBinary(modNode);
+const powImpl = liftBinary(powNode);
+const signedPowImpl = liftBinary(signedPowNode);
+const atan2Impl = liftBinary(atan2Node);
+/** @internal */
+function subtract$1(left, right) {
+	return subtractImpl(left, right);
+}
+/** @internal */
+function multiply$1(left, right) {
+	return multiplyImpl(left, right);
+}
+/** @internal */
+function mod$1(left, right) {
+	return modImpl(left, right);
+}
+/** @internal */
+function divide$1(left, right) {
+	return divideImpl(left, right);
+}
+/** @internal */
+function pow$1(base, exponent) {
+	return powImpl(base, exponent);
+}
+/** @internal */
+function signedPow$1(base, exponent) {
+	return signedPowImpl(base, exponent);
+}
+const liftUnary = (construct) => (argument) => {
+	const arg = toCalc(argument);
+	return makeCalc(construct(nodeOf(arg)), refsOf(arg));
+};
+const absImpl = liftUnary((argument) => foldUnary("Abs", argument));
+const signImpl = liftUnary((argument) => foldUnary("Sign", argument));
+const sinImpl = liftUnary((argument) => foldUnary("Sin", argument));
+const cosImpl = liftUnary((argument) => foldUnary("Cos", argument));
+const tanImpl = liftUnary((argument) => foldUnary("Tan", argument));
+const acosImpl = liftUnary((argument) => foldUnary("Acos", argument));
+/** @internal */
+function abs$1(argument) {
+	return absImpl(argument);
+}
+/** @internal */
+function sign$1(argument) {
+	return signImpl(argument);
+}
+/** @internal */
+function sin$1(argument) {
+	return sinImpl(argument);
+}
+/** @internal */
+function cos$1(argument) {
+	return cosImpl(argument);
+}
+/** @internal */
+function tan$1(argument) {
+	return tanImpl(argument);
+}
+/** @internal */
+function acos$1(argument) {
+	return acosImpl(argument);
+}
+/** @internal */
+function atan2$1(y, x) {
+	return atan2Impl(y, x);
+}
+/** @internal */
+function clamp$1(minimum, value, maximum) {
+	const lo = toCalc(minimum);
+	const mid = toCalc(value);
+	const hi = toCalc(maximum);
+	return makeCalc(clampNode(nodeOf(lo), nodeOf(mid), nodeOf(hi)), mergeRefs([
+		lo,
+		mid,
+		hi
+	]));
+}
+/** @internal */
+function lerp$1(a, b, t) {
+	return add$1(multiply$1(subtract$1(1, t), a), multiply$1(t, b));
+}
+/** @internal */
+const collectBindings = (refSet, bindings) => {
+	const nodeBindings = {};
+	const newRefs = new Set(refSet);
+	for (const [key, value] of Object.entries(bindings)) {
+		if (value === void 0 || !refSet.has(key)) continue;
+		const expr = toCalc(value);
+		nodeBindings[key] = nodeOf(expr);
+		newRefs.delete(key);
+		for (const name of refsOf(expr)) newRefs.add(name);
+	}
+	return {
+		nodeBindings,
+		refSet: newRefs
+	};
+};
+/** @internal */
+const bind$1 = dual(2, (expr, bindings) => {
+	const collected = collectBindings(refsOf(expr), bindings);
+	return makeCalc(substituteNode(nodeOf(expr), collected.nodeBindings), collected.refSet);
+});
+/** @internal */
+function solve$1(expr, bindings, context) {
+	let node = nodeOf(expr);
+	let remaining = refsOf(expr);
+	if (bindings !== void 0) {
+		const collected = collectBindings(remaining, bindings);
+		node = substituteNode(node, collected.nodeBindings);
+		remaining = collected.refSet;
+	}
+	invariant(remaining.size === 0, "Cannot convert expression to number: unbound references remain");
+	return evaluateNode(node, context ?? {});
+}
+/** @internal */
+function serialize$1(expr, options) {
+	let node = nodeOf(expr);
+	if (options?.bindings !== void 0) {
+		const collected = collectBindings(refsOf(expr), options.bindings);
+		node = substituteNode(node, collected.nodeBindings);
+	}
+	const precision = options?.precision === void 0 ? DEFAULT_FORMAT : toSpec(options.precision);
+	return serializeTop(node, precision);
+}
+/** @internal */
+function refs$1(expr) {
+	return refsOf(expr);
+}
+/** @internal */
+function channels$1(expr) {
+	return identsOf(nodeOf(expr));
+}
+/** @internal */
+const equals$1 = dual(2, (self, that) => equals$2(self, that));
+//#endregion
+//#region src/calc/calc.ts
+var calc_exports = /* @__PURE__ */ __exportAll({
+	abs: () => abs,
+	acos: () => acos,
+	add: () => add,
+	atan2: () => atan2,
+	bind: () => bind,
+	channels: () => channels,
+	clamp: () => clamp,
+	cos: () => cos,
+	divide: () => divide,
+	equals: () => equals,
+	isCalc: () => isCalc,
+	lerp: () => lerp,
+	max: () => max,
+	min: () => min,
+	mod: () => mod,
+	multiply: () => multiply,
+	of: () => of,
+	pow: () => pow,
+	ref: () => ref,
+	refs: () => refs,
+	serialize: () => serialize,
+	sign: () => sign,
+	signedPow: () => signedPow,
+	sin: () => sin,
+	solve: () => solve,
+	subtract: () => subtract,
+	tan: () => tan
+});
+/**
+* Checks if a value is a `Calc`.
+*
+* True only for values built by this module's constructors, which carry
+* the brand.
+*
+* @param u - The value to check.
+* @returns `true` if the value is a `Calc`, `false` otherwise.
+* @since 0.1.0
+*/
+const isCalc = isCalc$1;
+/**
+* Creates a constant expression, optionally annotated with a serialization
+* precision that overrides the context default wherever the constant lands
+* — including in constants produced by folding it with others (the
+* highest-fidelity operand annotation wins).
+*
+* Bare numbers passed to combinators become unannotated constants; `of`
+* exists to name a value or pin its precision.
+*
+* @param value - The constant value. Must be finite.
+* @param precision - Optional precision annotation.
+* @returns A constant `Calc<never>`.
+* @throws `Error` when `value` is not finite.
+* @example
+* ```ts
+* const k = Calc.of(0.8377580409572781, Precision.significant(10))
+* Calc.serialize(Calc.multiply(k, Calc.ref('t'))) // 'calc(0.837758041 * var(--t))'
+* ```
+* @since 0.1.0
+*/
+const of = of$1;
+/**
+* Creates a reference to an unbound name. References serialize as
+* `var(--name)` and are the channel through which expressions read CSS
+* custom properties; `bind` replaces them with values or other
+* expressions.
+*
+* Repeated calls with the same name return the same instance.
+*
+* @param name - The reference name, without the `--` prefix. Must be non-empty.
+* @returns A `Calc` with `name` as its one unbound reference.
+* @throws `Error` when `name` is empty.
+* @example
+* ```ts
+* Calc.serialize(Calc.ref('width')) // 'var(--width)'
+* ```
+* @since 0.1.0
+*/
+const ref = ref$1;
+/**
+* Adds expressions. Constant operands fold at construction.
+*
+* Serializes as `a + b + ...` inside a `calc()` wrapper; negative constant
+* terms (and products led by a negative constant) render subtractively:
+* `a + (-2)` serializes as `a - 2`.
+*
+* @param a - The first operand.
+* @param b - The second operand.
+* @returns The sum, with the operands' references unioned.
+* @example
+* ```ts
+* Calc.serialize(Calc.add(Calc.ref('x'), 10)) // 'calc(var(--x) + 10)'
+* ```
+* @since 0.1.0
+*/
+const add = add$1;
+/**
+* Subtracts `right` from `left`. Constant operands fold at construction.
+*
+* @param left - The minuend.
+* @param right - The subtrahend.
+* @returns The difference, with the operands' references unioned.
+* @since 0.1.0
+*/
+const subtract = subtract$1;
+/**
+* The CSS `mod()` of `dividend` and `divisor` — the remainder that takes the
+* sign of the divisor (the floored modulo), so `mod(x, 360)` lands in
+* `[0, 360)` for a positive divisor. Same-kind operands, as `subtract`;
+* constant operands fold at construction.
+*
+* @param dividend - The value to reduce.
+* @param divisor - The modulus, sharing `dividend`'s kind.
+* @returns The modulo, with the operands' references unioned.
+* @example
+* ```ts
+* Calc.serialize(Calc.mod(Calc.ref('h'), 360)) // 'mod(var(--h), 360)'
+* ```
+* @since 0.2.0
+*/
+const mod = mod$1;
+/**
+* Multiplies expressions. Constant operands fold at construction.
+*
+* Addition and subtraction operands are parenthesized when serialized
+* under a product: `(a + b) * c`.
+*
+* @param left - The first factor.
+* @param right - The second factor.
+* @returns The product, with the operands' references unioned.
+* @since 0.1.0
+*/
+const multiply = multiply$1;
+/**
+* Divides `left` by `right`. Constant operands fold at construction.
+*
+* @param left - The dividend.
+* @param right - The divisor.
+* @returns The quotient, with the operands' references unioned.
+* @since 0.1.0
+*/
+const divide = divide$1;
+/**
+* Raises `base` to `exponent`. Serializes as the CSS `pow()` function.
+*
+* @param base - The base.
+* @param exponent - The exponent.
+* @returns The power, with the operands' references unioned.
+* @since 0.1.0
+*/
+const pow = pow$1;
+/**
+* Sign-preserving power: `abs(base) ^ exponent * sign(base)`. Unlike
+* `pow`, well-defined for negative bases with fractional exponents.
+* Serializes as `pow(abs(base), exponent) * sign(base)`.
+*
+* @param base - The base.
+* @param exponent - The exponent.
+* @returns The signed power, with the operands' references unioned.
+* @since 0.1.0
+*/
+const signedPow = signedPow$1;
+/**
+* The minimum of the operands. Serializes as the CSS `min()` function.
+*
+* @param a - The first operand.
+* @param b - The second operand.
+* @returns The minimum, with the operands' references unioned.
+* @since 0.1.0
+*/
+const min = min$1;
+/**
+* The maximum of the operands. Serializes as the CSS `max()` function.
+*
+* @param a - The first operand.
+* @param b - The second operand.
+* @returns The maximum, with the operands' references unioned.
+* @since 0.1.0
+*/
+const max = max$1;
+/**
+* Clamps `value` between `minimum` and `maximum`. Serializes as the CSS
+* `clamp()` function, with the CSS argument order `(min, value, max)`.
+*
+* @param minimum - The lower bound.
+* @param value - The value to clamp.
+* @param maximum - The upper bound.
+* @returns The clamped expression, with the operands' references unioned.
+* @example
+* ```ts
+* Calc.serialize(Calc.clamp(-1, Calc.ref('u'), 1)) // 'clamp(-1, var(--u), 1)'
+* ```
+* @since 0.1.0
+*/
+const clamp = clamp$1;
+/**
+* Linear interpolation from `a` to `b` by `t`. This is sugar, not a node:
+* it desugars to `(1 - t) * a + t * b`, and serializes as that expanded
+* form.
+*
+* @param a - The value at `t = 0`.
+* @param b - The value at `t = 1`.
+* @param t - The interpolation parameter.
+* @returns The interpolated expression, with the operands' references unioned.
+* @since 0.1.0
+*/
+const lerp = lerp$1;
+/**
+* The absolute value. Serializes as the CSS `abs()` function.
+*
+* @param argument - The operand.
+* @returns The absolute value expression.
+* @since 0.1.0
+*/
+const abs = abs$1;
+/**
+* The sign (`-1`, `0`, or `1`). Serializes as the CSS `sign()` function.
+*
+* @param argument - The operand.
+* @returns The sign expression.
+* @since 0.1.0
+*/
+const sign = sign$1;
+/**
+* The sine of its argument. Serializes as the CSS `sin()` function, which
+* accepts an `<angle>` or a plain number treated as radians — so this takes
+* either an angle-kind expression or a number, and returns a number.
+*
+* @param argument - An angle, or a plain number in radians.
+* @returns The sine, a `<number>`, carrying the argument's units.
+* @since 0.1.0
+*/
+const sin = sin$1;
+/**
+* The cosine of its argument. Serializes as the CSS `cos()` function, which
+* accepts an `<angle>` or a plain number treated as radians — so this takes
+* either an angle-kind expression or a number, and returns a number.
+*
+* @param argument - An angle, or a plain number in radians.
+* @returns The cosine, a `<number>`, carrying the argument's units.
+* @since 0.1.0
+*/
+const cos = cos$1;
+/**
+* The tangent of its argument. Serializes as the CSS `tan()` function, which
+* accepts an `<angle>` or a plain number treated as radians. Paired with
+* `atan2`, `tan(atan2(a, b))` divides two same-kind dimensions to a `<number>` —
+* the length ratio that works where `a / b` does not, since Firefox does not
+* yet support `<length> / <length>` in `calc()`.
+*
+* @param argument - An angle, or a plain number in radians.
+* @returns The tangent, a `<number>`, carrying the argument's units.
+* @since 0.2.0
+*/
+const tan = tan$1;
+/**
+* The arccosine of a value in `[-1, 1]`, an `<angle>` in radians (CSS's
+* `acos()` returns an `<angle>`). Solving evaluates `Math.acos`, in radians.
+*
+* Because the result is angle-kind, it composes only with other angles: divide
+* or scale it by a number, and add or subtract an `Angle.rad(...)` phase. A
+* plain number added to it is a type error — supply the phase as an angle.
+*
+* @param argument - The cosine value, in `[-1, 1]`.
+* @returns The arccosine, an `<angle>`, carrying the argument's units.
+* @example
+* ```ts
+* const phase = Angle.rad(2.0943951)
+* Calc.serialize(Calc.cos(Calc.subtract(Calc.divide(Calc.acos(Calc.ref('u')), 3), phase)))
+* // 'cos(acos(var(--u)) / 3 - 2.0944rad)'
+* ```
+* @since 0.1.0
+*/
+const acos = acos$1;
+/**
+* The angle, in radians, of the vector from the origin to `(x, y)` — CSS's
+* `atan2()`, which returns an `<angle>`. The operands must share a kind (two
+* numbers, two lengths, two angles); their units cancel in the ratio, so
+* `tan(atan2(a, b))` recovers `a / b` as a `<number>` and is the portable way to
+* divide two `<length>`s.
+*
+* @param y - The vertical component.
+* @param x - The horizontal component, sharing `y`'s kind.
+* @returns The angle, an `<angle>`, with the operands' units unioned.
+* @example
+* ```ts
+* const ratio = Calc.tan(Calc.atan2(Calc.subtract(Length.vw(100), Length.px(320)), Length.px(160)))
+* Calc.serialize(ratio) // 'tan(atan2(100vw - 320px, 160px))'
+* ```
+* @since 0.2.0
+*/
+const atan2 = atan2$1;
+const bind = bind$1;
+const solve = solve$1;
+/**
+* Renders an expression as CSS text. Arithmetic gets a `calc()` wrapper;
+* function forms (`min`, `clamp`, `sin`, ...) and leaves stand alone.
+* References render as `var(--name)`.
+*
+* Bindings in `options` are applied first and may be partial — this is
+* the serialize half of the solve/serialize duality, and unbound
+* references are the values left for the browser. Constants render with
+* their annotated precision, or the context `precision` option (default
+* `Precision.decimals(5)`). Constants equal to pi render as the CSS
+* constant `pi` where a math function surrounds them.
+*
+* @param expr - The expression to render.
+* @param options - Optional bindings and precision context.
+* @returns Deterministic CSS text.
+* @example
+* ```ts
+* const fluid = Calc.add(10, Calc.ref('runtime'))
+* Calc.serialize(fluid) // 'calc(10 + var(--runtime))'
+* Calc.serialize(fluid, { bindings: { runtime: 4 } }) // '14'
+* ```
+* @since 0.1.0
+*/
+const serialize = serialize$1;
+/**
+* The expression's unbound reference names.
+*
+* @param expr - The expression to inspect.
+* @returns The set of unbound reference names.
+* @since 0.1.0
+*/
+const refs = refs$1;
+/**
+* The channel-keyword tokens the expression reads — the `Channel` keywords a
+* relative color introduces (`l`, `c`, `h`, ...). Empty for an expression with
+* no channel keywords.
+*
+* This is the runtime companion to the `Leaves`-level scoping that `solve`'s
+* context requires: `channels` reports which values a context must supply,
+* exactly as `refs` reports the custom properties a binding must, and — unlike
+* a `Calc`'s `Kind`/`Leaves` type — survives on a `Calc<Refs, Kind, unknown>`
+* whose leaves have been erased. Channel keywords are not references, so `refs`
+* never lists them and they never reach a `Stylesheet`'s dependency report.
+*
+* @param expr - The expression to inspect.
+* @returns The set of channel-keyword tokens the expression reads.
+* @example
+* ```ts
+* Calc.channels(Calc.multiply(Channel.L, 0.8)) // Set { 'l' }
+* Calc.channels(Calc.ref('x')) // Set {}
+* ```
+* @since 0.2.0
+*/
+const channels = channels$1;
+const equals = equals$1;
+//#endregion
+//#region src/calc/precision.ts
+var precision_exports = /* @__PURE__ */ __exportAll({
+	decimals: () => decimals,
+	isPrecision: () => isPrecision,
+	significant: () => significant
+});
+/**
+* Checks if a value is a `Precision`.
+*
+* True only for values built by `decimals` or `significant`, which carry
+* the brand.
+*
+* @param u - The value to check.
+* @returns `true` if the value is a `Precision`, `false` otherwise.
+* @since 0.1.0
+*/
+const isPrecision = isPrecision$1;
+/**
+* Creates a `Precision` fixing the count of digits after the decimal
+* point. The library default for unannotated constants is `decimals(5)`.
+*
+* @param digits - Digits after the decimal point. Must be an integer in `[0, 100]`.
+* @returns A `Precision` in `decimals` mode.
+* @throws `Error` when `digits` is not an integer in `[0, 100]`.
+* @example
+* ```ts
+* Calc.serialize(Calc.of(1 / 3), { precision: Precision.decimals(2) }) // '0.33'
+* ```
+* @since 0.1.0
+*/
+const decimals = decimals$1;
+/**
+* Creates a `Precision` fixing the count of significant digits. Use it for
+* unit-free constants whose error is amplified downstream — solved curve
+* coefficients, for example — where fixed decimal places would truncate.
+*
+* @param digits - Significant digits. Must be an integer in `[1, 100]`.
+* @returns A `Precision` in `significant` mode.
+* @throws `Error` when `digits` is not an integer in `[1, 100]`.
+* @example
+* ```ts
+* const k = Calc.of(0.8377580409572781, Precision.significant(10))
+* Calc.serialize(k) // '0.837758041'
+* ```
+* @since 0.1.0
+*/
+const significant = significant$1;
+//#endregion
+export { EMPTY_REFS as C, toCalc as S, nodeOf as _, multiply as a, serializeNode as b, bind$1 as c, ident as d, identsOf as f, nodeHash as g, nodeEquals as h, mod as i, collectBindings as l, needsCalcWrap as m, add as n, sign as o, isCalc$1 as p, calc_exports as r, subtract as s, precision_exports as t, dimension as u, refsOf as v, unionRefs as w, substituteNode as x, serialize$1 as y };
+
+//# sourceMappingURL=calc-Cih4o2r7.mjs.map