math-expression-compiler 4.3.1 → 4.4.0

package/dist/index.js

@@ -1,2246 +0,0 @@
-import { exhaustiveGuard } from "@esposter/shared";
-import { err, ok } from "neverthrow";
-//#region src/models/function/MathExpressionFunctionName.ts
-let MathExpressionFunctionName = /* @__PURE__ */ function(MathExpressionFunctionName) {
-	MathExpressionFunctionName["CTranspose"] = "ctranspose";
-	MathExpressionFunctionName["Factorial"] = "factorial";
-	MathExpressionFunctionName["UnaryMinus"] = "unaryMinus";
-	MathExpressionFunctionName["UnaryPlus"] = "unaryPlus";
-	return MathExpressionFunctionName;
-}({});
-//#endregion
-//#region src/models/function/MathExpressionParameterType.ts
-let MathExpressionParameterType = /* @__PURE__ */ function(MathExpressionParameterType) {
-	MathExpressionParameterType["Any"] = "any";
-	MathExpressionParameterType["List"] = "list";
-	MathExpressionParameterType["Number"] = "number";
-	return MathExpressionParameterType;
-}({});
-//#endregion
-//#region src/models/parser/MathExpressionGrammarRule.ts
-let MathExpressionGrammarRule = /* @__PURE__ */ function(MathExpressionGrammarRule) {
-	MathExpressionGrammarRule["Assignment"] = "Assignment";
-	MathExpressionGrammarRule["Binary"] = "Binary";
-	MathExpressionGrammarRule["Conditional"] = "Conditional";
-	MathExpressionGrammarRule["DivisionBeforeProduct"] = "DivisionBeforeProduct";
-	MathExpressionGrammarRule["ImplicitProduct"] = "ImplicitProduct";
-	MathExpressionGrammarRule["LeftHand"] = "LeftHand";
-	MathExpressionGrammarRule["Nullish"] = "Nullish";
-	MathExpressionGrammarRule["Percentage"] = "Percentage";
-	MathExpressionGrammarRule["Power"] = "Power";
-	MathExpressionGrammarRule["Symbol"] = "Symbol";
-	MathExpressionGrammarRule["Unary"] = "Unary";
-	return MathExpressionGrammarRule;
-}({});
-//#endregion
-//#region 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;
-}({});
-//#endregion
-//#region src/models/shared/MathExpressionError.ts
-var MathExpressionError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "MathExpressionError";
-	}
-};
-//#endregion
-//#region src/models/shared/MathExpressionLogicalOperator.ts
-let MathExpressionLogicalOperator = /* @__PURE__ */ function(MathExpressionLogicalOperator) {
-	MathExpressionLogicalOperator["And"] = "and";
-	MathExpressionLogicalOperator["Nullish"] = "nullish";
-	MathExpressionLogicalOperator["Or"] = "or";
-	return MathExpressionLogicalOperator;
-}({});
-//#endregion
-//#region 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;
-}({});
-//#endregion
-//#region src/services/compiler/MathExpressionBitwiseAbsorptionMap.ts
-const MathExpressionBitwiseAbsorptionMap = {
-	bitAnd: {
-		absorbs: 0,
-		result: 0
-	},
-	bitOr: {
-		absorbs: -1,
-		result: -1
-	}
-};
-//#endregion
-//#region 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
-	};
-};
-//#endregion
-//#region src/services/compiler/constants.ts
-const NO_VALUES = [];
-const NO_LOCALS = [];
-const ADDITIVE_NAMES = ["add", "subtract"];
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region 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 BERNOULLI_CLOSED_FORM_INDEX = 54;
-const MAXIMUM_DIGITS = 15;
-const MAXIMUM_STIRLING_WORK = 4e6;
-const MILLER_RABIN_BASES = [
-	2n,
-	3n,
-	5n,
-	7n,
-	11n,
-	13n,
-	17n,
-	19n,
-	23n,
-	29n,
-	31n,
-	37n
-];
-const REFINEMENT_STEPS = 4;
-const LOW_TAIL_COEFFICIENTS = [
-	3.43273939e-7,
-	-35233877e-13,
-	-439150654e-14,
-	.00021858087,
-	-.00125372503,
-	-.00417768164,
-	.246640727,
-	1.50140941
-];
-const HIGH_TAIL_COEFFICIENTS = [
-	.000100950558,
-	.00134934322,
-	-.00367342844,
-	.00573950773,
-	-.0076224613,
-	.00943887047,
-	1.00167406,
-	2.83297682
-];
-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
-];
-const EULER_MACLAURIN_COEFFICIENTS = [
-	1 / 12,
-	-1 / 720,
-	1 / 30240,
-	-1 / 1209600,
-	1 / 47900160,
-	-691 / 1307674368e3,
-	1 / 74724249600,
-	-3617 / 0x25e8dffc150000
-];
-const SUMMATION_LIMIT = 10;
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region src/services/function/checkIsLarger.ts
-const checkIsLarger = (left, right) => left > right && !checkIsNearlyEqual(left, right);
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region 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));
-};
-//#endregion
-//#region src/services/function/checkIsSmaller.ts
-const checkIsSmaller = (left, right) => left < right && !checkIsNearlyEqual(left, right);
-//#endregion
-//#region src/services/function/computeBellNumber.ts
-const computeBellNumber = (index) => {
-	if (!Number.isInteger(index) || index < 0) return null;
-	let row = [1];
-	for (let step = 1; step <= index; step++) {
-		const next = [row.at(-1) ?? 0];
-		for (const above of row) next.push((next.at(-1) ?? 0) + above);
-		if (next[0] === Number.POSITIVE_INFINITY) return Number.POSITIVE_INFINITY;
-		row = next;
-	}
-	return row[0] ?? NaN;
-};
-//#endregion
-//#region src/services/function/computeBernoulliNumber.ts
-const computeBernoulliNumber = (index) => {
-	if (index === 1) return -.5;
-	if (index > 1 && index % 2 === 1) return 0;
-	if (index >= 54) {
-		let product = 1;
-		for (let factor = 1; factor <= index && Number.isFinite(product); factor++) product *= factor / (2 * Math.PI);
-		return index / 2 % 2 === 1 ? 2 * product : -2 * product;
-	}
-	const numbers = [1];
-	for (let current = 1; current <= index; current++) {
-		let sum = 0;
-		let binomial = 1;
-		for (let previous = 0; previous < current; previous++) {
-			sum += binomial * (numbers[previous] ?? 0);
-			binomial = binomial * (current + 1 - previous) / (previous + 1);
-		}
-		numbers.push(-sum / (current + 1));
-	}
-	return numbers[index] ?? NaN;
-};
-//#endregion
-//#region src/services/function/computeBitwiseAnd.ts
-const computeBitwiseAnd = (left, right) => left & right;
-//#endregion
-//#region src/services/function/computeBitwiseOr.ts
-const computeBitwiseOr = (left, right) => left | right;
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region src/services/function/computeCatalan.ts
-const computeCatalan = (index) => {
-	if (!Number.isInteger(index) || index < 0) return null;
-	return Math.round(computeCombinations(2 * index, index) / (index + 1));
-};
-//#endregion
-//#region src/services/function/computeComparison.ts
-const computeComparison = (left, right) => {
-	if (checkIsNearlyEqual(left, right)) return 0;
-	return left > right ? 1 : -1;
-};
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region src/services/function/computeSum.ts
-const computeSum = (values) => values.length === 0 ? 0 : values.reduce((total, value) => total + value);
-//#endregion
-//#region 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));
-};
-//#endregion
-//#region src/services/function/computeDeterminant.ts
-const computeDeterminant = (values) => {
-	if (values.length === 0) return 1;
-	return values.length === 1 ? values[0] ?? null : null;
-};
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region src/services/function/computePolynomial.ts
-const computePolynomial = (leading, coefficients, variable) => {
-	let polynomial = leading;
-	for (const coefficient of coefficients) polynomial = coefficient + polynomial * variable;
-	return polynomial;
-};
-//#endregion
-//#region src/services/function/computeInitialGuess.ts
-const computeInitialGuess = (value) => {
-	const weight = -Math.log((1 - value) * (1 + value));
-	if (weight < 5) return computePolynomial(2.81022636e-8, LOW_TAIL_COEFFICIENTS, weight - 2.5) * value;
-	return computePolynomial(-.000200214257, HIGH_TAIL_COEFFICIENTS, Math.sqrt(weight) - 3) * value;
-};
-//#endregion
-//#region src/services/function/computeErfInverse.ts
-const computeErfInverse = (value) => {
-	if (Number.isNaN(value) || value < -1 || value > 1) return NaN;
-	if (value === 1) return Number.POSITIVE_INFINITY;
-	if (value === -1) return Number.NEGATIVE_INFINITY;
-	let estimate = computeInitialGuess(value);
-	for (let step = 0; step < 4; step++) {
-		const slope = 2 / SQRT_PI * Math.exp(-estimate * estimate);
-		estimate -= (computeErf(estimate) - value) / slope;
-	}
-	return estimate;
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region 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
-	};
-};
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region src/services/function/computeFactorial.ts
-const computeFactorial = (value) => {
-	if (value < 0) return null;
-	return computeGamma(value + 1);
-};
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region src/services/function/computeGreatestCommonDivisor.ts
-const computeGreatestCommonDivisor = (left, right) => right === 0 ? Math.abs(left) : computeGreatestCommonDivisor(right, left % right);
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region 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));
-};
-//#endregion
-//#region 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))));
-};
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region src/services/function/computeLogarithm.ts
-const computeLogarithm = (value, base) => base === void 0 ? Math.log(value) : Math.log(value) / Math.log(base);
-//#endregion
-//#region src/services/function/computeLogGamma.ts
-const computeLogGamma = (value) => {
-	if (Number.isNaN(value) || value < 0) return NaN;
-	if ([0, Number.POSITIVE_INFINITY].includes(value)) return Number.POSITIVE_INFINITY;
-	if ([1, 2].includes(value)) return 0;
-	const { logGamma, product } = computeLogGammaOfPositive(value);
-	return logGamma - Math.log(product);
-};
-//#endregion
-//#region src/services/function/computeMean.ts
-const computeMean = (values) => computeSum(values) / values.length;
-//#endregion
-//#region src/services/function/compareNumbers.ts
-const compareNumbers = (left, right) => left - right;
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region src/services/function/computeMedianAbsoluteDeviation.ts
-const computeMedianAbsoluteDeviation = (values) => {
-	const center = computeMedian(values);
-	return computeMedian(values.map((value) => Math.abs(value - center)));
-};
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region 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)));
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region src/services/function/scaleList.ts
-const scaleList = (list, scalar) => list.map((element) => element * scalar);
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region src/services/function/computeStirlingColumn.ts
-const computeStirlingColumn = (count, parts) => {
-	const column = Array.from({ length: parts + 1 }, (_element, index) => index === 0 ? 1 : 0);
-	for (let step = 1; step <= count; step++) {
-		for (let part = parts; part >= 1; part--) column[part] = part * (column[part] ?? 0) + (column[part - 1] ?? 0);
-		column[0] = 0;
-	}
-	return column[parts] ?? 0;
-};
-//#endregion
-//#region src/services/function/computeStirlingDiagonal.ts
-const computeStirlingDiagonal = (count, index) => {
-	const diagonal = Array.from({ length: index + 1 }, (_element, position) => position === 0 ? 1 : 0);
-	for (let step = 1; step <= count; step++) for (let position = Math.min(step, index); position >= 1; position--) diagonal[position] = (step - position) * (diagonal[position - 1] ?? 0) + (diagonal[position] ?? 0);
-	return diagonal[index] ?? 0;
-};
-//#endregion
-//#region src/services/function/computeStirlingSecondKind.ts
-const computeStirlingSecondKind = (count, parts) => {
-	if (!Number.isInteger(count) || !Number.isInteger(parts) || count < 0 || parts < 0 || parts > count) return null;
-	if (parts === 0) return count === 0 ? 1 : 0;
-	if (parts === count) return 1;
-	const band = Math.min(parts, count - parts);
-	if (count * band > 4e6) return null;
-	return band === parts ? computeStirlingColumn(count, parts) : computeStirlingDiagonal(count, count - parts);
-};
-//#endregion
-//#region src/services/shared/checkIsTruthy.ts
-const checkIsTruthy = (value) => value !== 0 && !Number.isNaN(value);
-//#endregion
-//#region src/services/function/computeTruthyCount.ts
-const computeTruthyCount = (values) => values.filter((value) => checkIsTruthy(value)).length;
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region src/services/function/computeSummedZeta.ts
-const computeSummedZeta = (value) => {
-	let total = 0;
-	for (let integer = 1; integer < 10; integer++) total += integer ** -value;
-	total += 10 ** (1 - value) / (value - 1) + .5 * 10 ** -value;
-	let rising = value;
-	for (let index = 1; index <= EULER_MACLAURIN_COEFFICIENTS.length; index++) {
-		const coefficient = EULER_MACLAURIN_COEFFICIENTS[index - 1] ?? 0;
-		total += coefficient * rising * 10 ** (-value - 2 * index + 1);
-		rising *= (value + 2 * index - 1) * (value + 2 * index);
-	}
-	return total;
-};
-//#endregion
-//#region src/services/function/computeZeta.ts
-const computeZeta = (value) => {
-	if (value === Number.POSITIVE_INFINITY) return 1;
-	if (!Number.isFinite(value)) return NaN;
-	if (value === 1) return NaN;
-	if (value === 0) return -.5;
-	if (value > 0) return computeSummedZeta(value);
-	if (Number.isInteger(value) && value % 2 === 0) return 0;
-	if (1 - value >= 171.35) {
-		const sine = Math.sin(Math.PI * value / 2);
-		const logMagnitude = value * Math.LN2 + (value - 1) * Math.log(Math.PI) + Math.log(Math.abs(sine)) + computeLogGamma(1 - value) + Math.log(computeSummedZeta(1 - value));
-		return Math.sign(sine) * Math.exp(logMagnitude);
-	}
-	return 2 ** value * Math.PI ** (value - 1) * Math.sin(Math.PI * value / 2) * computeGamma(1 - value) * computeSummedZeta(1 - value);
-};
-//#endregion
-//#region src/services/function/signature/createNumericCompute.ts
-const createNumericCompute = (compute) => (values) => compute(values.flat());
-//#endregion
-//#region src/services/function/signature/createSignature.ts
-const createSignature = (parameters, minArity, maxArity, compute, scalarCompute = {}) => ({
-	compute,
-	maxArity,
-	minArity,
-	parameters,
-	...scalarCompute
-});
-//#endregion
-//#region src/services/function/signature/createNumberSignature.ts
-const createNumberSignature = (minArity, maxArity, compute, scalarCompute) => createSignature(["number"], minArity, maxArity, createNumericCompute(compute), scalarCompute);
-//#endregion
-//#region src/services/function/signature/createRangedSignatures.ts
-const createRangedSignatures = (minArity, maxArity, compute, scalarCompute) => [createNumberSignature(minArity, maxArity, compute, scalarCompute)];
-//#endregion
-//#region src/services/function/signature/createBinarySignatures.ts
-const createBinarySignatures = (compute) => createRangedSignatures(2, 2, (values) => compute(values[0] ?? NaN, values[1] ?? NaN), { computeBinary: compute });
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region 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}`);
-};
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region 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)
-});
-//#endregion
-//#region src/services/function/signature/createNonEmptyCompute.ts
-const createNonEmptyCompute = (compute) => (values) => values.length === 0 ? null : compute(values);
-//#endregion
-//#region src/services/function/signature/createListSignature.ts
-const createListSignature = (compute) => createSignature(["list"], 1, 1, createNumericCompute(compute));
-//#endregion
-//#region src/services/function/signature/createVariadicSignatures.ts
-const createVariadicSignatures = (minArity, compute, computeBinary) => [createNumberSignature(minArity, Number.POSITIVE_INFINITY, compute, { computeBinary })];
-//#endregion
-//#region src/services/function/signature/createSpreadSignatures.ts
-const createSpreadSignatures = (minArity, compute) => [...createVariadicSignatures(minArity, compute), createListSignature(compute)];
-//#endregion
-//#region src/services/function/signature/createExtremeSignatures.ts
-const createExtremeSignatures = (checkIsPreferred) => createSpreadSignatures(1, createNonEmptyCompute((values) => computeExtreme(values, values[0] ?? NaN, checkIsPreferred)));
-//#endregion
-//#region src/services/function/signature/createSingletonListSignature.ts
-const createSingletonListSignature = (compute) => createListSignature((values) => values.length === 1 ? compute(values[0] ?? NaN) : null);
-//#endregion
-//#region src/services/function/signature/createUnarySignatures.ts
-const createUnarySignatures = (compute) => createRangedSignatures(1, 1, (values) => compute(values[0] ?? NaN), { computeUnary: compute });
-//#endregion
-//#region src/services/function/signature/createIdentitySignatures.ts
-const createIdentitySignatures = () => [...createUnarySignatures((value) => value), createSingletonListSignature((value) => value)];
-//#endregion
-//#region src/services/function/signature/createIntegerBinarySignatures.ts
-const createIntegerBinarySignatures = (compute) => createBinarySignatures((left, right) => Number.isInteger(left) && Number.isInteger(right) ? compute(left, right) : null);
-//#endregion
-//#region src/services/function/signature/createIntegerUnarySignatures.ts
-const createIntegerUnarySignatures = (compute) => createUnarySignatures((value) => Number.isInteger(value) ? compute(value) : null);
-//#endregion
-//#region src/services/function/signature/createListFirstCompute.ts
-const createListFirstCompute = (compute) => (values) => compute(values.slice(0, 1).flat(), values.slice(1).flat());
-//#endregion
-//#region src/services/function/signature/createListPairCompute.ts
-const createListPairCompute = (compute) => (values) => compute(values.slice(0, 1).flat(), values.slice(1, 2).flat());
-//#endregion
-//#region src/services/function/signature/createListPairSignature.ts
-const createListPairSignature = (compute) => createSignature(["list", "list"], 2, 2, createListPairCompute(compute));
-//#endregion
-//#region 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));
-};
-//#endregion
-//#region src/services/shared/toNumber.ts
-const toNumber = (flag) => flag ? 1 : 0;
-//#endregion
-//#region 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),
-	bellNumbers: createUnarySignatures(computeBellNumber),
-	bernoulli: createUnarySignatures((value) => Number.isInteger(value) && value >= 0 ? computeBernoulliNumber(value) : null),
-	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))),
-	catalan: createUnarySignatures(computeCatalan),
-	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),
-	erfinv: createUnarySignatures(computeErfInverse),
-	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),
-	lgamma: createUnarySignatures(computeLogGamma),
-	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)))),
-	stirlingS2: createBinarySignatures(computeStirlingSecondKind),
-	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))),
-	zeta: createUnarySignatures(computeZeta)
-};
-//#endregion
-//#region src/services/shared/getOwnValue.ts
-const getOwnValue = (record, key) => Object.hasOwn(record, key) ? record[key] : void 0;
-//#endregion
-//#region src/services/shared/getMathExpressionSignatures.ts
-const getMathExpressionSignatures = (name) => getOwnValue(MathExpressionFunctionMap, name);
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region 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
-	};
-};
-//#endregion
-//#region 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)
-	};
-};
-//#endregion
-//#region src/services/compiler/compileArgument.ts
-const compileArgument = (node, context) => {
-	if (node.type === "list") return compileList(node.elements, context);
-	return context.compile(node);
-};
-//#endregion
-//#region src/services/shared/getMathExpressionParameterType.ts
-const getMathExpressionParameterType = (node) => node.type === "list" ? "list" : "number";
-//#endregion
-//#region src/services/shared/checkIsMatchingKind.ts
-const checkIsMatchingKind = (parameterType, argumentType) => parameterType === "any" || parameterType === argumentType;
-//#endregion
-//#region src/services/shared/getParameterType.ts
-const getParameterType = (signature, index) => signature.parameters[Math.min(index, signature.parameters.length - 1)];
-//#endregion
-//#region 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));
-//#endregion
-//#region src/services/shared/matchMathExpressionSignature.ts
-const matchMathExpressionSignature = (signatures, parameterTypes) => signatures.find((signature) => checkIsMatching(signature, parameterTypes));
-//#endregion
-//#region 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
-	};
-};
-//#endregion
-//#region 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)
-	};
-};
-//#endregion
-//#region 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
-	};
-};
-//#endregion
-//#region src/services/compiler/node/compileGroup.ts
-const compileGroup = (node, context) => context.compile(node.operand);
-//#endregion
-//#region src/services/compiler/node/compileListNode.ts
-const compileListNode = () => ({
-	evaluate: () => null,
-	isConstant: false
-});
-//#endregion
-//#region 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);
-	}
-};
-//#endregion
-//#region 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
-};
-//#endregion
-//#region src/services/compiler/getMathExpressionConstant.ts
-const getMathExpressionConstant = (name) => getOwnValue(MathExpressionConstantMap, name);
-//#endregion
-//#region 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
-	};
-};
-//#endregion
-//#region src/services/compiler/node/compileNumber.ts
-const compileNumber = (node) => {
-	const { value } = node;
-	return {
-		evaluate: () => value,
-		isConstant: true
-	};
-};
-//#endregion
-//#region 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
-	};
-};
-//#endregion
-//#region 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
-	};
-};
-//#endregion
-//#region 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
-};
-//#endregion
-//#region 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);
-	}
-};
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region 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
-	};
-};
-//#endregion
-//#region src/services/compiler/getMathExpressionOuterValue.ts
-const getMathExpressionOuterValue = (outer, values) => {
-	if (outer.variableIndex !== void 0) return values[outer.variableIndex] ?? NaN;
-	return outer.constant ?? null;
-};
-//#endregion
-//#region 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;
-	};
-};
-//#endregion
-//#region 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);
-	}
-};
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region src/services/parser/MathExpressionBinaryOperatorMap.ts
-const MathExpressionBinaryOperatorMap = {
-	"!=": {
-		name: "unequal",
-		power: 7,
-		type: "comparison"
-	},
-	"%": {
-		name: "mod",
-		power: 10,
-		type: "binary"
-	},
-	"&": {
-		name: "bitAnd",
-		power: 6,
-		type: "binary"
-	},
-	"*": {
-		name: "multiply",
-		power: 10,
-		type: "binary"
-	},
-	"+": {
-		name: "add",
-		power: 9,
-		type: "binary"
-	},
-	"-": {
-		name: "subtract",
-		power: 9,
-		type: "binary"
-	},
-	".*": {
-		name: "dotMultiply",
-		power: 10,
-		type: "binary"
-	},
-	"./": {
-		name: "dotDivide",
-		power: 10,
-		type: "binary"
-	},
-	"/": {
-		name: "divide",
-		power: 10,
-		type: "binary"
-	},
-	"<": {
-		name: "smaller",
-		power: 7,
-		type: "comparison"
-	},
-	"<<": {
-		name: "leftShift",
-		power: 8,
-		type: "binary"
-	},
-	"<=": {
-		name: "smallerEq",
-		power: 7,
-		type: "comparison"
-	},
-	"==": {
-		name: "equal",
-		power: 7,
-		type: "comparison"
-	},
-	">": {
-		name: "larger",
-		power: 7,
-		type: "comparison"
-	},
-	">=": {
-		name: "largerEq",
-		power: 7,
-		type: "comparison"
-	},
-	">>": {
-		name: "rightArithShift",
-		power: 8,
-		type: "binary"
-	},
-	">>>": {
-		name: "rightLogShift",
-		power: 8,
-		type: "binary"
-	},
-	"^|": {
-		name: "bitXor",
-		power: 5,
-		type: "binary"
-	},
-	and: {
-		operator: "and",
-		power: 3,
-		type: "logical"
-	},
-	mod: {
-		name: "mod",
-		power: 10,
-		type: "binary"
-	},
-	or: {
-		operator: "or",
-		power: 1,
-		type: "logical"
-	},
-	xor: {
-		name: "xor",
-		power: 2,
-		type: "binary"
-	},
-	"|": {
-		name: "bitOr",
-		power: 4,
-		type: "binary"
-	}
-};
-//#endregion
-//#region src/services/parser/MathExpressionOperatorMap.ts
-const MathExpressionOperatorMap = {
-	["Nullish"]: { "??": "nullish" },
-	["Power"]: {
-		".^": "dotPow",
-		"^": "pow"
-	},
-	["Unary"]: {
-		"+": "unaryPlus",
-		"-": "unaryMinus",
-		not: "not",
-		"~": "bitNot"
-	}
-};
-//#endregion
-//#region src/services/parser/constants.ts
-const MAX_MATH_EXPRESSION_DEPTH = 64;
-const PLACEHOLDER = {
-	type: "number",
-	value: NaN
-};
-//#endregion
-//#region src/services/parser/failMathExpressionAt.ts
-const failMathExpressionAt = (state, message, column) => {
-	if (state.error !== null) return;
-	state.error = new MathExpressionError(`${message} (char ${column})`);
-};
-//#endregion
-//#region src/services/parser/getMathExpressionColumn.ts
-const getMathExpressionColumn = (state) => state.index - state.token.length + 1;
-//#endregion
-//#region src/services/parser/failMathExpression.ts
-const failMathExpression = (state, message) => failMathExpressionAt(state, message, getMathExpressionColumn(state));
-//#endregion
-//#region src/services/parser/checkCanMathExpressionNest.ts
-const checkCanMathExpressionNest = (state) => {
-	if (state.depth < 64) return true;
-	failMathExpression(state, `Formula nests deeper than 64 levels`);
-	return false;
-};
-//#endregion
-//#region src/services/parser/checkIsToken.ts
-const checkIsToken = (state, token) => state.token === token;
-//#endregion
-//#region src/services/parser/token/checkIsDigitCharacter.ts
-const checkIsDigitCharacter = (character) => character >= "0" && character <= "9";
-//#endregion
-//#region src/services/parser/token/constants.ts
-const DELIMITERS_OF_THREE = /* @__PURE__ */ new Set([">>>"]);
-const DELIMITERS_OF_TWO = /* @__PURE__ */ new Set([
-	"!=",
-	".*",
-	"./",
-	".^",
-	"<<",
-	"<=",
-	"==",
-	">=",
-	">>",
-	"??",
-	"^|"
-]);
-const DELIMITERS_OF_ONE = /* @__PURE__ */ new Set([
-	"!",
-	"%",
-	"&",
-	"'",
-	"(",
-	")",
-	"*",
-	"+",
-	",",
-	"-",
-	"/",
-	":",
-	"<",
-	"=",
-	">",
-	"?",
-	"[",
-	"]",
-	"^",
-	"|",
-	"~"
-]);
-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([
-	"and",
-	"in",
-	"mod",
-	"not",
-	"or",
-	"to",
-	"xor"
-]);
-const DECIMAL_MARK_OPERATOR_FOLLOWERS = /* @__PURE__ */ new Set([
-	"*",
-	"/",
-	"^"
-]);
-const WORD_START_REGEX = /^[\p{L}_$]$/u;
-const WORD_CHARACTER_REGEX = /^[\p{L}\p{Nd}_$]$/u;
-//#endregion
-//#region 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 === "$";
-};
-//#endregion
-//#region src/services/parser/token/getMathExpressionCharacter.ts
-const getMathExpressionCharacter = (state, offset) => state.source.charAt(state.index + offset);
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region src/services/parser/token/MathExpressionRadixMap.ts
-const MathExpressionRadixMap = {
-	b: {
-		digit: /^[01]$/u,
-		radix: 2
-	},
-	o: {
-		digit: /^[0-7]$/u,
-		radix: 8
-	},
-	x: {
-		digit: /^[0-9a-fA-F]$/u,
-		radix: 16
-	}
-};
-//#endregion
-//#region 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);
-};
-//#endregion
-//#region 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";
-};
-//#endregion
-//#region src/services/parser/token/checkIsDecimalMark.ts
-const checkIsDecimalMark = (character, nextCharacter) => character === "." && !DECIMAL_MARK_OPERATOR_FOLLOWERS.has(nextCharacter);
-//#endregion
-//#region src/services/parser/token/failExponent.ts
-const failExponent = (state, text) => {
-	state.token = text;
-	failMathExpression(state, `Digit expected, got "${getMathExpressionCharacter(state, 0)}"`);
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region 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";
-};
-//#endregion
-//#region src/services/parser/token/checkIsWordCharacter.ts
-const checkIsWordCharacter = (character) => {
-	if (character >= "€") return WORD_CHARACTER_REGEX.test(character);
-	return checkIsWordStartCharacter(character) || checkIsDigitCharacter(character);
-};
-//#endregion
-//#region src/services/parser/token/readMathExpressionWord.ts
-const readMathExpressionWord = (state) => {
-	state.token = takeMathExpressionMatching(state, checkIsWordCharacter);
-	state.tokenType = NAMED_DELIMITERS.has(state.token) ? "delimiter" : "symbol";
-};
-//#endregion
-//#region 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;
-	}
-};
-//#endregion
-//#region 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";
-	}
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region src/services/parser/createBinaryNode.ts
-const createBinaryNode = (left, name, right) => ({
-	left,
-	name,
-	right,
-	type: "binary"
-});
-//#endregion
-//#region src/services/parser/createLogicalNode.ts
-const createLogicalNode = (left, operator, right) => ({
-	left,
-	operator,
-	right,
-	type: "logical"
-});
-//#endregion
-//#region 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"
-	};
-};
-//#endregion
-//#region src/services/parser/parseBinaryOperators.ts
-const parseBinaryOperators = (state, parse, minimumPower) => {
-	let node = parse(state, "ImplicitProduct");
-	let operator = getOwnValue(MathExpressionBinaryOperatorMap, state.token);
-	while (state.error === null && operator !== void 0 && operator.power >= minimumPower) {
-		getMathExpressionToken(state);
-		const right = parseBinaryOperators(state, parse, operator.power + 1);
-		node = createBinaryOperation(node, operator, right);
-		operator = getOwnValue(MathExpressionBinaryOperatorMap, state.token);
-	}
-	return node;
-};
-//#endregion
-//#region src/services/parser/rule/parseBinary.ts
-const parseBinary = (state, parse) => parseBinaryOperators(state, parse, 0);
-//#endregion
-//#region 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);
-	return {
-		condition,
-		type: "conditional",
-		whenFalse: parse(state, "Conditional"),
-		whenTrue
-	};
-};
-//#endregion
-//#region src/services/parser/checkIsSignedNumber.ts
-const checkIsSignedNumber = (node) => {
-	if (node.type === "number") return true;
-	return node.type === "unary" && (node.name === "unaryMinus" || node.name === "unaryPlus") && node.operand.type === "number";
-};
-//#endregion
-//#region src/services/parser/rule/parseDivisionBeforeProduct.ts
-const parseDivisionBeforeProduct = (state, parse) => {
-	const dividend = parse(state, "Percentage");
-	if (state.error !== null || !checkIsToken(state, "/") || !checkIsSignedNumber(dividend)) return dividend;
-	const snapshot = { ...state };
-	getMathExpressionToken(state);
-	const isNumber = state.tokenType === "number";
-	if (isNumber) getMathExpressionToken(state);
-	if (isNumber && state.error === null && (state.tokenType === "symbol" || checkIsToken(state, "("))) {
-		Object.assign(state, snapshot);
-		getMathExpressionToken(state);
-		return createBinaryNode(dividend, MathExpressionBinaryOperatorMap["/"].name, parse(state, "Percentage"));
-	}
-	Object.assign(state, snapshot);
-	return dividend;
-};
-//#endregion
-//#region 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";
-};
-//#endregion
-//#region src/services/parser/rule/parseImplicitProduct.ts
-const parseImplicitProduct = (state, parse) => {
-	let node = parse(state, "DivisionBeforeProduct");
-	let last = node;
-	while (state.error === null) {
-		if (!(state.tokenType === "symbol" || checkIsToken(state, "(") || state.tokenType === "number" && last.type !== "number" && !checkIsOperatorOperand(last))) break;
-		last = parse(state, "DivisionBeforeProduct");
-		node = createBinaryNode(node, MathExpressionBinaryOperatorMap["*"].name, last);
-	}
-	return node;
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region src/services/parser/checkIsNameToken.ts
-const checkIsNameToken = (state) => state.tokenType === "symbol" || state.tokenType === "delimiter" && getMathExpressionSignatures(state.token) !== void 0;
-//#endregion
-//#region src/services/parser/checkIsUnaryStart.ts
-const checkIsUnaryStart = (state) => state.tokenType === "number" || checkIsNameToken(state) || checkIsToken(state, "(") || getOwnValue(MathExpressionOperatorMap["Unary"], state.token) !== void 0;
-//#endregion
-//#region src/services/parser/rule/parsePercentage.ts
-const parsePercentage = (state, parse) => {
-	const node = parse(state, "Unary");
-	if (state.error !== null || !checkIsToken(state, "%")) return node;
-	const snapshot = { ...state };
-	getMathExpressionToken(state);
-	if (state.error === null && !checkIsToken(state, "+") && !checkIsToken(state, "-") && checkIsUnaryStart(state)) {
-		Object.assign(state, snapshot);
-		return node;
-	}
-	return {
-		operand: node,
-		type: "percentage"
-	};
-};
-//#endregion
-//#region 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;
-	getMathExpressionToken(state);
-	const exponent = parse(state, "Unary");
-	return createBinaryNode(base, name, exponent);
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region src/services/parser/getArgumentCountText.ts
-const getArgumentCountText = (count) => `${count} ${count === 1 ? "argument" : "arguments"}`;
-//#endregion
-//#region 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`;
-};
-//#endregion
-//#region 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`;
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region 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"
-	};
-};
-//#endregion
-//#region src/services/parser/parseArgument.ts
-const parseArgument = (state, parse) => checkIsToken(state, "[") ? parseList(state, parse) : parse(state, "Assignment");
-//#endregion
-//#region 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"
-	};
-};
-//#endregion
-//#region 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;
-};
-//#endregion
-//#region 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"
-	};
-};
-//#endregion
-//#region src/services/parser/MathExpressionRuleParserMap.ts
-const MathExpressionRuleParserMap = {
-	["Assignment"]: parseAssignment,
-	["Binary"]: parseBinary,
-	["Conditional"]: parseConditional,
-	["DivisionBeforeProduct"]: parseDivisionBeforeProduct,
-	["ImplicitProduct"]: parseImplicitProduct,
-	["LeftHand"]: parseLeftHand,
-	["Nullish"]: parseNullish,
-	["Percentage"]: parsePercentage,
-	["Power"]: parsePower,
-	["Symbol"]: parseSymbol,
-	["Unary"]: parseUnary
-};
-//#endregion
-//#region src/services/parser/parseMathExpressionRule.ts
-const parseMathExpressionRule = (state, rule) => MathExpressionRuleParserMap[rule](state, parseMathExpressionRule);
-//#endregion
-//#region 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);
-};
-//#endregion
-export { ADDITIVE_NAMES, BERNOULLI_CLOSED_FORM_INDEX, DECIMAL_MARK_OPERATOR_FOLLOWERS, DELIMITERS_OF_ONE, DELIMITERS_OF_THREE, DELIMITERS_OF_TWO, EULER_MACLAURIN_COEFFICIENTS, FIRST_CHARACTERS_OF_THREE, FIRST_CHARACTERS_OF_TWO, HIGH_TAIL_COEFFICIENTS, LAST_FACTORIAL_ARGUMENT, LOW_TAIL_COEFFICIENTS, MATH_EXPRESSION_ABSOLUTE_TOLERANCE, MATH_EXPRESSION_RELATIVE_TOLERANCE, MAXIMUM_DIGITS, MAXIMUM_STIRLING_WORK, MAX_MATH_EXPRESSION_DEPTH, MILLER_RABIN_BASES, MathExpressionBinaryOperatorMap, MathExpressionBitwiseAbsorptionMap, MathExpressionConstantMap, MathExpressionError, MathExpressionFunctionMap, MathExpressionFunctionName, MathExpressionGrammarRule, MathExpressionLogicalOperator, MathExpressionNodeCompileMap, MathExpressionNodeType, MathExpressionOperatorMap, MathExpressionParameterType, MathExpressionRadixMap, MathExpressionRuleParserMap, MathExpressionTokenType, NAMED_DELIMITERS, NO_LOCALS, NO_VALUES, OVERFLOW_ARGUMENT, PLACEHOLDER, REFINEMENT_STEPS, SQRT_PI, STIRLING_TERMS, STIRLING_THRESHOLD, SUMMATION_LIMIT, WORD_CHARACTER_REGEX, WORD_START_REGEX, checkCanMathExpressionNest, checkIsDecimalMark, checkIsDigitCharacter, checkIsLarger, checkIsMatching, checkIsMatchingKind, checkIsMillerRabinPassing, checkIsNameToken, checkIsNearlyEqual, checkIsOperatorOperand, checkIsPercentageExpression, checkIsPrime, checkIsSignedNumber, checkIsSmaller, checkIsToken, checkIsTruthy, checkIsUnaryStart, checkIsWordCharacter, checkIsWordStartCharacter, collectMathExpressionAssignedNames, compareNumbers, compileArgument, compileAssignment, compileBinary, compileCall, compileComparison, compileConditional, compileGroup, compileList, compileListNode, compileLogical, compileMathExpression, compileMathExpressionNode, compileName, compileNumber, compilePercentage, compileUnary, computeBellNumber, computeBernoulliNumber, computeBitwiseAnd, computeBitwiseOr, computeCatalan, computeCombinations, computeComparison, computeCompositions, computeCorrelation, computeDeterminant, computeDistance, computeDotProduct, computeErf, computeErfInverse, computeExtreme, computeFactorial, computeGamma, computeGreatestCommonDivisor, computeHypotenuse, computeInitialGuess, computeIntegerGreatestCommonDivisor, computeInverseCoth, computeKullbackLeibler, computeLeastCommonMultiple, computeListComparison, computeLogGamma, computeLogGammaOfPositive, computeLogarithm, computeMean, computeMedian, computeMedianAbsoluteDeviation, computeModularInverse, computeModularPower, computeModulo, computeMultinomial, computeNorm, computeNthRoot, computeNumberLiteral, computePartitionSelect, computePermutations, computePointToLine2D, computePointToLine3D, computePolynomial, computeProduct, computeProductOfRange, computeQuantile, computeStirlingColumn, computeStirlingDiagonal, computeStirlingLogGamma, computeStirlingSecondKind, computeSum, computeSummedZeta, computeTruthyCount, computeVariance, computeVectorNorm, computeZeta, 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, parseDivisionBeforeProduct, parseImplicitProduct, parseLeftHand, parseList, parseMathExpression, parseMathExpressionRule, parseNullish, parsePercentage, parsePower, parseSequence, parseSymbol, parseUnary, readMathExpressionDelimiter, readMathExpressionNumber, readMathExpressionWord, readRadixNumber, roundToDigits, scaleList, shiftDecimalPlaces, skipMathExpressionSpaces, takeExponent, takeMathExpressionMatching, toNumber, walkNode };