math-expression-compiler 4.5.0 → 4.6.0

package/dist/index.d.ts

@@ -140,8 +140,6 @@ export declare enum MathExpressionBinaryOperatorSymbol {
   GreaterThanOrEqual = ">=",
   LessThan = "<",
   LessThanOrEqual = "<=",
-  Mod = "mod",
-  Modulo = "%",
   Multiply = "*",
   NotEqual = "!=",
   Or = "or",
@@ -155,8 +153,6 @@ export declare enum MathExpressionGrammarRule {
   Assignment = "Assignment",
   Binary = "Binary",
   Conditional = "Conditional",
-  DivisionBeforeProduct = "DivisionBeforeProduct",
-  ImplicitProduct = "ImplicitProduct",
   LeftHand = "LeftHand",
   Nullish = "Nullish",
   Percentage = "Percentage",
@@ -249,11 +245,8 @@ export declare const checkIsNearlyEqual: (left: number, right: number) => boolea
 export declare const checkIsPrime: (value: number) => boolean;
 export declare const checkIsSmaller: (left: number, right: number) => boolean;
 export declare const compareNumbers: (left: number, right: number) => number;
-export declare const computeBellNumber: (index: number) => null | number;
-export declare const computeBernoulliNumber: (index: number) => number;
 export declare const computeBitwiseAnd: (left: number, right: number) => number;
 export declare const computeBitwiseOr: (left: number, right: number) => number;
-export declare const computeCatalan: (index: number) => null | number;
 export declare const computeCombinations: (available: number, chosen: number) => number;
 export declare const computeComparison: (left: number, right: number) => number;
 export declare const computeCompositions: (total: number, parts: number) => null | number;
@@ -262,20 +255,17 @@ export declare const computeDeterminant: (values: readonly number[]) => null | n
 export declare const computeDistance: (point: number[], other: number[]) => null | number;
 export declare const computeDotProduct: (left: readonly number[], right: readonly number[]) => null | number;
 export declare const computeErf: (value: number) => number;
-export declare const computeErfInverse: (value: number) => number;
 export declare const computeExtreme: (values: readonly number[], initial: number, checkIsPreferred: (value: number, extreme: number) => boolean) => number;
 export declare const computeFactorial: (value: number) => null | number;
 export declare const computeGamma: (value: number) => number;
 export declare const computeGreatestCommonDivisor: (left: number, right: number) => number;
 export declare const computeHypotenuse: (values: readonly number[]) => number;
-export declare const computeInitialGuess: (value: number) => number;
 export declare const computeIntegerGreatestCommonDivisor: (values: readonly number[]) => null | number;
 export declare const computeInverseCoth: (value: number) => number;
 export declare const computeKullbackLeibler: (distribution: readonly number[], reference: readonly number[]) => null | number;
 export declare const computeLeastCommonMultiple: (left: number, right: number) => null | number;
 export declare const computeListComparison: (left: number[], right: number[]) => number;
 export declare const computeLogarithm: (value: number, base?: number) => number;
-export declare const computeLogGamma: (value: number) => number;
 export declare const computeLogGammaOfPositive: (value: number) => {
   logGamma: number;
   product: number;
@@ -293,36 +283,23 @@ export declare const computePartitionSelect: (values: number[], index: number) =
 export declare const computePermutations: (available: number, chosen: number) => null | number;
 export declare const computePointToLine2D: (point: number[], line: number[]) => number;
 export declare const computePointToLine3D: (point: number[], line: number[]) => number;
-export declare const computePolynomial: (leading: number, coefficients: readonly number[], variable: number) => number;
 export declare const computeProduct: (values: readonly MathExpressionValue[]) => null | number;
 export declare const computeProductOfRange: (first: number, last: number) => number;
 export declare const computeQuantile: (values: number[], probability: number, isSorted: boolean) => null | number;
-export declare const computeStirlingColumn: (count: number, parts: number) => number;
-export declare const computeStirlingDiagonal: (count: number, index: number) => number;
 export declare const computeStirlingLogGamma: (value: number) => number;
-export declare const computeStirlingSecondKind: (count: number, parts: number) => null | number;
 export declare const computeSum: (values: readonly number[]) => number;
-export declare const computeSummedZeta: (value: number) => number;
 export declare const computeTruthyCount: (values: readonly number[]) => number;
 export declare const computeVariance: (values: readonly number[]) => number;
 export declare const computeVectorNorm: (values: readonly number[], power: number) => null | number;
-export declare const computeZeta: (value: number) => number;
 export declare const MATH_EXPRESSION_RELATIVE_TOLERANCE = 1e-12;
 export declare const MATH_EXPRESSION_ABSOLUTE_TOLERANCE = 1e-15;
 export declare const SQRT_PI: number;
-export declare const BERNOULLI_CLOSED_FORM_INDEX = 54;
 export declare const MAXIMUM_DIGITS = 15;
-export declare const MAXIMUM_STIRLING_WORK = 4e6;
 export declare const MILLER_RABIN_BASES: readonly bigint[];
-export declare const REFINEMENT_STEPS = 4;
-export declare const LOW_TAIL_COEFFICIENTS: readonly number[];
-export declare const HIGH_TAIL_COEFFICIENTS: readonly number[];
 export declare const OVERFLOW_ARGUMENT = 171.35;
 export declare const LAST_FACTORIAL_ARGUMENT = 171;
 export declare const STIRLING_THRESHOLD = 15;
 export declare const STIRLING_TERMS: readonly number[];
-export declare const EULER_MACLAURIN_COEFFICIENTS: readonly number[];
-export declare const SUMMATION_LIMIT = 10;
 export declare const MathExpressionFunctionMap: Record<string, MathExpressionSignature[]>;
 export declare const multiplyPair: (left: MathExpressionValue, right: MathExpressionValue) => MathExpressionValue | null;
 export declare const roundToDigits: (rounder: (value: number) => number, value: number, digits: number) => null | number;
@@ -353,11 +330,10 @@ export declare const createVariadicSignatures: (minArity: number, compute: MathE
 export declare const getMathExpressionNames: (node: MathExpressionNode) => string[];
 export declare const walkNode: (node: MathExpressionNode, bound: Set<string>, free: Set<string>) => void;
 export declare const checkCanMathExpressionNest: (state: MathExpressionParserState) => boolean;
+export declare const checkIsFactorStart: (state: MathExpressionParserState, last: MathExpressionNode) => boolean;
 export declare const checkIsNameToken: (state: MathExpressionParserState) => boolean;
 export declare const checkIsOperatorOperand: (node: MathExpressionNode) => boolean;
-export declare const checkIsSignedNumber: (node: MathExpressionNode) => boolean;
 export declare const checkIsToken: (state: MathExpressionParserState, token: string) => boolean;
-export declare const checkIsUnaryStart: (state: MathExpressionParserState) => boolean;
 export declare const computeNumberLiteral: (token: string) => null | number;
 export declare const MAX_MATH_EXPRESSION_DEPTH = 64;
 export declare const PLACEHOLDER: MathExpressionNode;
@@ -373,7 +349,6 @@ export declare const getMathExpressionSignatureError: (name: string, signatures:
 export declare const getMathExpressionToken: (state: MathExpressionParserState) => void;
 export declare const MathExpressionBinaryOperatorMap: {
   readonly "*": MathExpressionBinaryFunctionOperator;
-  readonly "/": MathExpressionBinaryFunctionOperator;
   readonly [token: string]: MathExpressionBinaryOperator;
 };
 export declare const MathExpressionOperatorMap: {
@@ -392,8 +367,6 @@ export declare const parseSequence: (state: MathExpressionParserState, closing:
 export declare const parseAssignment: MathExpressionRuleParser;
 export declare const parseBinary: MathExpressionRuleParser;
 export declare const parseConditional: MathExpressionRuleParser;
-export declare const parseDivisionBeforeProduct: MathExpressionRuleParser;
-export declare const parseImplicitProduct: MathExpressionRuleParser;
 export declare const parseLeftHand: MathExpressionRuleParser;
 export declare const parseNullish: MathExpressionRuleParser;
 export declare const parsePercentage: MathExpressionRuleParser;

package/dist/index.js

@@ -36,8 +36,6 @@ let MathExpressionBinaryOperatorSymbol = /* @__PURE__ */ function(MathExpression
 	MathExpressionBinaryOperatorSymbol["GreaterThanOrEqual"] = ">=";
 	MathExpressionBinaryOperatorSymbol["LessThan"] = "<";
 	MathExpressionBinaryOperatorSymbol["LessThanOrEqual"] = "<=";
-	MathExpressionBinaryOperatorSymbol["Mod"] = "mod";
-	MathExpressionBinaryOperatorSymbol["Modulo"] = "%";
 	MathExpressionBinaryOperatorSymbol["Multiply"] = "*";
 	MathExpressionBinaryOperatorSymbol["NotEqual"] = "!=";
 	MathExpressionBinaryOperatorSymbol["Or"] = "or";
@@ -53,8 +51,6 @@ let MathExpressionGrammarRule = /* @__PURE__ */ function(MathExpressionGrammarRu
 	MathExpressionGrammarRule["Assignment"] = "Assignment";
 	MathExpressionGrammarRule["Binary"] = "Binary";
 	MathExpressionGrammarRule["Conditional"] = "Conditional";
-	MathExpressionGrammarRule["DivisionBeforeProduct"] = "DivisionBeforeProduct";
-	MathExpressionGrammarRule["ImplicitProduct"] = "ImplicitProduct";
 	MathExpressionGrammarRule["LeftHand"] = "LeftHand";
 	MathExpressionGrammarRule["Nullish"] = "Nullish";
 	MathExpressionGrammarRule["Percentage"] = "Percentage";
@@ -185,9 +181,7 @@ const compileAssignment = (node, context) => {
 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,
@@ -202,27 +196,6 @@ const MILLER_RABIN_BASES = [
 	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;
@@ -235,17 +208,6 @@ const STIRLING_TERMS = [
 	-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;
 // src/services/function/checkIsNearlyEqual.ts
 const checkIsNearlyEqual = (left, right) => {
 	if (Number.isNaN(left) || Number.isNaN(right)) return false;
@@ -297,39 +259,6 @@ const checkIsPrime = (value) => {
 };
 // src/services/function/checkIsSmaller.ts
 const checkIsSmaller = (left, right) => left < right && !checkIsNearlyEqual(left, right);
-// 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;
-};
-// 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;
-};
 // src/services/function/computeBitwiseAnd.ts
 const computeBitwiseAnd = (left, right) => left & right;
 // src/services/function/computeBitwiseOr.ts
@@ -344,11 +273,6 @@ const computeCombinations = (available, chosen) => {
 	}
 	return Math.round(result);
 };
-// 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));
-};
 // src/services/function/computeComparison.ts
 const computeComparison = (left, right) => {
 	if (checkIsNearlyEqual(left, right)) return 0;
@@ -431,30 +355,6 @@ const computeErf = (value) => {
 	for (let index = CONTINUED_FRACTION_DEPTH; index >= 1; index--) fraction = magnitude + index / 2 / fraction;
 	return sign * (1 - Math.exp(-magnitude * magnitude) / SQRT_PI / fraction);
 };
-// src/services/function/computePolynomial.ts
-const computePolynomial = (leading, coefficients, variable) => {
-	let polynomial = leading;
-	for (const coefficient of coefficients) polynomial = coefficient + polynomial * variable;
-	return polynomial;
-};
-// 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;
-};
-// 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;
-};
 // src/services/function/computeStirlingLogGamma.ts
 const computeStirlingLogGamma = (value) => {
 	const inverse = 1 / value;
@@ -563,14 +463,6 @@ const computeListComparison = (left, right) => {
 };
 // src/services/function/computeLogarithm.ts
 const computeLogarithm = (value, base) => base === void 0 ? Math.log(value) : Math.log(value) / Math.log(base);
-// 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);
-};
 // src/services/function/computeMean.ts
 const computeMean = (values) => computeSum(values) / values.length;
 // src/services/function/compareNumbers.ts
@@ -691,30 +583,6 @@ const computeQuantile = (values, probability, isSorted) => {
 	const fraction = index % 1;
 	return (ordered[integerPart] ?? NaN) * (1 - fraction) + (ordered[integerPart + 1] ?? NaN) * fraction;
 };
-// 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;
-};
-// 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;
-};
-// 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);
-};
 // src/services/shared/checkIsTruthy.ts
 const checkIsTruthy = (value) => value !== 0 && !Number.isNaN(value);
 // src/services/function/computeTruthyCount.ts
@@ -746,34 +614,6 @@ const computeVectorNorm = (values, power) => {
 	if (checkIsNearlyEqual(power, 0)) return Number.POSITIVE_INFINITY;
 	return computeSum(magnitudes.map((magnitude) => magnitude ** power)) ** (1 / power);
 };
-// 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;
-};
-// 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);
-};
 // src/services/function/signature/createNumericCompute.ts
 const createNumericCompute = (compute) => (values) => compute(values.flat());
 // src/services/function/signature/createSignature.ts
@@ -880,14 +720,11 @@ const MathExpressionFunctionMap = {
 	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),
@@ -923,7 +760,6 @@ const MathExpressionFunctionMap = {
 	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),
@@ -950,7 +786,6 @@ const MathExpressionFunctionMap = {
 		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;
@@ -1013,7 +848,6 @@ const MathExpressionFunctionMap = {
 	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),
@@ -1023,8 +857,7 @@ const MathExpressionFunctionMap = {
 	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)
+	xor: createVariadicSignatures(1, (values) => toNumber(computeTruthyCount(values) % 2 === 1), (left, right) => toNumber(checkIsTruthy(left) !== checkIsTruthy(right)))
 };
 // src/services/shared/getOwnValue.ts
 const getOwnValue = (record, key) => Object.hasOwn(record, key) ? record[key] : void 0;
@@ -1410,36 +1243,21 @@ const checkCanMathExpressionNest = (state) => {
 	failMathExpression(state, `Formula nests deeper than 64 levels`);
 	return false;
 };
-// src/services/parser/checkIsNameToken.ts
-const checkIsNameToken = (state) => state.tokenType === "symbol" || state.tokenType === "delimiter" && getMathExpressionSignatures(state.token) !== void 0;
 // src/services/parser/checkIsOperatorOperand.ts
 const checkIsOperatorOperand = (node) => {
 	if (node.type === "unary") return node.name !== "factorial";
 	return node.type === "binary" || node.type === "comparison" || node.type === "logical";
 };
-// src/services/parser/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";
-};
 // src/services/parser/checkIsToken.ts
 const checkIsToken = (state, token) => state.token === token;
-// src/services/parser/MathExpressionOperatorMap.ts
-const MathExpressionOperatorMap = {
-	["Nullish"]: { "??": "nullish" },
-	["Power"]: {
-		".^": "dotPow",
-		"^": "pow"
-	},
-	["Unary"]: {
-		"+": "unaryPlus",
-		"-": "unaryMinus",
-		not: "not",
-		"~": "bitNot"
-	}
+// src/services/parser/checkIsFactorStart.ts
+const checkIsFactorStart = (state, last) => {
+	if (last.type === "percentage") return false;
+	if (state.tokenType === "symbol" || checkIsToken(state, "(")) return true;
+	return state.tokenType === "number" && last.type !== "number" && !checkIsOperatorOperand(last);
 };
-// src/services/parser/checkIsUnaryStart.ts
-const checkIsUnaryStart = (state) => state.tokenType === "number" || checkIsNameToken(state) || checkIsToken(state, "(") || getOwnValue(MathExpressionOperatorMap["Unary"], state.token) !== void 0;
+// src/services/parser/checkIsNameToken.ts
+const checkIsNameToken = (state) => state.tokenType === "symbol" || state.tokenType === "delimiter" && getMathExpressionSignatures(state.token) !== void 0;
 // src/services/parser/token/MathExpressionRadixMap.ts
 const MathExpressionRadixMap = {
 	["b"]: {
@@ -1534,6 +1352,7 @@ const DELIMITERS_OF_TWO = /* @__PURE__ */ new Set([
 const DELIMITERS_OF_ONE = /* @__PURE__ */ new Set([
 	...SYMBOLIC_BINARY_SYMBOLS_OF_ONE,
 	"!",
+	"%",
 	"'",
 	"(",
 	")",
@@ -1551,9 +1370,9 @@ const FIRST_CHARACTERS_OF_TWO = new Set(Array.from(DELIMITERS_OF_TWO, (delimiter
 const NAMED_DELIMITERS = /* @__PURE__ */ new Set([
 	"in",
 	"and",
-	"mod",
 	"or",
 	"xor",
+	"mod",
 	"not",
 	"to"
 ]);
@@ -1771,16 +1590,6 @@ const MathExpressionBinaryOperatorMap = {
 		power: 7,
 		type: "comparison"
 	},
-	["mod"]: {
-		name: "mod",
-		power: 10,
-		type: "binary"
-	},
-	["%"]: {
-		name: "mod",
-		power: 10,
-		type: "binary"
-	},
 	["*"]: {
 		name: "multiply",
 		power: 10,
@@ -1822,6 +1631,20 @@ const MathExpressionBinaryOperatorMap = {
 		type: "binary"
 	}
 };
+// src/services/parser/MathExpressionOperatorMap.ts
+const MathExpressionOperatorMap = {
+	["Nullish"]: { "??": "nullish" },
+	["Power"]: {
+		".^": "dotPow",
+		"^": "pow"
+	},
+	["Unary"]: {
+		"+": "unaryPlus",
+		"-": "unaryMinus",
+		not: "not",
+		"~": "bitNot"
+	}
+};
 // src/services/parser/rule/parseAssignment.ts
 const parseAssignment = (state, parse) => {
 	if (!checkCanMathExpressionNest(state)) return PLACEHOLDER;
@@ -1842,13 +1665,15 @@ const parseAssignment = (state, parse) => {
 };
 // 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);
+	let node = parse(state, "Percentage");
+	let last = node;
+	while (state.error === null) {
+		const isImplicit = checkIsFactorStart(state, last);
+		const operator = isImplicit ? MathExpressionBinaryOperatorMap["*"] : getOwnValue(MathExpressionBinaryOperatorMap, state.token);
+		if (operator === void 0 || operator.power < minimumPower) break;
+		if (!isImplicit) getMathExpressionToken(state);
+		last = parseBinaryOperators(state, parse, operator.power + 1);
+		node = createBinaryOperation(node, operator, last);
 	}
 	return node;
 };
@@ -1877,33 +1702,6 @@ const parseConditional = (state, parse) => {
 		whenTrue
 	};
 };
-// 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;
-};
-// 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;
-};
 // src/services/parser/rule/parseLeftHand.ts
 const parseLeftHand = (state, parse) => {
 	let node = parse(state, "Symbol");
@@ -1935,12 +1733,7 @@ const parseNullish = (state, parse) => {
 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"
@@ -2065,8 +1858,6 @@ const MathExpressionRuleParserMap = {
 	["Assignment"]: parseAssignment,
 	["Binary"]: parseBinary,
 	["Conditional"]: parseConditional,
-	["DivisionBeforeProduct"]: parseDivisionBeforeProduct,
-	["ImplicitProduct"]: parseImplicitProduct,
 	["LeftHand"]: parseLeftHand,
 	["Nullish"]: parseNullish,
 	["Percentage"]: parsePercentage,
@@ -2092,4 +1883,4 @@ const parseMathExpression = (formula) => {
 	if (state.error === null && !checkIsToken(state, "")) failMathExpression(state, state.tokenType === "delimiter" ? `Unexpected operator ${state.token}` : `Unexpected part "${state.token}"`);
 	return state.error === null ? ok(node) : err(state.error);
 };
-export { ADDITIVE_NAMES, 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, MathExpressionBinaryOperatorSymbol, MathExpressionBitwiseAbsorption, MathExpressionBitwiseAbsorptionMap, MathExpressionConstantMap, MathExpressionError, MathExpressionFunctionMap, MathExpressionFunctionName, MathExpressionGrammarRule, MathExpressionLogicalOperator, MathExpressionNodeCompileMap, MathExpressionNodeType, MathExpressionOperatorMap, MathExpressionParameterType, MathExpressionRadix, MathExpressionRadixMap, MathExpressionRuleParserMap, MathExpressionTokenType, NAMED_DELIMITERS, NO_LOCALS, NO_VALUES, OVERFLOW_ARGUMENT, PLACEHOLDER, 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 };
+export { ADDITIVE_NAMES, DECIMAL_MARK_OPERATOR_FOLLOWERS, DELIMITERS_OF_ONE, DELIMITERS_OF_THREE, DELIMITERS_OF_TWO, FIRST_CHARACTERS_OF_THREE, FIRST_CHARACTERS_OF_TWO, LAST_FACTORIAL_ARGUMENT, MATH_EXPRESSION_ABSOLUTE_TOLERANCE, MATH_EXPRESSION_RELATIVE_TOLERANCE, MAXIMUM_DIGITS, MAX_MATH_EXPRESSION_DEPTH, MILLER_RABIN_BASES, MathExpressionBinaryOperatorMap, MathExpressionBinaryOperatorSymbol, MathExpressionBitwiseAbsorption, MathExpressionBitwiseAbsorptionMap, MathExpressionConstantMap, MathExpressionError, MathExpressionFunctionMap, MathExpressionFunctionName, MathExpressionGrammarRule, MathExpressionLogicalOperator, MathExpressionNodeCompileMap, MathExpressionNodeType, MathExpressionOperatorMap, MathExpressionParameterType, MathExpressionRadix, MathExpressionRadixMap, MathExpressionRuleParserMap, MathExpressionTokenType, NAMED_DELIMITERS, NO_LOCALS, NO_VALUES, OVERFLOW_ARGUMENT, PLACEHOLDER, SQRT_PI, STIRLING_TERMS, STIRLING_THRESHOLD, WORD_CHARACTER_REGEX, WORD_START_REGEX, checkCanMathExpressionNest, checkIsDecimalMark, checkIsDigitCharacter, checkIsFactorStart, checkIsLarger, checkIsMatching, checkIsMatchingKind, checkIsMillerRabinPassing, checkIsNameToken, checkIsNearlyEqual, checkIsOperatorOperand, checkIsPercentageExpression, checkIsPrime, checkIsSmaller, checkIsToken, checkIsTruthy, checkIsWordCharacter, checkIsWordStartCharacter, collectMathExpressionAssignedNames, compareNumbers, compileArgument, compileAssignment, compileBinary, compileCall, compileComparison, compileConditional, compileGroup, compileList, compileListNode, compileLogical, compileMathExpression, compileMathExpressionNode, compileName, compileNumber, compilePercentage, compileUnary, computeBitwiseAnd, computeBitwiseOr, computeCombinations, computeComparison, computeCompositions, computeCorrelation, computeDeterminant, computeDistance, computeDotProduct, computeErf, computeExtreme, computeFactorial, computeGamma, computeGreatestCommonDivisor, computeHypotenuse, computeIntegerGreatestCommonDivisor, computeInverseCoth, computeKullbackLeibler, computeLeastCommonMultiple, computeListComparison, computeLogGammaOfPositive, computeLogarithm, computeMean, computeMedian, computeMedianAbsoluteDeviation, computeModularInverse, computeModularPower, computeModulo, computeMultinomial, computeNorm, computeNthRoot, computeNumberLiteral, computePartitionSelect, computePermutations, computePointToLine2D, computePointToLine3D, computeProduct, computeProductOfRange, computeQuantile, computeStirlingLogGamma, computeSum, computeTruthyCount, computeVariance, computeVectorNorm, createBinaryNode, createBinaryOperation, createBinarySignatures, createBitwiseFold, createBitwisePair, createDigitSignatures, createExtremeSignatures, createIdentitySignatures, createIntegerBinarySignatures, createIntegerUnarySignatures, createListFirstCompute, createListPairCompute, createListPairSignature, createListSignature, createLogicalNode, createNonEmptyCompute, createNumberSignature, createNumericCompute, createOrderedListSignatures, createRangedSignatures, createSignature, createSingletonListSignature, createSpreadSignatures, createUnarySignatures, createVariadicSignatures, failExponent, failMathExpression, failMathExpressionAt, getArgumentCountText, getMathExpressionArityMessage, getMathExpressionCharacter, getMathExpressionChildren, getMathExpressionColumn, getMathExpressionConstant, getMathExpressionNames, getMathExpressionOuterValue, getMathExpressionParameterType, getMathExpressionScalarCompute, getMathExpressionSignatureError, getMathExpressionSignatures, getMathExpressionToken, getOwnValue, getParameterType, matchMathExpressionSignature, multiplyPair, parseArgument, parseAssignment, parseBinary, parseBinaryOperators, parseCall, parseConditional, parseLeftHand, parseList, parseMathExpression, parseMathExpressionRule, parseNullish, parsePercentage, parsePower, parseSequence, parseSymbol, parseUnary, readMathExpressionDelimiter, readMathExpressionNumber, readMathExpressionWord, readRadixNumber, roundToDigits, scaleList, shiftDecimalPlaces, skipMathExpressionSpaces, takeExponent, takeMathExpressionMatching, toNumber, walkNode };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-expression-compiler",
-  "version": "4.5.0",
+  "version": "4.6.0",
   "description": "Math expressions compiled once into a function of plain numbers — mathjs's numeric language, checked against its recorded answers with every deliberate difference listed",
   "keywords": [
     "typescript"
@@ -40,13 +40,13 @@
     "typecheck": "tsrs --fast"
   },
   "dependencies": {
-    "@esposter/shared": "4.5.0",
+    "@esposter/shared": "4.6.0",
     "neverthrow": "^8.2.0"
   },
   "devDependencies": {
-    "@esposter/configuration": "4.5.0",
-    "@esposter/shared-node": "4.5.0",
-    "tsdown": "^0.23.5"
+    "@esposter/configuration": "4.6.0",
+    "@esposter/shared-node": "4.6.0",
+    "tsdown": "^0.23.7"
   },
-  "gitHead": "e30c001f3b4b15693e75fb53092d62a97ade4d2b"
+  "gitHead": "0ceea3ffbe12ca69413ea5db2d3cfad197a63cba"
 }