math-expression-compiler 4.4.0 → 4.6.0

package/dist/index.js

@@ -0,0 +1,1886 @@
+import { exhaustiveGuard } from "@esposter/shared";
+import { err, ok } from "neverthrow";
+// src/models/compiler/MathExpressionBitwiseAbsorption.ts
+let MathExpressionBitwiseAbsorption = /* @__PURE__ */ function(MathExpressionBitwiseAbsorption) {
+	MathExpressionBitwiseAbsorption["BitAnd"] = "bitAnd";
+	MathExpressionBitwiseAbsorption["BitOr"] = "bitOr";
+	return MathExpressionBitwiseAbsorption;
+}({});
+// src/models/function/MathExpressionFunctionName.ts
+let MathExpressionFunctionName = /* @__PURE__ */ function(MathExpressionFunctionName) {
+	MathExpressionFunctionName["CTranspose"] = "ctranspose";
+	MathExpressionFunctionName["Factorial"] = "factorial";
+	MathExpressionFunctionName["UnaryMinus"] = "unaryMinus";
+	MathExpressionFunctionName["UnaryPlus"] = "unaryPlus";
+	return MathExpressionFunctionName;
+}({});
+// src/models/function/MathExpressionParameterType.ts
+let MathExpressionParameterType = /* @__PURE__ */ function(MathExpressionParameterType) {
+	MathExpressionParameterType["Any"] = "any";
+	MathExpressionParameterType["List"] = "list";
+	MathExpressionParameterType["Number"] = "number";
+	return MathExpressionParameterType;
+}({});
+// src/models/parser/MathExpressionBinaryOperatorSymbol.ts
+let MathExpressionBinaryOperatorSymbol = /* @__PURE__ */ function(MathExpressionBinaryOperatorSymbol) {
+	MathExpressionBinaryOperatorSymbol["Add"] = "+";
+	MathExpressionBinaryOperatorSymbol["And"] = "and";
+	MathExpressionBinaryOperatorSymbol["BitwiseAnd"] = "&";
+	MathExpressionBinaryOperatorSymbol["BitwiseOr"] = "|";
+	MathExpressionBinaryOperatorSymbol["BitwiseXor"] = "^|";
+	MathExpressionBinaryOperatorSymbol["Divide"] = "/";
+	MathExpressionBinaryOperatorSymbol["ElementwiseDivide"] = "./";
+	MathExpressionBinaryOperatorSymbol["ElementwiseMultiply"] = ".*";
+	MathExpressionBinaryOperatorSymbol["Equal"] = "==";
+	MathExpressionBinaryOperatorSymbol["GreaterThan"] = ">";
+	MathExpressionBinaryOperatorSymbol["GreaterThanOrEqual"] = ">=";
+	MathExpressionBinaryOperatorSymbol["LessThan"] = "<";
+	MathExpressionBinaryOperatorSymbol["LessThanOrEqual"] = "<=";
+	MathExpressionBinaryOperatorSymbol["Multiply"] = "*";
+	MathExpressionBinaryOperatorSymbol["NotEqual"] = "!=";
+	MathExpressionBinaryOperatorSymbol["Or"] = "or";
+	MathExpressionBinaryOperatorSymbol["ShiftLeft"] = "<<";
+	MathExpressionBinaryOperatorSymbol["ShiftRight"] = ">>";
+	MathExpressionBinaryOperatorSymbol["Subtract"] = "-";
+	MathExpressionBinaryOperatorSymbol["UnsignedShiftRight"] = ">>>";
+	MathExpressionBinaryOperatorSymbol["Xor"] = "xor";
+	return MathExpressionBinaryOperatorSymbol;
+}({});
+// src/models/parser/MathExpressionGrammarRule.ts
+let MathExpressionGrammarRule = /* @__PURE__ */ function(MathExpressionGrammarRule) {
+	MathExpressionGrammarRule["Assignment"] = "Assignment";
+	MathExpressionGrammarRule["Binary"] = "Binary";
+	MathExpressionGrammarRule["Conditional"] = "Conditional";
+	MathExpressionGrammarRule["LeftHand"] = "LeftHand";
+	MathExpressionGrammarRule["Nullish"] = "Nullish";
+	MathExpressionGrammarRule["Percentage"] = "Percentage";
+	MathExpressionGrammarRule["Power"] = "Power";
+	MathExpressionGrammarRule["Symbol"] = "Symbol";
+	MathExpressionGrammarRule["Unary"] = "Unary";
+	return MathExpressionGrammarRule;
+}({});
+// src/models/parser/MathExpressionTokenType.ts
+let MathExpressionTokenType = /* @__PURE__ */ function(MathExpressionTokenType) {
+	MathExpressionTokenType["Delimiter"] = "delimiter";
+	MathExpressionTokenType["Null"] = "null";
+	MathExpressionTokenType["Number"] = "number";
+	MathExpressionTokenType["Symbol"] = "symbol";
+	MathExpressionTokenType["Unknown"] = "unknown";
+	return MathExpressionTokenType;
+}({});
+// src/models/parser/token/MathExpressionRadix.ts
+let MathExpressionRadix = /* @__PURE__ */ function(MathExpressionRadix) {
+	MathExpressionRadix["Binary"] = "b";
+	MathExpressionRadix["Hexadecimal"] = "x";
+	MathExpressionRadix["Octal"] = "o";
+	return MathExpressionRadix;
+}({});
+// src/models/shared/MathExpressionError.ts
+var MathExpressionError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "MathExpressionError";
+	}
+};
+// src/models/shared/MathExpressionLogicalOperator.ts
+let MathExpressionLogicalOperator = /* @__PURE__ */ function(MathExpressionLogicalOperator) {
+	MathExpressionLogicalOperator["And"] = "and";
+	MathExpressionLogicalOperator["Nullish"] = "nullish";
+	MathExpressionLogicalOperator["Or"] = "or";
+	return MathExpressionLogicalOperator;
+}({});
+// src/models/shared/MathExpressionNodeType.ts
+let MathExpressionNodeType = /* @__PURE__ */ function(MathExpressionNodeType) {
+	MathExpressionNodeType["Assignment"] = "assignment";
+	MathExpressionNodeType["Binary"] = "binary";
+	MathExpressionNodeType["Call"] = "call";
+	MathExpressionNodeType["Comparison"] = "comparison";
+	MathExpressionNodeType["Conditional"] = "conditional";
+	MathExpressionNodeType["Group"] = "group";
+	MathExpressionNodeType["List"] = "list";
+	MathExpressionNodeType["Logical"] = "logical";
+	MathExpressionNodeType["Name"] = "name";
+	MathExpressionNodeType["Number"] = "number";
+	MathExpressionNodeType["Percentage"] = "percentage";
+	MathExpressionNodeType["Unary"] = "unary";
+	return MathExpressionNodeType;
+}({});
+// src/services/compiler/constants.ts
+const NO_VALUES = [];
+const NO_LOCALS = [];
+const ADDITIVE_NAMES = ["add", "subtract"];
+// src/services/compiler/checkIsPercentageExpression.ts
+const checkIsPercentageExpression = (node) => {
+	if (node.type === "percentage") return true;
+	if (node.type !== "binary") return false;
+	if (!ADDITIVE_NAMES.includes(node.name)) return false;
+	return checkIsPercentageExpression(node.left) && checkIsPercentageExpression(node.right);
+};
+// src/services/shared/getMathExpressionChildren.ts
+const getMathExpressionChildren = (node) => {
+	switch (node.type) {
+		case "assignment": return [node.value];
+		case "binary":
+		case "logical": return [node.left, node.right];
+		case "call": return node.arguments;
+		case "comparison": return node.operands;
+		case "conditional": return [
+			node.condition,
+			node.whenTrue,
+			node.whenFalse
+		];
+		case "group":
+		case "percentage":
+		case "unary": return [node.operand];
+		case "list": return node.elements;
+		case "name":
+		case "number": return [];
+		default: return exhaustiveGuard(node);
+	}
+};
+// src/services/compiler/collectMathExpressionAssignedNames.ts
+const collectMathExpressionAssignedNames = (node, names) => {
+	if (node.type === "assignment") names.add(node.name);
+	for (const child of getMathExpressionChildren(node)) collectMathExpressionAssignedNames(child, names);
+};
+// src/services/compiler/compileList.ts
+const compileList = (elements, context) => {
+	const compiledElements = elements.map((element) => context.compile(element));
+	return {
+		evaluate: (values, locals) => {
+			const numbers = [];
+			for (const element of compiledElements) {
+				const elementValue = element.evaluate(values, locals);
+				if (elementValue === null) return null;
+				numbers.push(elementValue);
+			}
+			return numbers;
+		},
+		isConstant: compiledElements.every((element) => element.isConstant)
+	};
+};
+// src/services/compiler/compileArgument.ts
+const compileArgument = (node, context) => {
+	if (node.type === "list") return compileList(node.elements, context);
+	return context.compile(node);
+};
+// src/services/compiler/node/compileAssignment.ts
+const compileAssignment = (node, context) => {
+	const slot = context.assignedSlots.get(node.name) ?? 0;
+	const compiledValue = context.compile(node.value);
+	return {
+		evaluate: (values, locals) => {
+			const value = compiledValue.evaluate(values, locals);
+			locals[slot] = value;
+			return value;
+		},
+		isConstant: false
+	};
+};
+// src/services/function/constants.ts
+const MATH_EXPRESSION_RELATIVE_TOLERANCE = 1e-12;
+const MATH_EXPRESSION_ABSOLUTE_TOLERANCE = 1e-15;
+const SQRT_PI = Math.sqrt(Math.PI);
+const MAXIMUM_DIGITS = 15;
+const MILLER_RABIN_BASES = [
+	2n,
+	3n,
+	5n,
+	7n,
+	11n,
+	13n,
+	17n,
+	19n,
+	23n,
+	29n,
+	31n,
+	37n
+];
+const OVERFLOW_ARGUMENT = 171.35;
+const LAST_FACTORIAL_ARGUMENT = 171;
+const STIRLING_THRESHOLD = 15;
+const STIRLING_TERMS = [
+	1 / 12,
+	-1 / 360,
+	1 / 1260,
+	-1 / 1680,
+	1 / 1188,
+	-691 / 360360,
+	1 / 156
+];
+// src/services/function/checkIsNearlyEqual.ts
+const checkIsNearlyEqual = (left, right) => {
+	if (Number.isNaN(left) || Number.isNaN(right)) return false;
+	if (!Number.isFinite(left) || !Number.isFinite(right)) return left === right;
+	if (left === right) return true;
+	const tolerance = Math.max(MATH_EXPRESSION_RELATIVE_TOLERANCE * Math.max(Math.abs(left), Math.abs(right)), MATH_EXPRESSION_ABSOLUTE_TOLERANCE);
+	return Math.abs(left - right) <= tolerance;
+};
+// src/services/function/checkIsLarger.ts
+const checkIsLarger = (left, right) => left > right && !checkIsNearlyEqual(left, right);
+// src/services/function/computeModularPower.ts
+const computeModularPower = (base, exponent, modulus) => {
+	let result = 1n;
+	let square = base % modulus;
+	let remaining = exponent;
+	while (remaining > 0n) {
+		if (remaining % 2n === 1n) result = result * square % modulus;
+		square = square * square % modulus;
+		remaining /= 2n;
+	}
+	return result;
+};
+// src/services/function/checkIsMillerRabinPassing.ts
+const checkIsMillerRabinPassing = (candidate, base, oddPart, twos) => {
+	const minusOne = candidate - 1n;
+	let power = computeModularPower(base, oddPart, candidate);
+	if (power === 1n || power === minusOne) return true;
+	for (let round = 1; round < twos; round++) {
+		power = power * power % candidate;
+		if (power === minusOne) return true;
+	}
+	return false;
+};
+// src/services/function/checkIsPrime.ts
+const checkIsPrime = (value) => {
+	if (!Number.isInteger(value) || value < 2 || value > Number.MAX_SAFE_INTEGER) return false;
+	const candidate = BigInt(value);
+	for (const base of MILLER_RABIN_BASES) {
+		if (candidate === base) return true;
+		if (candidate % base === 0n) return false;
+	}
+	let oddPart = candidate - 1n;
+	let twos = 0;
+	while (oddPart % 2n === 0n) {
+		oddPart /= 2n;
+		twos++;
+	}
+	return MILLER_RABIN_BASES.every((base) => checkIsMillerRabinPassing(candidate, base, oddPart, twos));
+};
+// src/services/function/checkIsSmaller.ts
+const checkIsSmaller = (left, right) => left < right && !checkIsNearlyEqual(left, right);
+// src/services/function/computeBitwiseAnd.ts
+const computeBitwiseAnd = (left, right) => left & right;
+// src/services/function/computeBitwiseOr.ts
+const computeBitwiseOr = (left, right) => left | right;
+// src/services/function/computeCombinations.ts
+const computeCombinations = (available, chosen) => {
+	const smaller = Math.min(chosen, available - chosen);
+	let result = 1;
+	for (let step = 1; step <= smaller; step++) {
+		result = result * (available - smaller + step) / step;
+		if (result > Number.MAX_VALUE) return Number.POSITIVE_INFINITY;
+	}
+	return Math.round(result);
+};
+// src/services/function/computeComparison.ts
+const computeComparison = (left, right) => {
+	if (checkIsNearlyEqual(left, right)) return 0;
+	return left > right ? 1 : -1;
+};
+// src/services/function/computeCompositions.ts
+const computeCompositions = (total, parts) => {
+	if (!Number.isInteger(total) || !Number.isInteger(parts) || parts < 1 || parts > total) return null;
+	return computeCombinations(total - 1, parts - 1);
+};
+// src/services/function/computeDotProduct.ts
+const computeDotProduct = (left, right) => {
+	if (left.length !== right.length) return null;
+	return left.reduce((total, value, index) => total + value * (right[index] ?? NaN), 0);
+};
+// src/services/function/computeSum.ts
+const computeSum = (values) => values.length === 0 ? 0 : values.reduce((total, value) => total + value);
+// src/services/function/computeCorrelation.ts
+const computeCorrelation = (left, right) => {
+	if (left.length !== right.length) return null;
+	const count = left.length;
+	const sumLeft = computeSum(left);
+	const sumRight = computeSum(right);
+	const sumProducts = computeDotProduct(left, right) ?? NaN;
+	const sumLeftSquares = computeSum(left.map((value) => value ** 2));
+	const sumRightSquares = computeSum(right.map((value) => value ** 2));
+	return (count * sumProducts - sumLeft * sumRight) / Math.sqrt((count * sumLeftSquares - sumLeft ** 2) * (count * sumRightSquares - sumRight ** 2));
+};
+// src/services/function/computeDeterminant.ts
+const computeDeterminant = (values) => {
+	if (values.length === 0) return 1;
+	return values.length === 1 ? values[0] ?? null : null;
+};
+// src/services/function/computePointToLine2D.ts
+const computePointToLine2D = (point, line) => {
+	const [x = NaN, y = NaN] = point;
+	const [a = NaN, b = NaN, c = NaN] = line;
+	return Math.abs(a * x + b * y + c) / Math.hypot(a, b);
+};
+// src/services/function/computePointToLine3D.ts
+const computePointToLine3D = (point, line) => {
+	const [x = NaN, y = NaN, z = NaN] = point;
+	const [x0 = NaN, y0 = NaN, z0 = NaN, a = NaN, b = NaN, c = NaN] = line;
+	const first = (y0 - y) * c - (z0 - z) * b;
+	const second = (z0 - z) * a - (x0 - x) * c;
+	const third = (x0 - x) * b - (y0 - y) * a;
+	return Math.hypot(first, second, third) / Math.hypot(a, b, c);
+};
+// src/services/function/computeDistance.ts
+const computeDistance = (point, other) => {
+	if (point.length === 2 && other.length === 3) return computePointToLine2D(point, other);
+	if (point.length === 3 && other.length === 6) return computePointToLine3D(point, other);
+	if (point.length !== other.length || point.length === 0) return null;
+	let total = 0;
+	for (const [index, value] of point.entries()) {
+		const difference = value - (other[index] ?? NaN);
+		total = difference * difference + total;
+	}
+	return Math.sqrt(total);
+};
+// src/services/function/computeErf.ts
+const SERIES_LIMIT = 3;
+const CONTINUED_FRACTION_DEPTH = 80;
+const computeErf = (value) => {
+	if (Number.isNaN(value)) return NaN;
+	const magnitude = Math.abs(value);
+	const sign = value < 0 ? -1 : 1;
+	if (magnitude < SERIES_LIMIT) {
+		const squared = magnitude * magnitude;
+		let term = magnitude;
+		let total = magnitude;
+		for (let index = 1; index < 200; index++) {
+			term *= 2 * squared / (2 * index + 1);
+			total += term;
+			if (term < total * 1e-17) break;
+		}
+		return sign * 2 * Math.exp(-squared) * total / SQRT_PI;
+	}
+	let fraction = magnitude;
+	for (let index = CONTINUED_FRACTION_DEPTH; index >= 1; index--) fraction = magnitude + index / 2 / fraction;
+	return sign * (1 - Math.exp(-magnitude * magnitude) / SQRT_PI / fraction);
+};
+// src/services/function/computeStirlingLogGamma.ts
+const computeStirlingLogGamma = (value) => {
+	const inverse = 1 / value;
+	const squared = inverse * inverse;
+	let power = inverse;
+	let series = 0;
+	for (const term of STIRLING_TERMS) {
+		series += term * power;
+		power *= squared;
+	}
+	return (value - .5) * Math.log(value) - value + .5 * Math.log(2 * Math.PI) + series;
+};
+// src/services/function/computeLogGammaOfPositive.ts
+const computeLogGammaOfPositive = (value) => {
+	let shifted = value;
+	let product = 1;
+	while (shifted < 15) {
+		product *= shifted;
+		shifted += 1;
+	}
+	return {
+		logGamma: computeStirlingLogGamma(shifted),
+		product
+	};
+};
+// src/services/function/computeProductOfRange.ts
+const computeProductOfRange = (first, last) => {
+	if (last < first) return 1;
+	if (last === first) return last;
+	const middle = Math.floor((first + last) / 2);
+	return computeProductOfRange(first, middle) * computeProductOfRange(middle + 1, last);
+};
+// src/services/function/computeGamma.ts
+const computeGamma = (value) => {
+	if (Number.isNaN(value)) return NaN;
+	if (Number.isInteger(value)) {
+		if (value <= 0 || value > 171) return Number.POSITIVE_INFINITY;
+		return computeProductOfRange(1, value - 1);
+	}
+	if (value < .5) return Math.PI / (Math.sin(Math.PI * value) * computeGamma(1 - value));
+	if (value >= 171.35) return Number.POSITIVE_INFINITY;
+	const { logGamma, product } = computeLogGammaOfPositive(value);
+	return Math.exp(logGamma) / product;
+};
+// src/services/function/computeFactorial.ts
+const computeFactorial = (value) => {
+	if (value < 0) return null;
+	return computeGamma(value + 1);
+};
+// src/services/function/computeHypotenuse.ts
+const computeHypotenuse = (values) => {
+	let largest = 0;
+	let total = 0;
+	for (const value of values) {
+		const magnitude = Math.abs(value);
+		if (largest < magnitude) {
+			const ratio = largest / magnitude;
+			total = total * (ratio * ratio) + 1;
+			largest = magnitude;
+		} else if (magnitude > 0) {
+			const ratio = magnitude === largest ? 1 : magnitude / largest;
+			total += ratio * ratio;
+		} else total += magnitude;
+	}
+	return largest * Math.sqrt(total);
+};
+// src/services/function/computeGreatestCommonDivisor.ts
+const computeGreatestCommonDivisor = (left, right) => right === 0 ? Math.abs(left) : computeGreatestCommonDivisor(right, left % right);
+// src/services/function/computeIntegerGreatestCommonDivisor.ts
+const computeIntegerGreatestCommonDivisor = (values) => {
+	if (!values.every((value) => Number.isInteger(value))) return null;
+	return values.reduce((total, value) => computeGreatestCommonDivisor(total, value), 0);
+};
+// src/services/function/computeInverseCoth.ts
+const computeInverseCoth = (value) => {
+	const magnitude = Math.abs(value);
+	if (magnitude < 1) return NaN;
+	if (magnitude === 1) return value * Number.POSITIVE_INFINITY;
+	return Math.sign(value) * .5 * Math.log1p(2 / (magnitude - 1));
+};
+// src/services/function/computeKullbackLeibler.ts
+const computeKullbackLeibler = (distribution, reference) => {
+	if (distribution.length !== reference.length) return null;
+	const distributionSum = computeSum(distribution);
+	const referenceSum = computeSum(reference);
+	if (distributionSum === 0 || referenceSum === 0) return null;
+	const normalizedDistribution = distribution.map((value) => value / distributionSum);
+	const normalizedReference = reference.map((value) => value / referenceSum);
+	return computeSum(normalizedDistribution.map((value, index) => value * Math.log(value / (normalizedReference[index] ?? NaN))));
+};
+// src/services/function/computeLeastCommonMultiple.ts
+const computeLeastCommonMultiple = (left, right) => {
+	if (!Number.isInteger(left) || !Number.isInteger(right)) return null;
+	const divisor = computeGreatestCommonDivisor(left, right);
+	return divisor === 0 ? 0 : Math.abs(left * right / divisor);
+};
+// src/services/function/computeListComparison.ts
+const computeListComparison = (left, right) => {
+	for (const [index, value] of left.entries()) {
+		const other = right[index];
+		if (other === void 0) return 1;
+		const comparison = computeComparison(value, other);
+		if (comparison !== 0) return comparison;
+	}
+	return left.length < right.length ? -1 : 0;
+};
+// src/services/function/computeLogarithm.ts
+const computeLogarithm = (value, base) => base === void 0 ? Math.log(value) : Math.log(value) / Math.log(base);
+// src/services/function/computeMean.ts
+const computeMean = (values) => computeSum(values) / values.length;
+// src/services/function/compareNumbers.ts
+const compareNumbers = (left, right) => left - right;
+// src/services/function/computeMedian.ts
+const computeMedian = (values) => {
+	const sorted = values.toSorted(compareNumbers);
+	const middle = Math.floor(sorted.length / 2);
+	if (sorted.length % 2 === 1) return sorted[middle] ?? NaN;
+	return ((sorted[middle - 1] ?? NaN) + (sorted[middle] ?? NaN)) / 2;
+};
+// src/services/function/computeMedianAbsoluteDeviation.ts
+const computeMedianAbsoluteDeviation = (values) => {
+	const center = computeMedian(values);
+	return computeMedian(values.map((value) => Math.abs(value - center)));
+};
+// src/services/function/computeModulo.ts
+const computeModulo = (dividend, divisor) => {
+	if (divisor === 0) return dividend;
+	if (!Number.isFinite(dividend) || !Number.isFinite(divisor)) return NaN;
+	if (Number.isInteger(dividend) && Number.isInteger(divisor)) {
+		const remainder = dividend % divisor;
+		if (remainder === 0) return 0;
+		return Math.sign(remainder) === Math.sign(divisor) ? remainder : remainder + divisor;
+	}
+	const quotient = dividend / divisor;
+	if (checkIsNearlyEqual(quotient, Math.round(quotient))) return 0;
+	return dividend - divisor * Math.floor(quotient);
+};
+// src/services/function/computeModularInverse.ts
+const computeModularInverse = (value, modulus) => {
+	if (!Number.isInteger(value) || !Number.isInteger(modulus) || modulus === 0) return null;
+	let remainder = value;
+	let nextRemainder = modulus;
+	let coefficient = 0;
+	let previousCoefficient = 1;
+	while (nextRemainder !== 0) {
+		const quotient = Math.floor(remainder / nextRemainder);
+		[coefficient, previousCoefficient] = [previousCoefficient - quotient * coefficient, coefficient];
+		[remainder, nextRemainder] = [nextRemainder, remainder - quotient * nextRemainder];
+	}
+	if ((remainder < 0 ? -remainder : remainder) !== 1) return NaN;
+	const inverse = computeModulo(remainder < 0 ? -previousCoefficient : previousCoefficient, modulus);
+	return inverse < 0 ? inverse + modulus : inverse;
+};
+// src/services/function/computeMultinomial.ts
+const computeMultinomial = (parts) => {
+	if (!parts.every((part) => Number.isInteger(part) && part > 0)) return null;
+	let result = 1;
+	let running = 0;
+	for (const part of parts) {
+		running += part;
+		result *= computeCombinations(running, part);
+	}
+	return result;
+};
+// src/services/function/computeNorm.ts
+const computeNorm = (values) => {
+	if (values.length === 0) return 0;
+	if (values.length === 1) return Math.abs(values[0] ?? NaN);
+	return Math.sqrt(computeSum(values.map((value) => value * value)));
+};
+// src/services/function/computeNthRoot.ts
+const computeNthRoot = (value, root) => {
+	const isInverse = root < 0;
+	const degree = Math.abs(root);
+	if (degree === 0) return null;
+	if (value < 0 && degree % 2 !== 1) return null;
+	if (value === 0) return isInverse ? Number.POSITIVE_INFINITY : 0;
+	if (!Number.isFinite(value)) return isInverse ? 0 : value;
+	let result = Math.abs(value) ** (1 / degree);
+	const rounded = Math.round(result);
+	if (Number.isInteger(degree) && rounded ** degree === Math.abs(value)) result = rounded;
+	if (value < 0) result = -result;
+	return isInverse ? 1 / result : result;
+};
+// src/services/function/computePartitionSelect.ts
+const computePartitionSelect = (values, index) => {
+	if (!Number.isInteger(index) || index < 0 || index >= values.length) return null;
+	return values.toSorted(compareNumbers)[index] ?? null;
+};
+// src/services/function/computePermutations.ts
+const computePermutations = (available, chosen) => {
+	if (!Number.isInteger(available) || !Number.isInteger(chosen) || chosen < 0 || chosen > available) return null;
+	let result = 1;
+	for (let factor = available - chosen + 1; factor <= available; factor++) {
+		result *= factor;
+		if (result > Number.MAX_VALUE) return Number.POSITIVE_INFINITY;
+	}
+	return result;
+};
+// src/services/function/scaleList.ts
+const scaleList = (list, scalar) => list.map((element) => element * scalar);
+// src/services/function/multiplyPair.ts
+const multiplyPair = (left, right) => {
+	if (typeof left === "number" && typeof right === "number") return left * right;
+	if (typeof left === "number" && Array.isArray(right)) return scaleList(right, left);
+	if (Array.isArray(left) && typeof right === "number") return scaleList(left, right);
+	if (Array.isArray(left) && Array.isArray(right)) return computeDotProduct(left, right);
+	return null;
+};
+// src/services/function/computeProduct.ts
+const computeProduct = (values) => {
+	let total = 1;
+	for (const value of values) {
+		if (total === null) return null;
+		total = multiplyPair(total, value);
+	}
+	return typeof total === "number" ? total : null;
+};
+// src/services/function/computeQuantile.ts
+const computeQuantile = (values, probability, isSorted) => {
+	if (values.length === 0 || probability < 0 || probability > 1) return null;
+	const ordered = isSorted ? values : values.toSorted(compareNumbers);
+	const index = probability * (ordered.length - 1);
+	const integerPart = Math.floor(index);
+	if (Number.isInteger(index)) return ordered[integerPart] ?? NaN;
+	const fraction = index % 1;
+	return (ordered[integerPart] ?? NaN) * (1 - fraction) + (ordered[integerPart + 1] ?? NaN) * fraction;
+};
+// src/services/shared/checkIsTruthy.ts
+const checkIsTruthy = (value) => value !== 0 && !Number.isNaN(value);
+// src/services/function/computeTruthyCount.ts
+const computeTruthyCount = (values) => values.filter((value) => checkIsTruthy(value)).length;
+// src/services/function/computeVariance.ts
+const computeVariance = (values) => {
+	if (values.length === 1) return Number.isFinite(values[0] ?? NaN) ? 0 : NaN;
+	const average = computeMean(values);
+	return computeSum(values.map((value) => (value - average) ** 2)) / (values.length - 1);
+};
+// src/services/function/computeExtreme.ts
+const computeExtreme = (values, initial, checkIsPreferred) => {
+	let extreme = initial;
+	for (const value of values) {
+		if (Number.isNaN(value)) return NaN;
+		if (checkIsPreferred(value, extreme)) extreme = value;
+	}
+	return extreme;
+};
+// src/services/function/computeVectorNorm.ts
+const computeVectorNorm = (values, power) => {
+	if (Number.isNaN(power)) return null;
+	const magnitudes = values.map((value) => Math.abs(value));
+	if (Math.abs(power) === Number.POSITIVE_INFINITY) {
+		const [first] = magnitudes;
+		if (first === void 0) return 0;
+		return computeExtreme(magnitudes, first, power > 0 ? checkIsLarger : checkIsSmaller);
+	}
+	if (checkIsNearlyEqual(power, 0)) return Number.POSITIVE_INFINITY;
+	return computeSum(magnitudes.map((magnitude) => magnitude ** power)) ** (1 / power);
+};
+// src/services/function/signature/createNumericCompute.ts
+const createNumericCompute = (compute) => (values) => compute(values.flat());
+// src/services/function/signature/createSignature.ts
+const createSignature = (parameters, minArity, maxArity, compute, scalarCompute = {}) => ({
+	compute,
+	maxArity,
+	minArity,
+	parameters,
+	...scalarCompute
+});
+// src/services/function/signature/createNumberSignature.ts
+const createNumberSignature = (minArity, maxArity, compute, scalarCompute) => createSignature(["number"], minArity, maxArity, createNumericCompute(compute), scalarCompute);
+// src/services/function/signature/createRangedSignatures.ts
+const createRangedSignatures = (minArity, maxArity, compute, scalarCompute) => [createNumberSignature(minArity, maxArity, compute, scalarCompute)];
+// src/services/function/signature/createBinarySignatures.ts
+const createBinarySignatures = (compute) => createRangedSignatures(2, 2, (values) => compute(values[0] ?? NaN, values[1] ?? NaN), { computeBinary: compute });
+// src/services/function/signature/createBitwisePair.ts
+const createBitwisePair = (absorbing, compute) => (left, right) => {
+	if (left === absorbing) return absorbing;
+	if (!Number.isInteger(left) || !Number.isInteger(right)) return null;
+	return compute(left, right);
+};
+// src/services/function/signature/createBitwiseFold.ts
+const createBitwiseFold = (absorbing, compute) => {
+	const computePair = createBitwisePair(absorbing, compute);
+	return (values) => values.slice(1).reduce((result, value) => result === null ? null : computePair(result, value), values[0] ?? NaN);
+};
+// src/services/function/shiftDecimalPlaces.ts
+const shiftDecimalPlaces = (value, places) => {
+	if (!Number.isFinite(value)) return value;
+	const [mantissa = "", exponent = "0"] = value.toExponential().split("e");
+	return Number(`${mantissa}e${Number(exponent) + places}`);
+};
+// src/services/function/roundToDigits.ts
+const roundToDigits = (rounder, value, digits) => {
+	if (!Number.isInteger(digits) || digits < 0 || digits > 15) return null;
+	if (!Number.isFinite(value)) return value;
+	if (Number.isInteger(value)) return value + 0;
+	if (digits === 0) return rounder(value) + 0;
+	return shiftDecimalPlaces(rounder(shiftDecimalPlaces(value, digits)), -digits);
+};
+// src/services/function/signature/createDigitSignatures.ts
+const createDigitSignatures = (rounder) => createRangedSignatures(1, 2, (values) => {
+	const [value = NaN, digits = 0] = values;
+	return roundToDigits(rounder, value, digits);
+}, {
+	computeBinary: (value, digits) => roundToDigits(rounder, value, digits),
+	computeUnary: (value) => roundToDigits(rounder, value, 0)
+});
+// src/services/function/signature/createNonEmptyCompute.ts
+const createNonEmptyCompute = (compute) => (values) => values.length === 0 ? null : compute(values);
+// src/services/function/signature/createListSignature.ts
+const createListSignature = (compute) => createSignature(["list"], 1, 1, createNumericCompute(compute));
+// src/services/function/signature/createVariadicSignatures.ts
+const createVariadicSignatures = (minArity, compute, computeBinary) => [createNumberSignature(minArity, Number.POSITIVE_INFINITY, compute, { computeBinary })];
+// src/services/function/signature/createSpreadSignatures.ts
+const createSpreadSignatures = (minArity, compute) => [...createVariadicSignatures(minArity, compute), createListSignature(compute)];
+// src/services/function/signature/createExtremeSignatures.ts
+const createExtremeSignatures = (checkIsPreferred) => createSpreadSignatures(1, createNonEmptyCompute((values) => computeExtreme(values, values[0] ?? NaN, checkIsPreferred)));
+// src/services/function/signature/createSingletonListSignature.ts
+const createSingletonListSignature = (compute) => createListSignature((values) => values.length === 1 ? compute(values[0] ?? NaN) : null);
+// src/services/function/signature/createUnarySignatures.ts
+const createUnarySignatures = (compute) => createRangedSignatures(1, 1, (values) => compute(values[0] ?? NaN), { computeUnary: compute });
+// src/services/function/signature/createIdentitySignatures.ts
+const createIdentitySignatures = () => [...createUnarySignatures((value) => value), createSingletonListSignature((value) => value)];
+// src/services/function/signature/createIntegerBinarySignatures.ts
+const createIntegerBinarySignatures = (compute) => createBinarySignatures((left, right) => Number.isInteger(left) && Number.isInteger(right) ? compute(left, right) : null);
+// src/services/function/signature/createIntegerUnarySignatures.ts
+const createIntegerUnarySignatures = (compute) => createUnarySignatures((value) => Number.isInteger(value) ? compute(value) : null);
+// src/services/function/signature/createListFirstCompute.ts
+const createListFirstCompute = (compute) => (values) => compute(values.slice(0, 1).flat(), values.slice(1).flat());
+// src/services/function/signature/createListPairCompute.ts
+const createListPairCompute = (compute) => (values) => compute(values.slice(0, 1).flat(), values.slice(1, 2).flat());
+// src/services/function/signature/createListPairSignature.ts
+const createListPairSignature = (compute) => createSignature(["list", "list"], 2, 2, createListPairCompute(compute));
+// src/services/function/signature/createOrderedListSignatures.ts
+const createOrderedListSignatures = (compute) => {
+	const computePair = createListPairCompute(compute);
+	return [
+		["number", "list"],
+		["list", "number"],
+		["list", "list"]
+	].map((parameters) => createSignature(parameters, 2, 2, computePair));
+};
+// src/services/shared/toNumber.ts
+const toNumber = (flag) => flag ? 1 : 0;
+// src/services/function/MathExpressionFunctionMap.ts
+const MathExpressionFunctionMap = {
+	abs: createUnarySignatures(Math.abs),
+	acos: createUnarySignatures(Math.acos),
+	acosh: createUnarySignatures(Math.acosh),
+	acot: createUnarySignatures((value) => Math.atan(1 / value)),
+	acoth: createUnarySignatures(computeInverseCoth),
+	acsc: createUnarySignatures((value) => Math.asin(1 / value)),
+	acsch: createUnarySignatures((value) => Math.asinh(1 / value)),
+	add: createVariadicSignatures(2, computeSum, (left, right) => left + right),
+	addScalar: createBinarySignatures((left, right) => left + right),
+	and: createVariadicSignatures(1, (values) => toNumber(values.every((value) => checkIsTruthy(value)))),
+	arg: createUnarySignatures((value) => Number.isNaN(value) ? NaN : value < 0 ? Math.PI : 0),
+	asec: createUnarySignatures((value) => Math.acos(1 / value)),
+	asech: createUnarySignatures((value) => Math.acosh(1 / value)),
+	asin: createUnarySignatures(Math.asin),
+	asinh: createUnarySignatures(Math.asinh),
+	atan: createUnarySignatures(Math.atan),
+	atan2: createBinarySignatures((left, right) => Math.atan2(left, right)),
+	atanh: createUnarySignatures(Math.atanh),
+	bitAnd: createVariadicSignatures(2, createBitwiseFold(0, computeBitwiseAnd), createBitwisePair(0, computeBitwiseAnd)),
+	bitNot: createIntegerUnarySignatures((value) => ~value),
+	bitOr: createVariadicSignatures(2, createBitwiseFold(-1, computeBitwiseOr), createBitwisePair(-1, computeBitwiseOr)),
+	bitXor: createIntegerBinarySignatures((left, right) => left ^ right),
+	boolean: createRangedSignatures(0, 1, (values) => values.length === 0 ? 0 : toNumber(checkIsTruthy(values[0] ?? 0))),
+	cbrt: createUnarySignatures(Math.cbrt),
+	ceil: createDigitSignatures(Math.ceil),
+	clone: createUnarySignatures((value) => value),
+	combinations: createBinarySignatures((available, chosen) => Number.isInteger(available) && Number.isInteger(chosen) && chosen >= 0 && chosen <= available ? computeCombinations(available, chosen) : null),
+	combinationsWithRep: createBinarySignatures((available, chosen) => Number.isInteger(available) && Number.isInteger(chosen) && available >= 1 && chosen >= 0 ? computeCombinations(available + chosen - 1, chosen) : null),
+	compare: createBinarySignatures(computeComparison),
+	compareNatural: [...createBinarySignatures(computeComparison), ...createOrderedListSignatures(computeListComparison)],
+	composition: createBinarySignatures(computeCompositions),
+	conj: createUnarySignatures((value) => value),
+	corr: [createListPairSignature(computeCorrelation)],
+	cos: createUnarySignatures(Math.cos),
+	cosh: createUnarySignatures(Math.cosh),
+	cot: createUnarySignatures((value) => 1 / Math.tan(value)),
+	coth: createUnarySignatures((value) => 1 / Math.tanh(value)),
+	count: [createListSignature((values) => values.length)],
+	csc: createUnarySignatures((value) => 1 / Math.sin(value)),
+	csch: createUnarySignatures((value) => 1 / Math.sinh(value)),
+	cube: createUnarySignatures((value) => value * value * value),
+	deepEqual: [
+		...createBinarySignatures((left, right) => toNumber(checkIsNearlyEqual(left, right))),
+		createListPairSignature((left, right) => toNumber(left.length === right.length && left.every((value, index) => checkIsNearlyEqual(value, right[index] ?? NaN)))),
+		createSignature(["number", "list"], 2, 2, () => toNumber(false)),
+		createSignature(["list", "number"], 2, 2, () => toNumber(false))
+	],
+	det: [...createUnarySignatures((value) => value), createListSignature(computeDeterminant)],
+	distance: [createListPairSignature(computeDistance)],
+	divide: createBinarySignatures((left, right) => left / right),
+	divideScalar: createBinarySignatures((left, right) => left / right),
+	dot: [createListPairSignature(computeDotProduct)],
+	dotDivide: createBinarySignatures((left, right) => left / right),
+	dotMultiply: createBinarySignatures((left, right) => left * right),
+	dotPow: createBinarySignatures((left, right) => left ** right),
+	equal: createBinarySignatures((left, right) => toNumber(checkIsNearlyEqual(left, right))),
+	equalScalar: createBinarySignatures((left, right) => toNumber(checkIsNearlyEqual(left, right))),
+	erf: createUnarySignatures(computeErf),
+	exp: createUnarySignatures(Math.exp),
+	expm1: createUnarySignatures(Math.expm1),
+	fix: createDigitSignatures(Math.trunc),
+	floor: createDigitSignatures(Math.floor),
+	gamma: createUnarySignatures(computeGamma),
+	gcd: createSpreadSignatures(2, (values) => values.length < 2 ? null : computeIntegerGreatestCommonDivisor(values)),
+	hypot: createSpreadSignatures(1, computeHypotenuse),
+	im: createUnarySignatures(() => 0),
+	inv: createUnarySignatures((value) => 1 / value),
+	invmod: createBinarySignatures(computeModularInverse),
+	isBounded: [...createUnarySignatures((value) => toNumber(Number.isFinite(value))), createListSignature((values) => toNumber(values.every((value) => Number.isFinite(value))))],
+	isFinite: createUnarySignatures((value) => toNumber(Number.isFinite(value))),
+	isInteger: createUnarySignatures((value) => toNumber(Number.isInteger(value))),
+	isNaN: createUnarySignatures((value) => toNumber(Number.isNaN(value))),
+	isNegative: createUnarySignatures((value) => toNumber(value < 0)),
+	isPositive: createUnarySignatures((value) => toNumber(value > 0)),
+	isPrime: createUnarySignatures((value) => toNumber(checkIsPrime(value))),
+	isZero: createUnarySignatures((value) => toNumber(value === 0)),
+	kldivergence: [createListPairSignature(computeKullbackLeibler)],
+	larger: createBinarySignatures((left, right) => toNumber(checkIsLarger(left, right))),
+	largerEq: createBinarySignatures((left, right) => toNumber(left >= right || checkIsNearlyEqual(left, right))),
+	lcm: createVariadicSignatures(2, (values) => {
+		const [first = NaN, ...rest] = values;
+		return rest.reduce((total, value) => total === null ? null : computeLeastCommonMultiple(total, value), first);
+	}),
+	leftShift: createIntegerBinarySignatures((left, right) => left << right),
+	log: createRangedSignatures(1, 2, (values) => computeLogarithm(values[0] ?? NaN, values[1])),
+	log1p: createRangedSignatures(1, 2, (values) => {
+		const [value = NaN, base] = values;
+		return base === void 0 ? Math.log1p(value) : Math.log1p(value) / Math.log(base);
+	}),
+	log2: createUnarySignatures(Math.log2),
+	log10: createUnarySignatures(Math.log10),
+	mad: createSpreadSignatures(1, createNonEmptyCompute(computeMedianAbsoluteDeviation)),
+	["ctranspose"]: createUnarySignatures((value) => value),
+	["factorial"]: createUnarySignatures(computeFactorial),
+	["unaryMinus"]: createUnarySignatures((value) => -value),
+	["unaryPlus"]: createUnarySignatures((value) => value),
+	max: createExtremeSignatures(checkIsLarger),
+	mean: createSpreadSignatures(1, createNonEmptyCompute(computeMean)),
+	median: createSpreadSignatures(1, createNonEmptyCompute(computeMedian)),
+	min: createExtremeSignatures(checkIsSmaller),
+	mod: createBinarySignatures(computeModulo),
+	multinomial: [createListSignature(computeMultinomial)],
+	multiply: [
+		...createVariadicSignatures(2, (values) => values.reduce((total, value) => total * value, 1), (left, right) => left * right),
+		createListPairSignature(computeDotProduct),
+		createSignature(["any"], 2, Number.POSITIVE_INFINITY, computeProduct)
+	],
+	multiplyScalar: createBinarySignatures((left, right) => left * right),
+	norm: [
+		...createRangedSignatures(1, 1, computeNorm),
+		createListSignature(computeNorm),
+		createSignature(["list", "number"], 2, 2, createListFirstCompute((list, [power = NaN]) => computeVectorNorm(list, power)))
+	],
+	not: createUnarySignatures((value) => toNumber(!checkIsTruthy(value))),
+	nthRoot: createRangedSignatures(1, 2, (values) => computeNthRoot(values[0] ?? NaN, values[1] ?? 2)),
+	nullish: createVariadicSignatures(1, (values) => values[0] ?? NaN),
+	number: createRangedSignatures(0, 1, (values) => values.length === 0 ? 0 : values[0] ?? NaN),
+	numeric: createUnarySignatures((value) => value),
+	or: createVariadicSignatures(1, (values) => toNumber(computeTruthyCount(values) > 0)),
+	partitionSelect: [createSignature(["list", "number"], 2, 2, createListFirstCompute((list, [index = NaN]) => computePartitionSelect(list, index)))],
+	permutations: createRangedSignatures(1, 2, (values) => {
+		const [available = NaN, chosen = available] = values;
+		return computePermutations(available, chosen);
+	}),
+	pinv: createUnarySignatures((value) => value === 0 ? 0 : 1 / value),
+	pow: createBinarySignatures((left, right) => left ** right),
+	prod: createSpreadSignatures(1, createNonEmptyCompute((values) => values.reduce((total, value) => total * value, 1))),
+	quantileSeq: [createSignature(["list", "number"], 2, 3, createListFirstCompute((list, [probability = NaN, sorted = 0]) => computeQuantile(list, probability, checkIsTruthy(sorted))))],
+	re: createUnarySignatures((value) => value),
+	rightArithShift: createIntegerBinarySignatures((left, right) => left >> right),
+	rightLogShift: createIntegerBinarySignatures((left, right) => left >>> right),
+	round: createDigitSignatures((value) => Math.sign(value) * Math.round(Math.abs(value))),
+	sec: createUnarySignatures((value) => 1 / Math.cos(value)),
+	sech: createUnarySignatures((value) => 1 / Math.cosh(value)),
+	setIsSubset: [createListPairSignature((left, right) => toNumber(left.every((value) => right.includes(value))))],
+	setMultiplicity: [createSignature(["number", "list"], 2, 2, createListFirstCompute(([value = NaN], list) => list.filter((element) => element === value).length))],
+	setSize: [createListSignature((values) => values.length)],
+	sign: createUnarySignatures(Math.sign),
+	sin: createUnarySignatures(Math.sin),
+	sinh: createUnarySignatures(Math.sinh),
+	smaller: createBinarySignatures((left, right) => toNumber(checkIsSmaller(left, right))),
+	smallerEq: createBinarySignatures((left, right) => toNumber(left <= right || checkIsNearlyEqual(left, right))),
+	sqrt: createUnarySignatures(Math.sqrt),
+	square: createUnarySignatures((value) => value * value),
+	squeeze: createIdentitySignatures(),
+	std: createSpreadSignatures(1, createNonEmptyCompute((values) => Math.sqrt(computeVariance(values)))),
+	subtract: createBinarySignatures((left, right) => left - right),
+	subtractScalar: createBinarySignatures((left, right) => left - right),
+	sum: createSpreadSignatures(1, computeSum),
+	tan: createUnarySignatures(Math.tan),
+	tanh: createUnarySignatures(Math.tanh),
+	trace: createIdentitySignatures(),
+	transpose: createIdentitySignatures(),
+	unequal: createBinarySignatures((left, right) => toNumber(!checkIsNearlyEqual(left, right))),
+	variance: createSpreadSignatures(1, createNonEmptyCompute(computeVariance)),
+	xor: createVariadicSignatures(1, (values) => toNumber(computeTruthyCount(values) % 2 === 1), (left, right) => toNumber(checkIsTruthy(left) !== checkIsTruthy(right)))
+};
+// src/services/shared/getOwnValue.ts
+const getOwnValue = (record, key) => Object.hasOwn(record, key) ? record[key] : void 0;
+// src/services/shared/getMathExpressionSignatures.ts
+const getMathExpressionSignatures = (name) => getOwnValue(MathExpressionFunctionMap, name);
+// src/services/compiler/getMathExpressionScalarCompute.ts
+const getMathExpressionScalarCompute = (name, key) => {
+	const signature = getMathExpressionSignatures(name)?.[0];
+	if (signature === void 0) return () => null;
+	const scalarCompute = signature[key];
+	if (scalarCompute !== void 0) return scalarCompute;
+	return (...values) => signature.compute(values);
+};
+// src/services/compiler/MathExpressionBitwiseAbsorptionMap.ts
+const MathExpressionBitwiseAbsorptionMap = {
+	["bitAnd"]: {
+		absorbs: 0,
+		result: 0
+	},
+	["bitOr"]: {
+		absorbs: -1,
+		result: -1
+	}
+};
+// src/services/compiler/node/compileBinary.ts
+const compileBinary = (node, context) => {
+	const { left, name, right } = node;
+	const compiledLeft = context.compile(left);
+	if (ADDITIVE_NAMES.includes(name) && right.type === "percentage" && !checkIsPercentageExpression(left)) {
+		const compiledPercent = context.compile(right.operand);
+		const sign = name === "add" ? 1 : -1;
+		const evaluate = (values, locals) => {
+			const base = compiledLeft.evaluate(values, locals);
+			const percent = compiledPercent.evaluate(values, locals);
+			if (base === null || percent === null) return null;
+			return base + sign * base * (percent / 100);
+		};
+		return {
+			evaluate,
+			isConstant: compiledLeft.isConstant && compiledPercent.isConstant
+		};
+	}
+	const compiledRight = context.compile(right);
+	const compute = getMathExpressionScalarCompute(name, "computeBinary");
+	const absorption = MathExpressionBitwiseAbsorptionMap[name];
+	const evaluate = (values, locals) => {
+		const leftValue = compiledLeft.evaluate(values, locals);
+		if (leftValue === null) return null;
+		if (absorption?.absorbs === leftValue) return absorption.result;
+		const rightValue = compiledRight.evaluate(values, locals);
+		if (rightValue === null) return null;
+		return compute(leftValue, rightValue);
+	};
+	return {
+		evaluate,
+		isConstant: compiledLeft.isConstant && compiledRight.isConstant
+	};
+};
+// src/services/shared/getMathExpressionParameterType.ts
+const getMathExpressionParameterType = (node) => node.type === "list" ? "list" : "number";
+// src/services/shared/checkIsMatchingKind.ts
+const checkIsMatchingKind = (parameterType, argumentType) => parameterType === "any" || parameterType === argumentType;
+// src/services/shared/getParameterType.ts
+const getParameterType = (signature, index) => signature.parameters[Math.min(index, signature.parameters.length - 1)];
+// src/services/shared/checkIsMatching.ts
+const checkIsMatching = (signature, parameterTypes) => parameterTypes.length >= signature.minArity && parameterTypes.length <= signature.maxArity && parameterTypes.every((parameterType, index) => checkIsMatchingKind(getParameterType(signature, index), parameterType));
+// src/services/shared/matchMathExpressionSignature.ts
+const matchMathExpressionSignature = (signatures, parameterTypes) => signatures.find((signature) => checkIsMatching(signature, parameterTypes));
+// src/services/compiler/node/compileCall.ts
+const compileCall = (node, context) => {
+	const signatures = getMathExpressionSignatures(node.name);
+	const parameterTypes = node.arguments.map((argument) => getMathExpressionParameterType(argument));
+	const signature = matchMathExpressionSignature(signatures ?? [], parameterTypes);
+	const compute = signature?.compute ?? (() => null);
+	const computeUnary = signature?.computeUnary;
+	const computeBinary = signature?.computeBinary;
+	const compiledArguments = node.arguments.map((argument) => compileArgument(argument, context));
+	const isConstant = compiledArguments.every((argument) => argument.isConstant);
+	const [first, second] = compiledArguments;
+	if (compiledArguments.length === 1 && first !== void 0) return {
+		evaluate: (values, locals) => {
+			const firstValue = first.evaluate(values, locals);
+			if (firstValue === null) return null;
+			if (computeUnary !== void 0 && typeof firstValue === "number") return computeUnary(firstValue);
+			return compute([firstValue]);
+		},
+		isConstant
+	};
+	if (compiledArguments.length === 2 && first !== void 0 && second !== void 0) return {
+		evaluate: (values, locals) => {
+			const firstValue = first.evaluate(values, locals);
+			if (firstValue === null) return null;
+			const secondValue = second.evaluate(values, locals);
+			if (secondValue === null) return null;
+			if (computeBinary !== void 0 && typeof firstValue === "number" && typeof secondValue === "number") return computeBinary(firstValue, secondValue);
+			return compute([firstValue, secondValue]);
+		},
+		isConstant
+	};
+	return {
+		evaluate: (values, locals) => {
+			const argumentValues = [];
+			for (const argument of compiledArguments) {
+				const argumentValue = argument.evaluate(values, locals);
+				if (argumentValue === null) return null;
+				argumentValues.push(argumentValue);
+			}
+			return compute(argumentValues);
+		},
+		isConstant
+	};
+};
+// src/services/compiler/node/compileComparison.ts
+const compileComparison = (node, context) => {
+	const compiledOperands = node.operands.map((operand) => context.compile(operand));
+	const computes = node.names.map((name) => getMathExpressionScalarCompute(name, "computeBinary"));
+	const evaluate = (values, locals) => {
+		let left = compiledOperands[0]?.evaluate(values, locals) ?? null;
+		let result = 1;
+		for (const [index, compute] of computes.entries()) {
+			const right = compiledOperands[index + 1]?.evaluate(values, locals) ?? null;
+			if (left === null || right === null) return null;
+			result = compute(left, right);
+			if (result !== 1) return result;
+			left = right;
+		}
+		return result;
+	};
+	return {
+		evaluate,
+		isConstant: compiledOperands.every((operand) => operand.isConstant)
+	};
+};
+// src/services/compiler/node/compileConditional.ts
+const compileConditional = (node, context) => {
+	const compiledCondition = context.compile(node.condition);
+	const compiledWhenTrue = context.compile(node.whenTrue);
+	const compiledWhenFalse = context.compile(node.whenFalse);
+	const evaluate = (values, locals) => {
+		const test = compiledCondition.evaluate(values, locals);
+		if (test === null) return null;
+		return checkIsTruthy(test) ? compiledWhenTrue.evaluate(values, locals) : compiledWhenFalse.evaluate(values, locals);
+	};
+	return {
+		evaluate,
+		isConstant: compiledCondition.isConstant && compiledWhenTrue.isConstant && compiledWhenFalse.isConstant
+	};
+};
+// src/services/compiler/node/compileGroup.ts
+const compileGroup = (node, context) => context.compile(node.operand);
+// src/services/compiler/node/compileListNode.ts
+const compileListNode = () => ({
+	evaluate: () => null,
+	isConstant: false
+});
+// src/services/compiler/node/compileLogical.ts
+const compileLogical = (node, context) => {
+	const compiledLeft = context.compile(node.left);
+	if (node.operator === "nullish") return compiledLeft;
+	const compiledRight = context.compile(node.right);
+	const isConstant = compiledLeft.isConstant && compiledRight.isConstant;
+	switch (node.operator) {
+		case "and": return {
+			evaluate: (values, locals) => {
+				const leftValue = compiledLeft.evaluate(values, locals);
+				if (leftValue === null) return null;
+				if (!checkIsTruthy(leftValue)) return 0;
+				const rightValue = compiledRight.evaluate(values, locals);
+				return rightValue === null ? null : toNumber(checkIsTruthy(rightValue));
+			},
+			isConstant
+		};
+		case "or": return {
+			evaluate: (values, locals) => {
+				const leftValue = compiledLeft.evaluate(values, locals);
+				if (leftValue === null) return null;
+				if (checkIsTruthy(leftValue)) return 1;
+				const rightValue = compiledRight.evaluate(values, locals);
+				return rightValue === null ? null : toNumber(checkIsTruthy(rightValue));
+			},
+			isConstant
+		};
+		default: return exhaustiveGuard(node.operator);
+	}
+};
+// src/services/shared/MathExpressionConstantMap.ts
+const MathExpressionConstantMap = {
+	E: Math.E,
+	e: Math.E,
+	false: 0,
+	Infinity: Number.POSITIVE_INFINITY,
+	LN2: Math.LN2,
+	LN10: Math.LN10,
+	LOG2E: Math.LOG2E,
+	LOG10E: Math.LOG10E,
+	NaN: NaN,
+	phi: (1 + Math.sqrt(5)) / 2,
+	PI: Math.PI,
+	pi: Math.PI,
+	SQRT1_2: Math.SQRT1_2,
+	SQRT2: Math.SQRT2,
+	tau: 2 * Math.PI,
+	true: 1
+};
+// src/services/compiler/getMathExpressionConstant.ts
+const getMathExpressionConstant = (name) => getOwnValue(MathExpressionConstantMap, name);
+// src/services/compiler/node/compileName.ts
+const compileName = (node, context) => {
+	const slot = context.assignedSlots.get(node.name);
+	if (slot !== void 0) return {
+		evaluate: (_values, locals) => locals[slot] ?? null,
+		isConstant: false
+	};
+	const index = context.variableIndices.get(node.name);
+	if (index !== void 0) return {
+		evaluate: (values) => values[index] ?? NaN,
+		isConstant: false
+	};
+	const constant = getMathExpressionConstant(node.name);
+	return {
+		evaluate: () => constant ?? null,
+		isConstant: true
+	};
+};
+// src/services/compiler/node/compileNumber.ts
+const compileNumber = (node) => {
+	const { value } = node;
+	return {
+		evaluate: () => value,
+		isConstant: true
+	};
+};
+// src/services/compiler/node/compilePercentage.ts
+const compilePercentage = (node, context) => {
+	const compiledOperand = context.compile(node.operand);
+	return {
+		evaluate: (values, locals) => {
+			const operandValue = compiledOperand.evaluate(values, locals);
+			return operandValue === null ? null : operandValue / 100;
+		},
+		isConstant: compiledOperand.isConstant
+	};
+};
+// src/services/compiler/node/compileUnary.ts
+const compileUnary = (node, context) => {
+	const compute = getMathExpressionScalarCompute(node.name, "computeUnary");
+	const compiledOperand = context.compile(node.operand);
+	return {
+		evaluate: (values, locals) => {
+			const operandValue = compiledOperand.evaluate(values, locals);
+			return operandValue === null ? null : compute(operandValue);
+		},
+		isConstant: compiledOperand.isConstant
+	};
+};
+// src/services/compiler/MathExpressionNodeCompileMap.ts
+const MathExpressionNodeCompileMap = {
+	["assignment"]: compileAssignment,
+	["binary"]: compileBinary,
+	["call"]: compileCall,
+	["comparison"]: compileComparison,
+	["conditional"]: compileConditional,
+	["group"]: compileGroup,
+	["list"]: compileListNode,
+	["logical"]: compileLogical,
+	["name"]: compileName,
+	["number"]: compileNumber,
+	["percentage"]: compilePercentage,
+	["unary"]: compileUnary
+};
+// src/services/compiler/compileMathExpressionNode.ts
+const compileMathExpressionNode = (node, context) => {
+	const compileOfType = MathExpressionNodeCompileMap[node.type];
+	const compiled = compileOfType(node, context);
+	if (!compiled.isConstant) return compiled;
+	const value = compiled.evaluate(NO_VALUES, NO_LOCALS);
+	return {
+		evaluate: () => value,
+		isConstant: true
+	};
+};
+// src/services/compiler/getMathExpressionOuterValue.ts
+const getMathExpressionOuterValue = (outer, values) => {
+	if (outer.variableIndex !== void 0) return values[outer.variableIndex] ?? NaN;
+	return outer.constant ?? null;
+};
+// src/services/compiler/compileMathExpression.ts
+const compileMathExpression = (node, variableNames) => {
+	const assignedNames = /* @__PURE__ */ new Set();
+	collectMathExpressionAssignedNames(node, assignedNames);
+	const assignedSlots = new Map(Array.from(assignedNames, (name, slot) => [name, slot]));
+	const variableIndices = new Map(variableNames.map((name, index) => [name, index]));
+	const context = {
+		assignedSlots,
+		compile: (child) => compileMathExpressionNode(child, context),
+		variableIndices
+	};
+	const compiled = context.compile(node);
+	const outerBindings = Array.from(assignedNames, (name) => ({
+		constant: getMathExpressionConstant(name),
+		variableIndex: variableIndices.get(name)
+	}));
+	return (values) => {
+		const locals = outerBindings.length === 0 ? NO_LOCALS : outerBindings.map((outer) => getMathExpressionOuterValue(outer, values));
+		return compiled.evaluate(values, locals) ?? NaN;
+	};
+};
+// src/services/names/walkNode.ts
+const walkNode = (node, bound, free) => {
+	switch (node.type) {
+		case "assignment":
+			walkNode(node.value, bound, free);
+			bound.add(node.name);
+			return;
+		case "binary": {
+			walkNode(node.left, bound, free);
+			const rightBound = Object.hasOwn(MathExpressionBitwiseAbsorptionMap, node.name) ? new Set(bound) : bound;
+			walkNode(node.right, rightBound, free);
+			return;
+		}
+		case "call":
+		case "group":
+		case "list":
+		case "number":
+		case "percentage":
+		case "unary":
+			for (const child of getMathExpressionChildren(node)) walkNode(child, bound, free);
+			return;
+		case "comparison": {
+			let chainBound = bound;
+			for (const [index, operand] of node.operands.entries()) {
+				if (index === 2) chainBound = new Set(bound);
+				walkNode(operand, chainBound, free);
+			}
+			return;
+		}
+		case "conditional": {
+			walkNode(node.condition, bound, free);
+			const whenTrueBound = new Set(bound);
+			const whenFalseBound = new Set(bound);
+			walkNode(node.whenTrue, whenTrueBound, free);
+			walkNode(node.whenFalse, whenFalseBound, free);
+			for (const name of whenTrueBound) if (whenFalseBound.has(name)) bound.add(name);
+			return;
+		}
+		case "logical":
+			walkNode(node.left, bound, free);
+			if (node.operator !== "nullish") walkNode(node.right, new Set(bound), free);
+			return;
+		case "name":
+			if (!bound.has(node.name)) free.add(node.name);
+			return;
+		default: return exhaustiveGuard(node);
+	}
+};
+// src/services/names/getMathExpressionNames.ts
+const getMathExpressionNames = (node) => {
+	const bound = /* @__PURE__ */ new Set();
+	const free = /* @__PURE__ */ new Set();
+	walkNode(node, bound, free);
+	return [...free].filter((name) => getMathExpressionConstant(name) === void 0);
+};
+// src/services/parser/constants.ts
+const MAX_MATH_EXPRESSION_DEPTH = 64;
+const PLACEHOLDER = {
+	type: "number",
+	value: NaN
+};
+// src/services/parser/failMathExpressionAt.ts
+const failMathExpressionAt = (state, message, column) => {
+	if (state.error !== null) return;
+	state.error = new MathExpressionError(`${message} (char ${column})`);
+};
+// src/services/parser/getMathExpressionColumn.ts
+const getMathExpressionColumn = (state) => state.index - state.token.length + 1;
+// src/services/parser/failMathExpression.ts
+const failMathExpression = (state, message) => {
+	failMathExpressionAt(state, message, getMathExpressionColumn(state));
+};
+// src/services/parser/checkCanMathExpressionNest.ts
+const checkCanMathExpressionNest = (state) => {
+	if (state.depth < 64) return true;
+	failMathExpression(state, `Formula nests deeper than 64 levels`);
+	return false;
+};
+// src/services/parser/checkIsOperatorOperand.ts
+const checkIsOperatorOperand = (node) => {
+	if (node.type === "unary") return node.name !== "factorial";
+	return node.type === "binary" || node.type === "comparison" || node.type === "logical";
+};
+// src/services/parser/checkIsToken.ts
+const checkIsToken = (state, token) => state.token === token;
+// src/services/parser/checkIsFactorStart.ts
+const checkIsFactorStart = (state, last) => {
+	if (last.type === "percentage") return false;
+	if (state.tokenType === "symbol" || checkIsToken(state, "(")) return true;
+	return state.tokenType === "number" && last.type !== "number" && !checkIsOperatorOperand(last);
+};
+// src/services/parser/checkIsNameToken.ts
+const checkIsNameToken = (state) => state.tokenType === "symbol" || state.tokenType === "delimiter" && getMathExpressionSignatures(state.token) !== void 0;
+// src/services/parser/token/MathExpressionRadixMap.ts
+const MathExpressionRadixMap = {
+	["b"]: {
+		digit: /^[01]$/u,
+		radix: 2
+	},
+	["x"]: {
+		digit: /^[0-9a-fA-F]$/u,
+		radix: 16
+	},
+	["o"]: {
+		digit: /^[0-7]$/u,
+		radix: 8
+	}
+};
+// src/services/parser/computeNumberLiteral.ts
+const computeNumberLiteral = (token) => {
+	const radixEntry = MathExpressionRadixMap[token.charAt(1)];
+	if (!token.startsWith("0") || radixEntry === void 0) return Number(token);
+	const { radix } = radixEntry;
+	const [digits = "", wordSize] = token.slice(2).split("i");
+	const [integerDigits = "", fractionDigits = ""] = digits.split(".");
+	let value = 0;
+	for (const digit of integerDigits) value = value * radix + Number.parseInt(digit, radix);
+	let scale = 1 / radix;
+	for (const digit of fractionDigits) {
+		value += Number.parseInt(digit, radix) * scale;
+		scale /= radix;
+	}
+	if (wordSize === void 0) return value;
+	const bits = Number(wordSize);
+	if (value > 2 ** bits - 1) return null;
+	return value >= 2 ** (bits - 1) ? value - 2 ** bits : value;
+};
+// src/services/parser/createBinaryNode.ts
+const createBinaryNode = (left, name, right) => ({
+	left,
+	name,
+	right,
+	type: "binary"
+});
+// src/services/parser/createLogicalNode.ts
+const createLogicalNode = (left, operator, right) => ({
+	left,
+	operator,
+	right,
+	type: "logical"
+});
+// src/services/parser/createBinaryOperation.ts
+const createBinaryOperation = (left, operator, right) => {
+	if (operator.type === "logical") return createLogicalNode(left, operator.operator, right);
+	if (operator.type === "binary") return createBinaryNode(left, operator.name, right);
+	if (left.type === "comparison") {
+		left.names.push(operator.name);
+		left.operands.push(right);
+		return left;
+	}
+	return {
+		names: [operator.name],
+		operands: [left, right],
+		type: "comparison"
+	};
+};
+// src/services/parser/getArgumentCountText.ts
+const getArgumentCountText = (count) => `${count} ${count === 1 ? "argument" : "arguments"}`;
+// src/services/parser/getMathExpressionArityMessage.ts
+const getMathExpressionArityMessage = (name, minArity, maxArity) => {
+	if (maxArity === Number.POSITIVE_INFINITY) return `"${name}" takes at least ${getArgumentCountText(minArity)}`;
+	if (minArity === maxArity) return `"${name}" takes ${getArgumentCountText(minArity)}`;
+	return `"${name}" takes ${minArity} or ${maxArity} arguments`;
+};
+// src/services/parser/getMathExpressionSignatureError.ts
+const getMathExpressionSignatureError = (name, signatures, parameterTypes) => {
+	const count = parameterTypes.length;
+	if (signatures.filter((signature) => count >= signature.minArity && count <= signature.maxArity).length === 0) return getMathExpressionArityMessage(name, Math.min(...signatures.map((signature) => signature.minArity)), Math.max(...signatures.map((signature) => signature.maxArity)));
+	if (parameterTypes.includes("list")) return `"${name}" does not take a list argument`;
+	return `"${name}" takes a list argument`;
+};
+// src/services/parser/token/checkIsDigitCharacter.ts
+const checkIsDigitCharacter = (character) => character >= "0" && character <= "9";
+// src/services/parser/token/constants.ts
+const SYMBOLIC_BINARY_SYMBOLS = Object.values(MathExpressionBinaryOperatorSymbol).filter((symbol) => !/\p{L}/u.test(symbol));
+const SYMBOLIC_BINARY_SYMBOLS_OF_THREE = SYMBOLIC_BINARY_SYMBOLS.filter((symbol) => symbol.length === 3);
+const SYMBOLIC_BINARY_SYMBOLS_OF_TWO = SYMBOLIC_BINARY_SYMBOLS.filter((symbol) => symbol.length === 2);
+const SYMBOLIC_BINARY_SYMBOLS_OF_ONE = SYMBOLIC_BINARY_SYMBOLS.filter((symbol) => symbol.length === 1);
+const DELIMITERS_OF_THREE = new Set(SYMBOLIC_BINARY_SYMBOLS_OF_THREE);
+const DELIMITERS_OF_TWO = /* @__PURE__ */ new Set([
+	...SYMBOLIC_BINARY_SYMBOLS_OF_TWO,
+	".^",
+	"??"
+]);
+const DELIMITERS_OF_ONE = /* @__PURE__ */ new Set([
+	...SYMBOLIC_BINARY_SYMBOLS_OF_ONE,
+	"!",
+	"%",
+	"'",
+	"(",
+	")",
+	",",
+	":",
+	"=",
+	"?",
+	"[",
+	"]",
+	"^",
+	"~"
+]);
+const FIRST_CHARACTERS_OF_THREE = new Set(Array.from(DELIMITERS_OF_THREE, (delimiter) => delimiter.charAt(0)));
+const FIRST_CHARACTERS_OF_TWO = new Set(Array.from(DELIMITERS_OF_TWO, (delimiter) => delimiter.charAt(0)));
+const NAMED_DELIMITERS = /* @__PURE__ */ new Set([
+	"in",
+	"and",
+	"or",
+	"xor",
+	"mod",
+	"not",
+	"to"
+]);
+const DECIMAL_MARK_OPERATOR_FOLLOWERS = /* @__PURE__ */ new Set([
+	"^",
+	"/",
+	"*"
+]);
+const WORD_START_REGEX = /^[\p{L}_$]$/u;
+const WORD_CHARACTER_REGEX = /^[\p{L}\p{Nd}_$]$/u;
+// src/services/parser/token/checkIsWordStartCharacter.ts
+const checkIsWordStartCharacter = (character) => {
+	if (character >= "€") return WORD_START_REGEX.test(character);
+	return character >= "a" && character <= "z" || character >= "A" && character <= "Z" || character === "_" || character === "$";
+};
+// src/services/parser/token/getMathExpressionCharacter.ts
+const getMathExpressionCharacter = (state, offset) => state.source.charAt(state.index + offset);
+// src/services/parser/token/readMathExpressionDelimiter.ts
+const readMathExpressionDelimiter = (state) => {
+	const character = getMathExpressionCharacter(state, 0);
+	let length = 0;
+	if (FIRST_CHARACTERS_OF_THREE.has(character) && DELIMITERS_OF_THREE.has(state.source.slice(state.index, state.index + 3))) length = 3;
+	else if (FIRST_CHARACTERS_OF_TWO.has(character) && DELIMITERS_OF_TWO.has(state.source.slice(state.index, state.index + 2))) length = 2;
+	else if (DELIMITERS_OF_ONE.has(character)) length = 1;
+	if (length === 0) return 0;
+	state.token = state.source.slice(state.index, state.index + length);
+	state.index += length;
+	state.tokenType = "delimiter";
+	if (["(", "["].includes(state.token)) state.nestingLevel++;
+	if ([")", "]"].includes(state.token)) state.nestingLevel--;
+	return length;
+};
+// src/services/parser/token/takeMathExpressionMatching.ts
+const takeMathExpressionMatching = (state, checkCharacter) => {
+	const start = state.index;
+	while (checkCharacter(getMathExpressionCharacter(state, 0))) state.index++;
+	return state.source.slice(start, state.index);
+};
+// src/services/parser/token/readRadixNumber.ts
+const readRadixNumber = (state, prefix, baseDigits) => {
+	const checkBaseDigit = (character) => baseDigits.test(character);
+	state.index += 2;
+	let digits = takeMathExpressionMatching(state, checkBaseDigit);
+	if (digits === "") {
+		state.index--;
+		state.token = "0";
+		state.tokenType = "number";
+		return;
+	}
+	if (getMathExpressionCharacter(state, 0) === ".") {
+		state.index++;
+		digits += `.${takeMathExpressionMatching(state, checkBaseDigit)}`;
+	}
+	let wordSize = "";
+	if (getMathExpressionCharacter(state, 0) === "i" && checkIsDigitCharacter(getMathExpressionCharacter(state, 1))) {
+		state.index++;
+		wordSize = `i${takeMathExpressionMatching(state, checkIsDigitCharacter)}`;
+	}
+	state.token = `0${prefix}${digits}${wordSize}`;
+	state.tokenType = "number";
+};
+// src/services/parser/token/checkIsDecimalMark.ts
+const checkIsDecimalMark = (character, nextCharacter) => character === "." && !DECIMAL_MARK_OPERATOR_FOLLOWERS.has(nextCharacter);
+// src/services/parser/token/failExponent.ts
+const failExponent = (state, text) => {
+	state.token = text;
+	failMathExpression(state, `Digit expected, got "${getMathExpressionCharacter(state, 0)}"`);
+};
+// src/services/parser/token/takeExponent.ts
+const takeExponent = (state, text) => {
+	const exponentMarker = getMathExpressionCharacter(state, 0);
+	if (!["e", "E"].includes(exponentMarker)) return text;
+	const afterMarker = getMathExpressionCharacter(state, 1);
+	if (checkIsDecimalMark(afterMarker, getMathExpressionCharacter(state, 2))) {
+		state.index++;
+		failExponent(state, text);
+		return text;
+	}
+	if (!checkIsDigitCharacter(afterMarker) && !["+", "-"].includes(afterMarker)) return text;
+	state.index++;
+	let exponent = "e";
+	if (["+", "-"].includes(afterMarker)) {
+		exponent += afterMarker;
+		state.index++;
+	}
+	if (!checkIsDigitCharacter(getMathExpressionCharacter(state, 0))) {
+		const partial = text + exponent;
+		failExponent(state, partial);
+		return partial;
+	}
+	const taken = text + exponent + takeMathExpressionMatching(state, checkIsDigitCharacter);
+	if (checkIsDecimalMark(getMathExpressionCharacter(state, 0), getMathExpressionCharacter(state, 1))) failExponent(state, taken);
+	return taken;
+};
+// src/services/parser/token/readMathExpressionNumber.ts
+const readMathExpressionNumber = (state) => {
+	const prefix = getMathExpressionCharacter(state, 1);
+	const radixEntry = MathExpressionRadixMap[prefix];
+	if (getMathExpressionCharacter(state, 0) === "0" && radixEntry !== void 0) {
+		readRadixNumber(state, prefix, radixEntry.digit);
+		return;
+	}
+	const start = state.index;
+	takeMathExpressionMatching(state, checkIsDigitCharacter);
+	if (getMathExpressionCharacter(state, 0) === ".") {
+		state.index++;
+		takeMathExpressionMatching(state, checkIsDigitCharacter);
+	}
+	state.token = takeExponent(state, state.source.slice(start, state.index));
+	state.tokenType = "number";
+};
+// src/services/parser/token/checkIsWordCharacter.ts
+const checkIsWordCharacter = (character) => {
+	if (character >= "€") return WORD_CHARACTER_REGEX.test(character);
+	return checkIsWordStartCharacter(character) || checkIsDigitCharacter(character);
+};
+// src/services/parser/token/readMathExpressionWord.ts
+const readMathExpressionWord = (state) => {
+	state.token = takeMathExpressionMatching(state, checkIsWordCharacter);
+	state.tokenType = NAMED_DELIMITERS.has(state.token) ? "delimiter" : "symbol";
+};
+// src/services/parser/token/skipMathExpressionSpaces.ts
+const skipMathExpressionSpaces = (state) => {
+	while (state.index < state.source.length) {
+		const character = getMathExpressionCharacter(state, 0);
+		if ([
+			" ",
+			"	",
+			"\xA0"
+		].includes(character) || character === "\n" && state.nestingLevel > 0) state.index++;
+		else if (character === "#") while (state.index < state.source.length && getMathExpressionCharacter(state, 0) !== "\n") state.index++;
+		else break;
+	}
+};
+// src/services/parser/getMathExpressionToken.ts
+const getMathExpressionToken = (state) => {
+	state.token = "";
+	state.tokenType = "null";
+	skipMathExpressionSpaces(state);
+	if (state.index >= state.source.length || state.error !== null) return;
+	const character = getMathExpressionCharacter(state, 0);
+	const next = getMathExpressionCharacter(state, 1);
+	if (checkIsDigitCharacter(character) || character === "." && checkIsDigitCharacter(next)) readMathExpressionNumber(state);
+	else if (checkIsWordStartCharacter(character)) readMathExpressionWord(state);
+	else if (readMathExpressionDelimiter(state) === 0) {
+		state.token = character;
+		state.index++;
+		state.tokenType = "unknown";
+	}
+};
+// src/services/parser/MathExpressionBinaryOperatorMap.ts
+const MathExpressionBinaryOperatorMap = {
+	["+"]: {
+		name: "add",
+		power: 9,
+		type: "binary"
+	},
+	["and"]: {
+		operator: "and",
+		power: 3,
+		type: "logical"
+	},
+	["&"]: {
+		name: "bitAnd",
+		power: 6,
+		type: "binary"
+	},
+	["|"]: {
+		name: "bitOr",
+		power: 4,
+		type: "binary"
+	},
+	["^|"]: {
+		name: "bitXor",
+		power: 5,
+		type: "binary"
+	},
+	["/"]: {
+		name: "divide",
+		power: 10,
+		type: "binary"
+	},
+	["./"]: {
+		name: "dotDivide",
+		power: 10,
+		type: "binary"
+	},
+	[".*"]: {
+		name: "dotMultiply",
+		power: 10,
+		type: "binary"
+	},
+	["=="]: {
+		name: "equal",
+		power: 7,
+		type: "comparison"
+	},
+	[">"]: {
+		name: "larger",
+		power: 7,
+		type: "comparison"
+	},
+	[">="]: {
+		name: "largerEq",
+		power: 7,
+		type: "comparison"
+	},
+	["<"]: {
+		name: "smaller",
+		power: 7,
+		type: "comparison"
+	},
+	["<="]: {
+		name: "smallerEq",
+		power: 7,
+		type: "comparison"
+	},
+	["*"]: {
+		name: "multiply",
+		power: 10,
+		type: "binary"
+	},
+	["!="]: {
+		name: "unequal",
+		power: 7,
+		type: "comparison"
+	},
+	["or"]: {
+		operator: "or",
+		power: 1,
+		type: "logical"
+	},
+	["<<"]: {
+		name: "leftShift",
+		power: 8,
+		type: "binary"
+	},
+	[">>"]: {
+		name: "rightArithShift",
+		power: 8,
+		type: "binary"
+	},
+	["-"]: {
+		name: "subtract",
+		power: 9,
+		type: "binary"
+	},
+	[">>>"]: {
+		name: "rightLogShift",
+		power: 8,
+		type: "binary"
+	},
+	["xor"]: {
+		name: "xor",
+		power: 2,
+		type: "binary"
+	}
+};
+// src/services/parser/MathExpressionOperatorMap.ts
+const MathExpressionOperatorMap = {
+	["Nullish"]: { "??": "nullish" },
+	["Power"]: {
+		".^": "dotPow",
+		"^": "pow"
+	},
+	["Unary"]: {
+		"+": "unaryPlus",
+		"-": "unaryMinus",
+		not: "not",
+		"~": "bitNot"
+	}
+};
+// src/services/parser/rule/parseAssignment.ts
+const parseAssignment = (state, parse) => {
+	if (!checkCanMathExpressionNest(state)) return PLACEHOLDER;
+	state.depth++;
+	const left = parse(state, "Conditional");
+	let node = left;
+	if (state.error === null && checkIsToken(state, "=")) if (left.type === "name") {
+		getMathExpressionToken(state);
+		const value = parse(state, "Assignment");
+		node = {
+			name: left.name,
+			type: "assignment",
+			value
+		};
+	} else failMathExpression(state, "Invalid left hand side of assignment operator =");
+	state.depth--;
+	return node;
+};
+// src/services/parser/parseBinaryOperators.ts
+const parseBinaryOperators = (state, parse, minimumPower) => {
+	let node = parse(state, "Percentage");
+	let last = node;
+	while (state.error === null) {
+		const isImplicit = checkIsFactorStart(state, last);
+		const operator = isImplicit ? MathExpressionBinaryOperatorMap["*"] : getOwnValue(MathExpressionBinaryOperatorMap, state.token);
+		if (operator === void 0 || operator.power < minimumPower) break;
+		if (!isImplicit) getMathExpressionToken(state);
+		last = parseBinaryOperators(state, parse, operator.power + 1);
+		node = createBinaryOperation(node, operator, last);
+	}
+	return node;
+};
+// src/services/parser/rule/parseBinary.ts
+const parseBinary = (state, parse) => parseBinaryOperators(state, parse, 0);
+// src/services/parser/rule/parseConditional.ts
+const parseConditional = (state, parse) => {
+	const condition = parse(state, "Binary");
+	if (state.error !== null || !checkIsToken(state, "?")) return condition;
+	getMathExpressionToken(state);
+	if (checkIsToken(state, ":")) {
+		failMathExpression(state, "The true-expression of a conditional operator may not be empty");
+		return PLACEHOLDER;
+	}
+	const whenTrue = parse(state, "Assignment");
+	if (state.error === null && !checkIsToken(state, ":")) failMathExpression(state, "False part of conditional expression expected");
+	if (state.error !== null) return PLACEHOLDER;
+	getMathExpressionToken(state);
+	state.depth++;
+	const whenFalse = parse(state, "Conditional");
+	state.depth--;
+	return {
+		condition,
+		type: "conditional",
+		whenFalse,
+		whenTrue
+	};
+};
+// src/services/parser/rule/parseLeftHand.ts
+const parseLeftHand = (state, parse) => {
+	let node = parse(state, "Symbol");
+	while (state.error === null && (checkIsToken(state, "!") || checkIsToken(state, "'"))) {
+		const name = checkIsToken(state, "!") ? "factorial" : "ctranspose";
+		getMathExpressionToken(state);
+		node = {
+			name,
+			operand: node,
+			type: "unary"
+		};
+	}
+	return node;
+};
+// src/services/parser/rule/parseNullish.ts
+const parseNullish = (state, parse) => {
+	const operators = MathExpressionOperatorMap["Nullish"];
+	let node = parse(state, "LeftHand");
+	let operator = getOwnValue(operators, state.token);
+	while (state.error === null && operator !== void 0) {
+		getMathExpressionToken(state);
+		const right = parse(state, "LeftHand");
+		node = createLogicalNode(node, operator, right);
+		operator = getOwnValue(operators, state.token);
+	}
+	return node;
+};
+// src/services/parser/rule/parsePercentage.ts
+const parsePercentage = (state, parse) => {
+	const node = parse(state, "Unary");
+	if (state.error !== null || !checkIsToken(state, "%")) return node;
+	getMathExpressionToken(state);
+	return {
+		operand: node,
+		type: "percentage"
+	};
+};
+// src/services/parser/rule/parsePower.ts
+const parsePower = (state, parse) => {
+	const base = parse(state, "Nullish");
+	const name = getOwnValue(MathExpressionOperatorMap["Power"], state.token);
+	if (state.error !== null || name === void 0) return base;
+	if (!checkCanMathExpressionNest(state)) return PLACEHOLDER;
+	getMathExpressionToken(state);
+	state.depth++;
+	const exponent = parse(state, "Unary");
+	state.depth--;
+	return createBinaryNode(base, name, exponent);
+};
+// src/services/parser/parseSequence.ts
+const parseSequence = (state, closing, parseItem) => {
+	const nodes = [];
+	if (checkIsToken(state, closing)) return nodes;
+	while (state.error === null) {
+		nodes.push(parseItem(state));
+		if (!checkIsToken(state, ",")) break;
+		getMathExpressionToken(state);
+	}
+	if (state.error === null && !checkIsToken(state, closing)) failMathExpression(state, closing === ")" ? "Parenthesis ) expected" : "Parenthesis ] expected");
+	return nodes;
+};
+// src/services/parser/parseList.ts
+const parseList = (state, parse) => {
+	getMathExpressionToken(state);
+	const elements = parseSequence(state, "]", (item) => parse(item, "Assignment"));
+	if (state.error !== null) return PLACEHOLDER;
+	getMathExpressionToken(state);
+	return {
+		elements,
+		type: "list"
+	};
+};
+// src/services/parser/parseArgument.ts
+const parseArgument = (state, parse) => checkIsToken(state, "[") ? parseList(state, parse) : parse(state, "Assignment");
+// src/services/parser/parseCall.ts
+const parseCall = (state, name, column, parse) => {
+	const signatures = getMathExpressionSignatures(name);
+	if (signatures === void 0) {
+		failMathExpressionAt(state, `Unknown function "${name}"`, column);
+		return PLACEHOLDER;
+	}
+	getMathExpressionToken(state);
+	const argumentNodes = parseSequence(state, ")", (argument) => parseArgument(argument, parse));
+	if (state.error !== null) return PLACEHOLDER;
+	getMathExpressionToken(state);
+	const parameterTypes = argumentNodes.map((argument) => getMathExpressionParameterType(argument));
+	if (matchMathExpressionSignature(signatures, parameterTypes) === void 0) {
+		failMathExpressionAt(state, getMathExpressionSignatureError(name, signatures, parameterTypes), column);
+		return PLACEHOLDER;
+	}
+	return {
+		arguments: argumentNodes,
+		name,
+		type: "call"
+	};
+};
+// src/services/parser/rule/parseSymbol.ts
+const parseSymbol = (state, parse) => {
+	if (state.tokenType === "number") {
+		const value = computeNumberLiteral(state.token);
+		if (value === null) {
+			failMathExpression(state, `String "${state.token.split("i")[0]}" is out of range`);
+			getMathExpressionToken(state);
+			return PLACEHOLDER;
+		}
+		getMathExpressionToken(state);
+		return {
+			type: "number",
+			value
+		};
+	}
+	if (checkIsNameToken(state)) {
+		const name = state.token;
+		const column = getMathExpressionColumn(state);
+		const isSymbol = state.tokenType === "symbol";
+		getMathExpressionToken(state);
+		if (checkIsToken(state, "(")) return parseCall(state, name, column, parse);
+		if (isSymbol) return {
+			name,
+			type: "name"
+		};
+	}
+	if (checkIsToken(state, "(")) {
+		getMathExpressionToken(state);
+		const operand = parse(state, "Assignment");
+		if (state.error === null && !checkIsToken(state, ")")) failMathExpression(state, "Parenthesis ) expected");
+		if (state.error !== null) return PLACEHOLDER;
+		getMathExpressionToken(state);
+		return {
+			operand,
+			type: "group"
+		};
+	}
+	failMathExpression(state, checkIsToken(state, "") ? "Unexpected end of expression" : "Value expected");
+	return PLACEHOLDER;
+};
+// src/services/parser/rule/parseUnary.ts
+const parseUnary = (state, parse) => {
+	const name = getOwnValue(MathExpressionOperatorMap["Unary"], state.token);
+	if (name === void 0) return parse(state, "Power");
+	if (!checkCanMathExpressionNest(state)) return PLACEHOLDER;
+	getMathExpressionToken(state);
+	state.depth++;
+	const operand = parse(state, "Unary");
+	state.depth--;
+	return {
+		name,
+		operand,
+		type: "unary"
+	};
+};
+// src/services/parser/MathExpressionRuleParserMap.ts
+const MathExpressionRuleParserMap = {
+	["Assignment"]: parseAssignment,
+	["Binary"]: parseBinary,
+	["Conditional"]: parseConditional,
+	["LeftHand"]: parseLeftHand,
+	["Nullish"]: parseNullish,
+	["Percentage"]: parsePercentage,
+	["Power"]: parsePower,
+	["Symbol"]: parseSymbol,
+	["Unary"]: parseUnary
+};
+// src/services/parser/parseMathExpressionRule.ts
+const parseMathExpressionRule = (state, rule) => MathExpressionRuleParserMap[rule](state, parseMathExpressionRule);
+// src/services/parser/parseMathExpression.ts
+const parseMathExpression = (formula) => {
+	const state = {
+		depth: 0,
+		error: null,
+		index: 0,
+		nestingLevel: 0,
+		source: formula,
+		token: "",
+		tokenType: "null"
+	};
+	getMathExpressionToken(state);
+	const node = parseMathExpressionRule(state, "Assignment");
+	if (state.error === null && !checkIsToken(state, "")) failMathExpression(state, state.tokenType === "delimiter" ? `Unexpected operator ${state.token}` : `Unexpected part "${state.token}"`);
+	return state.error === null ? ok(node) : err(state.error);
+};
+export { ADDITIVE_NAMES, DECIMAL_MARK_OPERATOR_FOLLOWERS, DELIMITERS_OF_ONE, DELIMITERS_OF_THREE, DELIMITERS_OF_TWO, FIRST_CHARACTERS_OF_THREE, FIRST_CHARACTERS_OF_TWO, LAST_FACTORIAL_ARGUMENT, MATH_EXPRESSION_ABSOLUTE_TOLERANCE, MATH_EXPRESSION_RELATIVE_TOLERANCE, MAXIMUM_DIGITS, MAX_MATH_EXPRESSION_DEPTH, MILLER_RABIN_BASES, MathExpressionBinaryOperatorMap, MathExpressionBinaryOperatorSymbol, MathExpressionBitwiseAbsorption, MathExpressionBitwiseAbsorptionMap, MathExpressionConstantMap, MathExpressionError, MathExpressionFunctionMap, MathExpressionFunctionName, MathExpressionGrammarRule, MathExpressionLogicalOperator, MathExpressionNodeCompileMap, MathExpressionNodeType, MathExpressionOperatorMap, MathExpressionParameterType, MathExpressionRadix, MathExpressionRadixMap, MathExpressionRuleParserMap, MathExpressionTokenType, NAMED_DELIMITERS, NO_LOCALS, NO_VALUES, OVERFLOW_ARGUMENT, PLACEHOLDER, SQRT_PI, STIRLING_TERMS, STIRLING_THRESHOLD, WORD_CHARACTER_REGEX, WORD_START_REGEX, checkCanMathExpressionNest, checkIsDecimalMark, checkIsDigitCharacter, checkIsFactorStart, checkIsLarger, checkIsMatching, checkIsMatchingKind, checkIsMillerRabinPassing, checkIsNameToken, checkIsNearlyEqual, checkIsOperatorOperand, checkIsPercentageExpression, checkIsPrime, checkIsSmaller, checkIsToken, checkIsTruthy, checkIsWordCharacter, checkIsWordStartCharacter, collectMathExpressionAssignedNames, compareNumbers, compileArgument, compileAssignment, compileBinary, compileCall, compileComparison, compileConditional, compileGroup, compileList, compileListNode, compileLogical, compileMathExpression, compileMathExpressionNode, compileName, compileNumber, compilePercentage, compileUnary, computeBitwiseAnd, computeBitwiseOr, computeCombinations, computeComparison, computeCompositions, computeCorrelation, computeDeterminant, computeDistance, computeDotProduct, computeErf, computeExtreme, computeFactorial, computeGamma, computeGreatestCommonDivisor, computeHypotenuse, computeIntegerGreatestCommonDivisor, computeInverseCoth, computeKullbackLeibler, computeLeastCommonMultiple, computeListComparison, computeLogGammaOfPositive, computeLogarithm, computeMean, computeMedian, computeMedianAbsoluteDeviation, computeModularInverse, computeModularPower, computeModulo, computeMultinomial, computeNorm, computeNthRoot, computeNumberLiteral, computePartitionSelect, computePermutations, computePointToLine2D, computePointToLine3D, computeProduct, computeProductOfRange, computeQuantile, computeStirlingLogGamma, computeSum, computeTruthyCount, computeVariance, computeVectorNorm, createBinaryNode, createBinaryOperation, createBinarySignatures, createBitwiseFold, createBitwisePair, createDigitSignatures, createExtremeSignatures, createIdentitySignatures, createIntegerBinarySignatures, createIntegerUnarySignatures, createListFirstCompute, createListPairCompute, createListPairSignature, createListSignature, createLogicalNode, createNonEmptyCompute, createNumberSignature, createNumericCompute, createOrderedListSignatures, createRangedSignatures, createSignature, createSingletonListSignature, createSpreadSignatures, createUnarySignatures, createVariadicSignatures, failExponent, failMathExpression, failMathExpressionAt, getArgumentCountText, getMathExpressionArityMessage, getMathExpressionCharacter, getMathExpressionChildren, getMathExpressionColumn, getMathExpressionConstant, getMathExpressionNames, getMathExpressionOuterValue, getMathExpressionParameterType, getMathExpressionScalarCompute, getMathExpressionSignatureError, getMathExpressionSignatures, getMathExpressionToken, getOwnValue, getParameterType, matchMathExpressionSignature, multiplyPair, parseArgument, parseAssignment, parseBinary, parseBinaryOperators, parseCall, parseConditional, parseLeftHand, parseList, parseMathExpression, parseMathExpressionRule, parseNullish, parsePercentage, parsePower, parseSequence, parseSymbol, parseUnary, readMathExpressionDelimiter, readMathExpressionNumber, readMathExpressionWord, readRadixNumber, roundToDigits, scaleList, shiftDecimalPlaces, skipMathExpressionSpaces, takeExponent, takeMathExpressionMatching, toNumber, walkNode };