math-expression-compiler 4.3.3 → 4.5.0

package/README.md

@@ -5,12 +5,14 @@
 [![NPM downloads][badge-npm-downloads]][url-npm]
 [![NPM Unpacked Size (with version)][badge-npm-unpacked-size]][url-npm]
 
-Math expressions compiled once into a function of plain numbers, in mathjs's numeric language and held to mathjs's recorded answers. A formula is parsed into a tree, the tree is compiled into a function of its variables' values, and that function is called once per row with no parsing or lookup per call.
+This package compiles math expressions once, each into a function of plain numbers. They use mathjs's numeric language and match mathjs's recorded answers.
+
+Design notes live in [the specs](https://github.com/Esposter/Esposter/tree/main/openspec/specs/math-expression-compiler).
 
 ## Table of Contents
 
 - 🚀 [Getting Started](#getting-started)
-- 📖 [Documentation](#documentation)
+- 🧩 [Key Exports](#key-exports)
 - ⚖️ [License](#license)
 
 ---
@@ -32,27 +34,16 @@ const evaluate = parseMathExpression("col0 * (1 - col1)").match(
 evaluate([10, 0.25]); // 7.5
 ```
 
+## <a name="key-exports">🧩 Key Exports</a>
+
 | Export                      | What it does                                                                                                                   |
 | :-------------------------- | :----------------------------------------------------------------------------------------------------------------------------- |
-| `parseMathExpression`       | A formula to its tree, or a `Result` holding the first error with its position                                                 |
 | `compileMathExpression`     | A tree and its variable names to a function of the variables' values, which yields `NaN` where a formula has no numeric answer |
 | `getMathExpressionNames`    | The names a tree reads that it does not assign itself and that are not constants                                               |
-| `MathExpressionFunctionMap` | Each function of the language by its mathjs name, as the signatures it takes: argument kinds, arities and computation          |
 | `MathExpressionConstantMap` | The named constants of the language                                                                                            |
 | `MathExpressionError`       | The error a parse returns                                                                                                      |
-
-## <a name="documentation">📖 Documentation</a>
-
-We highly recommend you take a look at the [documentation](https://github.com/Esposter/Esposter/tree/main/openspec/specs) to level up.
-
-## Commands
-
-| Command          | What it does                             |
-| :--------------- | :--------------------------------------- |
-| `pnpm build`     | Builds `dist` and regenerates the barrel |
-| `pnpm test`      | Runs the tests                           |
-| `pnpm lint:fix`  | Lints the package and fixes what it can  |
-| `pnpm typecheck` | Typechecks the package                   |
+| `MathExpressionFunctionMap` | Each function of the language by its mathjs name, as the signatures it takes: argument kinds, arities and computation          |
+| `parseMathExpression`       | A formula to its tree, or a `Result` holding the first error with its position                                                 |
 
 ## <a name="license">⚖️ License</a>
 

package/dist/index.d.ts

@@ -1,4 +1,8 @@
 import { Result } from "neverthrow";
+export declare enum MathExpressionBitwiseAbsorption {
+  BitAnd = "bitAnd",
+  BitOr = "bitOr"
+}
 export type MathExpressionResult = null | number;
 export type MathExpressionEvaluator = (values: readonly number[], locals: MathExpressionResult[]) => MathExpressionResult;
 export interface MathExpressionCompiled {
@@ -122,6 +126,31 @@ export type MathExpressionBinaryOperator = MathExpressionBinaryFunctionOperator
   power: number;
   type: MathExpressionNodeType.Logical;
 };
+export declare enum MathExpressionBinaryOperatorSymbol {
+  Add = "+",
+  And = "and",
+  BitwiseAnd = "&",
+  BitwiseOr = "|",
+  BitwiseXor = "^|",
+  Divide = "/",
+  ElementwiseDivide = "./",
+  ElementwiseMultiply = ".*",
+  Equal = "==",
+  GreaterThan = ">",
+  GreaterThanOrEqual = ">=",
+  LessThan = "<",
+  LessThanOrEqual = "<=",
+  Mod = "mod",
+  Modulo = "%",
+  Multiply = "*",
+  NotEqual = "!=",
+  Or = "or",
+  ShiftLeft = "<<",
+  ShiftRight = ">>",
+  Subtract = "-",
+  UnsignedShiftRight = ">>>",
+  Xor = "xor"
+}
 export declare enum MathExpressionGrammarRule {
   Assignment = "Assignment",
   Binary = "Binary",
@@ -156,13 +185,11 @@ export interface MathExpressionParserState {
 }
 export type MathExpressionParse = (state: MathExpressionParserState, rule: MathExpressionGrammarRule) => MathExpressionNode;
 export type MathExpressionRuleParser = (state: MathExpressionParserState, parse: MathExpressionParse) => MathExpressionNode;
-export declare const MathExpressionBitwiseAbsorptionMap: Readonly<Record<string, {
-  absorbs: number;
-  result: number;
-}>>;
-export declare const MathExpressionNodeCompileMap: { [T in MathExpressionNodeType]: (node: Extract<MathExpressionNode, {
-  type: T;
-}>, context: MathExpressionCompileContext) => MathExpressionCompiled; };
+export declare enum MathExpressionRadix {
+  Binary = "b",
+  Hexadecimal = "x",
+  Octal = "o"
+}
 export declare const checkIsPercentageExpression: (node: MathExpressionNode) => boolean;
 export declare const collectMathExpressionAssignedNames: (node: MathExpressionNode, names: Set<string>) => void;
 export declare const compileArgument: (node: MathExpressionNode, context: MathExpressionCompileContext) => MathExpressionCompiledArgument;
@@ -175,6 +202,13 @@ export declare const ADDITIVE_NAMES: readonly string[];
 export declare const getMathExpressionConstant: (name: string) => number | undefined;
 export declare const getMathExpressionOuterValue: (outer: MathExpressionOuterBinding, values: readonly number[]) => MathExpressionResult;
 export declare const getMathExpressionScalarCompute: <Key extends keyof MathExpressionScalarCompute>(name: string, key: Key) => NonNullable<MathExpressionScalarCompute[Key]>;
+export declare const MathExpressionBitwiseAbsorptionMap: Readonly<Record<string, {
+  absorbs: number;
+  result: number;
+}>>;
+export declare const MathExpressionNodeCompileMap: { [T in MathExpressionNodeType]: (node: Extract<MathExpressionNode, {
+  type: T;
+}>, context: MathExpressionCompileContext) => MathExpressionCompiled; };
 export declare const compileAssignment: (node: Extract<MathExpressionNode, {
   type: MathExpressionNodeType.Assignment;
 }>, context: MathExpressionCompileContext) => MathExpressionCompiled;
@@ -209,7 +243,6 @@ export declare const compilePercentage: (node: Extract<MathExpressionNode, {
 export declare const compileUnary: (node: Extract<MathExpressionNode, {
   type: MathExpressionNodeType.Unary;
 }>, context: MathExpressionCompileContext) => MathExpressionCompiled;
-export declare const MathExpressionFunctionMap: Record<string, MathExpressionSignature[]>;
 export declare const checkIsLarger: (left: number, right: number) => boolean;
 export declare const checkIsMillerRabinPassing: (candidate: bigint, base: bigint, oddPart: bigint, twos: number) => boolean;
 export declare const checkIsNearlyEqual: (left: number, right: number) => boolean;
@@ -241,12 +274,12 @@ 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;
 };
-export declare const computeLogarithm: (value: number, base?: number) => number;
 export declare const computeMean: (values: readonly number[]) => number;
 export declare const computeMedian: (values: readonly number[]) => number;
 export declare const computeMedianAbsoluteDeviation: (values: readonly number[]) => number;
@@ -290,6 +323,7 @@ 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;
 export declare const scaleList: (list: number[], scalar: number) => number[];
@@ -318,17 +352,6 @@ export declare const createUnarySignatures: (compute: MathExpressionUnaryCompute
 export declare const createVariadicSignatures: (minArity: number, compute: MathExpressionNumberCompute, computeBinary?: MathExpressionBinaryCompute) => MathExpressionSignature[];
 export declare const getMathExpressionNames: (node: MathExpressionNode) => string[];
 export declare const walkNode: (node: MathExpressionNode, bound: Set<string>, free: Set<string>) => void;
-export declare const MathExpressionBinaryOperatorMap: {
-  readonly "*": MathExpressionBinaryFunctionOperator;
-  readonly "/": MathExpressionBinaryFunctionOperator;
-  readonly [token: string]: MathExpressionBinaryOperator;
-};
-export declare const MathExpressionOperatorMap: {
-  [MathExpressionGrammarRule.Nullish]: Readonly<Record<string, MathExpressionLogicalOperator>>;
-  [MathExpressionGrammarRule.Power]: Readonly<Record<string, string>>;
-  [MathExpressionGrammarRule.Unary]: Readonly<Record<string, string>>;
-};
-export declare const MathExpressionRuleParserMap: Record<MathExpressionGrammarRule, MathExpressionRuleParser>;
 export declare const checkCanMathExpressionNest: (state: MathExpressionParserState) => boolean;
 export declare const checkIsNameToken: (state: MathExpressionParserState) => boolean;
 export declare const checkIsOperatorOperand: (node: MathExpressionNode) => boolean;
@@ -348,6 +371,17 @@ export declare const getMathExpressionArityMessage: (name: string, minArity: num
 export declare const getMathExpressionColumn: (state: MathExpressionParserState) => number;
 export declare const getMathExpressionSignatureError: (name: string, signatures: readonly MathExpressionSignature[], parameterTypes: MathExpressionParameterType[]) => string;
 export declare const getMathExpressionToken: (state: MathExpressionParserState) => void;
+export declare const MathExpressionBinaryOperatorMap: {
+  readonly "*": MathExpressionBinaryFunctionOperator;
+  readonly "/": MathExpressionBinaryFunctionOperator;
+  readonly [token: string]: MathExpressionBinaryOperator;
+};
+export declare const MathExpressionOperatorMap: {
+  [MathExpressionGrammarRule.Nullish]: Readonly<Record<string, MathExpressionLogicalOperator>>;
+  [MathExpressionGrammarRule.Power]: Readonly<Record<string, string>>;
+  [MathExpressionGrammarRule.Unary]: Readonly<Record<string, string>>;
+};
+export declare const MathExpressionRuleParserMap: Record<MathExpressionGrammarRule, MathExpressionRuleParser>;
 export declare const parseArgument: (state: MathExpressionParserState, parse: MathExpressionParse) => MathExpressionNode;
 export declare const parseBinaryOperators: (state: MathExpressionParserState, parse: MathExpressionParse, minimumPower: number) => MathExpressionNode;
 export declare const parseCall: (state: MathExpressionParserState, name: string, column: number, parse: MathExpressionParse) => MathExpressionNode;
@@ -366,10 +400,6 @@ export declare const parsePercentage: MathExpressionRuleParser;
 export declare const parsePower: MathExpressionRuleParser;
 export declare const parseSymbol: MathExpressionRuleParser;
 export declare const parseUnary: MathExpressionRuleParser;
-export declare const MathExpressionRadixMap: Readonly<Record<string, {
-  digit: RegExp;
-  radix: number;
-}>>;
 export declare const checkIsDecimalMark: (character: string, nextCharacter: string) => boolean;
 export declare const checkIsDigitCharacter: (character: string) => boolean;
 export declare const checkIsWordCharacter: (character: string) => boolean;
@@ -385,6 +415,10 @@ export declare const WORD_START_REGEX: RegExp;
 export declare const WORD_CHARACTER_REGEX: RegExp;
 export declare const failExponent: (state: MathExpressionParserState, text: string) => void;
 export declare const getMathExpressionCharacter: (state: MathExpressionParserState, offset: number) => string;
+export declare const MathExpressionRadixMap: Readonly<Record<string, {
+  digit: RegExp;
+  radix: number;
+}>>;
 export declare const readMathExpressionDelimiter: (state: MathExpressionParserState) => number;
 export declare const readMathExpressionNumber: (state: MathExpressionParserState) => void;
 export declare const readMathExpressionWord: (state: MathExpressionParserState) => void;
@@ -392,7 +426,6 @@ export declare const readRadixNumber: (state: MathExpressionParserState, prefix:
 export declare const skipMathExpressionSpaces: (state: MathExpressionParserState) => void;
 export declare const takeExponent: (state: MathExpressionParserState, text: string) => string;
 export declare const takeMathExpressionMatching: (state: MathExpressionParserState, checkCharacter: (character: string) => boolean) => string;
-export declare const MathExpressionConstantMap: Record<string, number>;
 export declare const checkIsMatching: (signature: MathExpressionSignature, parameterTypes: MathExpressionParameterType[]) => boolean;
 export declare const checkIsMatchingKind: (parameterType: MathExpressionParameterType | undefined, argumentType: MathExpressionParameterType) => boolean;
 export declare const checkIsTruthy: (value: number) => boolean;
@@ -402,4 +435,5 @@ export declare const getMathExpressionSignatures: (name: string) => MathExpressi
 export declare const getOwnValue: <T>(record: Readonly<Record<string, T>>, key: string) => T | undefined;
 export declare const getParameterType: (signature: MathExpressionSignature, index: number) => MathExpressionParameterType | undefined;
 export declare const matchMathExpressionSignature: (signatures: readonly MathExpressionSignature[], parameterTypes: MathExpressionParameterType[]) => MathExpressionSignature | undefined;
+export declare const MathExpressionConstantMap: Record<string, number>;
 export declare const toNumber: (flag: boolean) => number;

package/dist/index.js

@@ -1,5 +1,11 @@
 import { exhaustiveGuard } from "@esposter/shared";
 import { err, ok } from "neverthrow";
+// src/models/compiler/MathExpressionBitwiseAbsorption.ts
+let MathExpressionBitwiseAbsorption = /* @__PURE__ */ function(MathExpressionBitwiseAbsorption) {
+	MathExpressionBitwiseAbsorption["BitAnd"] = "bitAnd";
+	MathExpressionBitwiseAbsorption["BitOr"] = "bitOr";
+	return MathExpressionBitwiseAbsorption;
+}({});
 // src/models/function/MathExpressionFunctionName.ts
 let MathExpressionFunctionName = /* @__PURE__ */ function(MathExpressionFunctionName) {
 	MathExpressionFunctionName["CTranspose"] = "ctranspose";
@@ -15,6 +21,33 @@ let MathExpressionParameterType = /* @__PURE__ */ function(MathExpressionParamet
 	MathExpressionParameterType["Number"] = "number";
 	return MathExpressionParameterType;
 }({});
+// src/models/parser/MathExpressionBinaryOperatorSymbol.ts
+let MathExpressionBinaryOperatorSymbol = /* @__PURE__ */ function(MathExpressionBinaryOperatorSymbol) {
+	MathExpressionBinaryOperatorSymbol["Add"] = "+";
+	MathExpressionBinaryOperatorSymbol["And"] = "and";
+	MathExpressionBinaryOperatorSymbol["BitwiseAnd"] = "&";
+	MathExpressionBinaryOperatorSymbol["BitwiseOr"] = "|";
+	MathExpressionBinaryOperatorSymbol["BitwiseXor"] = "^|";
+	MathExpressionBinaryOperatorSymbol["Divide"] = "/";
+	MathExpressionBinaryOperatorSymbol["ElementwiseDivide"] = "./";
+	MathExpressionBinaryOperatorSymbol["ElementwiseMultiply"] = ".*";
+	MathExpressionBinaryOperatorSymbol["Equal"] = "==";
+	MathExpressionBinaryOperatorSymbol["GreaterThan"] = ">";
+	MathExpressionBinaryOperatorSymbol["GreaterThanOrEqual"] = ">=";
+	MathExpressionBinaryOperatorSymbol["LessThan"] = "<";
+	MathExpressionBinaryOperatorSymbol["LessThanOrEqual"] = "<=";
+	MathExpressionBinaryOperatorSymbol["Mod"] = "mod";
+	MathExpressionBinaryOperatorSymbol["Modulo"] = "%";
+	MathExpressionBinaryOperatorSymbol["Multiply"] = "*";
+	MathExpressionBinaryOperatorSymbol["NotEqual"] = "!=";
+	MathExpressionBinaryOperatorSymbol["Or"] = "or";
+	MathExpressionBinaryOperatorSymbol["ShiftLeft"] = "<<";
+	MathExpressionBinaryOperatorSymbol["ShiftRight"] = ">>";
+	MathExpressionBinaryOperatorSymbol["Subtract"] = "-";
+	MathExpressionBinaryOperatorSymbol["UnsignedShiftRight"] = ">>>";
+	MathExpressionBinaryOperatorSymbol["Xor"] = "xor";
+	return MathExpressionBinaryOperatorSymbol;
+}({});
 // src/models/parser/MathExpressionGrammarRule.ts
 let MathExpressionGrammarRule = /* @__PURE__ */ function(MathExpressionGrammarRule) {
 	MathExpressionGrammarRule["Assignment"] = "Assignment";
@@ -39,6 +72,13 @@ let MathExpressionTokenType = /* @__PURE__ */ function(MathExpressionTokenType)
 	MathExpressionTokenType["Unknown"] = "unknown";
 	return MathExpressionTokenType;
 }({});
+// src/models/parser/token/MathExpressionRadix.ts
+let MathExpressionRadix = /* @__PURE__ */ function(MathExpressionRadix) {
+	MathExpressionRadix["Binary"] = "b";
+	MathExpressionRadix["Hexadecimal"] = "x";
+	MathExpressionRadix["Octal"] = "o";
+	return MathExpressionRadix;
+}({});
 // src/models/shared/MathExpressionError.ts
 var MathExpressionError = class extends Error {
 	constructor(message) {
@@ -69,17 +109,65 @@ let MathExpressionNodeType = /* @__PURE__ */ function(MathExpressionNodeType) {
 	MathExpressionNodeType["Unary"] = "unary";
 	return MathExpressionNodeType;
 }({});
-// src/services/compiler/MathExpressionBitwiseAbsorptionMap.ts
-const MathExpressionBitwiseAbsorptionMap = {
-	bitAnd: {
-		absorbs: 0,
-		result: 0
-	},
-	bitOr: {
-		absorbs: -1,
-		result: -1
+// src/services/compiler/constants.ts
+const NO_VALUES = [];
+const NO_LOCALS = [];
+const ADDITIVE_NAMES = ["add", "subtract"];
+// src/services/compiler/checkIsPercentageExpression.ts
+const checkIsPercentageExpression = (node) => {
+	if (node.type === "percentage") return true;
+	if (node.type !== "binary") return false;
+	if (!ADDITIVE_NAMES.includes(node.name)) return false;
+	return checkIsPercentageExpression(node.left) && checkIsPercentageExpression(node.right);
+};
+// src/services/shared/getMathExpressionChildren.ts
+const getMathExpressionChildren = (node) => {
+	switch (node.type) {
+		case "assignment": return [node.value];
+		case "binary":
+		case "logical": return [node.left, node.right];
+		case "call": return node.arguments;
+		case "comparison": return node.operands;
+		case "conditional": return [
+			node.condition,
+			node.whenTrue,
+			node.whenFalse
+		];
+		case "group":
+		case "percentage":
+		case "unary": return [node.operand];
+		case "list": return node.elements;
+		case "name":
+		case "number": return [];
+		default: return exhaustiveGuard(node);
 	}
 };
+// src/services/compiler/collectMathExpressionAssignedNames.ts
+const collectMathExpressionAssignedNames = (node, names) => {
+	if (node.type === "assignment") names.add(node.name);
+	for (const child of getMathExpressionChildren(node)) collectMathExpressionAssignedNames(child, names);
+};
+// src/services/compiler/compileList.ts
+const compileList = (elements, context) => {
+	const compiledElements = elements.map((element) => context.compile(element));
+	return {
+		evaluate: (values, locals) => {
+			const numbers = [];
+			for (const element of compiledElements) {
+				const elementValue = element.evaluate(values, locals);
+				if (elementValue === null) return null;
+				numbers.push(elementValue);
+			}
+			return numbers;
+		},
+		isConstant: compiledElements.every((element) => element.isConstant)
+	};
+};
+// src/services/compiler/compileArgument.ts
+const compileArgument = (node, context) => {
+	if (node.type === "list") return compileList(node.elements, context);
+	return context.compile(node);
+};
 // src/services/compiler/node/compileAssignment.ts
 const compileAssignment = (node, context) => {
 	const slot = context.assignedSlots.get(node.name) ?? 0;
@@ -93,17 +181,6 @@ const compileAssignment = (node, context) => {
 		isConstant: false
 	};
 };
-// src/services/compiler/constants.ts
-const NO_VALUES = [];
-const NO_LOCALS = [];
-const ADDITIVE_NAMES = ["add", "subtract"];
-// src/services/compiler/checkIsPercentageExpression.ts
-const checkIsPercentageExpression = (node) => {
-	if (node.type === "percentage") return true;
-	if (node.type !== "binary") return false;
-	if (!ADDITIVE_NAMES.includes(node.name)) return false;
-	return checkIsPercentageExpression(node.left) && checkIsPercentageExpression(node.right);
-};
 // src/services/function/constants.ts
 const MATH_EXPRESSION_RELATIVE_TOLERANCE = 1e-12;
 const MATH_EXPRESSION_ABSOLUTE_TOLERANCE = 1e-15;
@@ -961,6 +1038,17 @@ const getMathExpressionScalarCompute = (name, key) => {
 	if (scalarCompute !== void 0) return scalarCompute;
 	return (...values) => signature.compute(values);
 };
+// src/services/compiler/MathExpressionBitwiseAbsorptionMap.ts
+const MathExpressionBitwiseAbsorptionMap = {
+	["bitAnd"]: {
+		absorbs: 0,
+		result: 0
+	},
+	["bitOr"]: {
+		absorbs: -1,
+		result: -1
+	}
+};
 // src/services/compiler/node/compileBinary.ts
 const compileBinary = (node, context) => {
 	const { left, name, right } = node;
@@ -995,27 +1083,6 @@ const compileBinary = (node, context) => {
 		isConstant: compiledLeft.isConstant && compiledRight.isConstant
 	};
 };
-// src/services/compiler/compileList.ts
-const compileList = (elements, context) => {
-	const compiledElements = elements.map((element) => context.compile(element));
-	return {
-		evaluate: (values, locals) => {
-			const numbers = [];
-			for (const element of compiledElements) {
-				const elementValue = element.evaluate(values, locals);
-				if (elementValue === null) return null;
-				numbers.push(elementValue);
-			}
-			return numbers;
-		},
-		isConstant: compiledElements.every((element) => element.isConstant)
-	};
-};
-// src/services/compiler/compileArgument.ts
-const compileArgument = (node, context) => {
-	if (node.type === "list") return compileList(node.elements, context);
-	return context.compile(node);
-};
 // src/services/shared/getMathExpressionParameterType.ts
 const getMathExpressionParameterType = (node) => node.type === "list" ? "list" : "number";
 // src/services/shared/checkIsMatchingKind.ts
@@ -1228,33 +1295,6 @@ const MathExpressionNodeCompileMap = {
 	["percentage"]: compilePercentage,
 	["unary"]: compileUnary
 };
-// src/services/shared/getMathExpressionChildren.ts
-const getMathExpressionChildren = (node) => {
-	switch (node.type) {
-		case "assignment": return [node.value];
-		case "binary":
-		case "logical": return [node.left, node.right];
-		case "call": return node.arguments;
-		case "comparison": return node.operands;
-		case "conditional": return [
-			node.condition,
-			node.whenTrue,
-			node.whenFalse
-		];
-		case "group":
-		case "percentage":
-		case "unary": return [node.operand];
-		case "list": return node.elements;
-		case "name":
-		case "number": return [];
-		default: return exhaustiveGuard(node);
-	}
-};
-// src/services/compiler/collectMathExpressionAssignedNames.ts
-const collectMathExpressionAssignedNames = (node, names) => {
-	if (node.type === "assignment") names.add(node.name);
-	for (const child of getMathExpressionChildren(node)) collectMathExpressionAssignedNames(child, names);
-};
 // src/services/compiler/compileMathExpressionNode.ts
 const compileMathExpressionNode = (node, context) => {
 	const compileOfType = MathExpressionNodeCompileMap[node.type];
@@ -1347,138 +1387,6 @@ const getMathExpressionNames = (node) => {
 	walkNode(node, bound, free);
 	return [...free].filter((name) => getMathExpressionConstant(name) === void 0);
 };
-// 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"
-	}
-};
-// src/services/parser/MathExpressionOperatorMap.ts
-const MathExpressionOperatorMap = {
-	["Nullish"]: { "??": "nullish" },
-	["Power"]: {
-		".^": "dotPow",
-		"^": "pow"
-	},
-	["Unary"]: {
-		"+": "unaryPlus",
-		"-": "unaryMinus",
-		not: "not",
-		"~": "bitNot"
-	}
-};
 // src/services/parser/constants.ts
 const MAX_MATH_EXPRESSION_DEPTH = 64;
 const PLACEHOLDER = {
@@ -1493,70 +1401,166 @@ const failMathExpressionAt = (state, message, column) => {
 // src/services/parser/getMathExpressionColumn.ts
 const getMathExpressionColumn = (state) => state.index - state.token.length + 1;
 // src/services/parser/failMathExpression.ts
-const failMathExpression = (state, message) => failMathExpressionAt(state, message, getMathExpressionColumn(state));
+const failMathExpression = (state, message) => {
+	failMathExpressionAt(state, message, getMathExpressionColumn(state));
+};
 // src/services/parser/checkCanMathExpressionNest.ts
 const checkCanMathExpressionNest = (state) => {
 	if (state.depth < 64) return true;
 	failMathExpression(state, `Formula nests deeper than 64 levels`);
 	return false;
 };
-// src/services/parser/checkIsToken.ts
-const checkIsToken = (state, token) => state.token === token;
-// src/services/parser/token/checkIsDigitCharacter.ts
-const checkIsDigitCharacter = (character) => character >= "0" && character <= "9";
-// 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([
-	"!",
-	"%",
-	"&",
-	"'",
+// 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/checkIsUnaryStart.ts
+const checkIsUnaryStart = (state) => state.tokenType === "number" || checkIsNameToken(state) || checkIsToken(state, "(") || getOwnValue(MathExpressionOperatorMap["Unary"], state.token) !== void 0;
+// src/services/parser/token/MathExpressionRadixMap.ts
+const MathExpressionRadixMap = {
+	["b"]: {
+		digit: /^[01]$/u,
+		radix: 2
+	},
+	["x"]: {
+		digit: /^[0-9a-fA-F]$/u,
+		radix: 16
+	},
+	["o"]: {
+		digit: /^[0-7]$/u,
+		radix: 8
+	}
+};
+// src/services/parser/computeNumberLiteral.ts
+const computeNumberLiteral = (token) => {
+	const radixEntry = MathExpressionRadixMap[token.charAt(1)];
+	if (!token.startsWith("0") || radixEntry === void 0) return Number(token);
+	const { radix } = radixEntry;
+	const [digits = "", wordSize] = token.slice(2).split("i");
+	const [integerDigits = "", fractionDigits = ""] = digits.split(".");
+	let value = 0;
+	for (const digit of integerDigits) value = value * radix + Number.parseInt(digit, radix);
+	let scale = 1 / radix;
+	for (const digit of fractionDigits) {
+		value += Number.parseInt(digit, radix) * scale;
+		scale /= radix;
+	}
+	if (wordSize === void 0) return value;
+	const bits = Number(wordSize);
+	if (value > 2 ** bits - 1) return null;
+	return value >= 2 ** (bits - 1) ? value - 2 ** bits : value;
+};
+// src/services/parser/createBinaryNode.ts
+const createBinaryNode = (left, name, right) => ({
+	left,
+	name,
+	right,
+	type: "binary"
+});
+// src/services/parser/createLogicalNode.ts
+const createLogicalNode = (left, operator, right) => ({
+	left,
+	operator,
+	right,
+	type: "logical"
+});
+// src/services/parser/createBinaryOperation.ts
+const createBinaryOperation = (left, operator, right) => {
+	if (operator.type === "logical") return createLogicalNode(left, operator.operator, right);
+	if (operator.type === "binary") return createBinaryNode(left, operator.name, right);
+	if (left.type === "comparison") {
+		left.names.push(operator.name);
+		left.operands.push(right);
+		return left;
+	}
+	return {
+		names: [operator.name],
+		operands: [left, right],
+		type: "comparison"
+	};
+};
+// src/services/parser/getArgumentCountText.ts
+const getArgumentCountText = (count) => `${count} ${count === 1 ? "argument" : "arguments"}`;
+// src/services/parser/getMathExpressionArityMessage.ts
+const getMathExpressionArityMessage = (name, minArity, maxArity) => {
+	if (maxArity === Number.POSITIVE_INFINITY) return `"${name}" takes at least ${getArgumentCountText(minArity)}`;
+	if (minArity === maxArity) return `"${name}" takes ${getArgumentCountText(minArity)}`;
+	return `"${name}" takes ${minArity} or ${maxArity} arguments`;
+};
+// src/services/parser/getMathExpressionSignatureError.ts
+const getMathExpressionSignatureError = (name, signatures, parameterTypes) => {
+	const count = parameterTypes.length;
+	if (signatures.filter((signature) => count >= signature.minArity && count <= signature.maxArity).length === 0) return getMathExpressionArityMessage(name, Math.min(...signatures.map((signature) => signature.minArity)), Math.max(...signatures.map((signature) => signature.maxArity)));
+	if (parameterTypes.includes("list")) return `"${name}" does not take a list argument`;
+	return `"${name}" takes a list argument`;
+};
+// src/services/parser/token/checkIsDigitCharacter.ts
+const checkIsDigitCharacter = (character) => character >= "0" && character <= "9";
+// src/services/parser/token/constants.ts
+const SYMBOLIC_BINARY_SYMBOLS = Object.values(MathExpressionBinaryOperatorSymbol).filter((symbol) => !/\p{L}/u.test(symbol));
+const SYMBOLIC_BINARY_SYMBOLS_OF_THREE = SYMBOLIC_BINARY_SYMBOLS.filter((symbol) => symbol.length === 3);
+const SYMBOLIC_BINARY_SYMBOLS_OF_TWO = SYMBOLIC_BINARY_SYMBOLS.filter((symbol) => symbol.length === 2);
+const SYMBOLIC_BINARY_SYMBOLS_OF_ONE = SYMBOLIC_BINARY_SYMBOLS.filter((symbol) => symbol.length === 1);
+const DELIMITERS_OF_THREE = new Set(SYMBOLIC_BINARY_SYMBOLS_OF_THREE);
+const DELIMITERS_OF_TWO = /* @__PURE__ */ new Set([
+	...SYMBOLIC_BINARY_SYMBOLS_OF_TWO,
+	".^",
+	"??"
+]);
+const DELIMITERS_OF_ONE = /* @__PURE__ */ new Set([
+	...SYMBOLIC_BINARY_SYMBOLS_OF_ONE,
+	"!",
+	"'",
 	"(",
 	")",
-	"*",
-	"+",
 	",",
-	"-",
-	"/",
 	":",
-	"<",
 	"=",
-	">",
 	"?",
 	"[",
 	"]",
 	"^",
-	"|",
 	"~"
 ]);
 const FIRST_CHARACTERS_OF_THREE = new Set(Array.from(DELIMITERS_OF_THREE, (delimiter) => delimiter.charAt(0)));
 const FIRST_CHARACTERS_OF_TWO = new Set(Array.from(DELIMITERS_OF_TWO, (delimiter) => delimiter.charAt(0)));
 const NAMED_DELIMITERS = /* @__PURE__ */ new Set([
-	"and",
 	"in",
+	"and",
 	"mod",
-	"not",
 	"or",
-	"to",
-	"xor"
+	"xor",
+	"not",
+	"to"
 ]);
 const DECIMAL_MARK_OPERATOR_FOLLOWERS = /* @__PURE__ */ new Set([
-	"*",
+	"^",
 	"/",
-	"^"
+	"*"
 ]);
 const WORD_START_REGEX = /^[\p{L}_$]$/u;
 const WORD_CHARACTER_REGEX = /^[\p{L}\p{Nd}_$]$/u;
@@ -1582,21 +1586,6 @@ const readMathExpressionDelimiter = (state) => {
 	if ([")", "]"].includes(state.token)) state.nestingLevel--;
 	return length;
 };
-// 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
-	}
-};
 // src/services/parser/token/takeMathExpressionMatching.ts
 const takeMathExpressionMatching = (state, checkCharacter) => {
 	const start = state.index;
@@ -1715,6 +1704,124 @@ const getMathExpressionToken = (state) => {
 		state.tokenType = "unknown";
 	}
 };
+// src/services/parser/MathExpressionBinaryOperatorMap.ts
+const MathExpressionBinaryOperatorMap = {
+	["+"]: {
+		name: "add",
+		power: 9,
+		type: "binary"
+	},
+	["and"]: {
+		operator: "and",
+		power: 3,
+		type: "logical"
+	},
+	["&"]: {
+		name: "bitAnd",
+		power: 6,
+		type: "binary"
+	},
+	["|"]: {
+		name: "bitOr",
+		power: 4,
+		type: "binary"
+	},
+	["^|"]: {
+		name: "bitXor",
+		power: 5,
+		type: "binary"
+	},
+	["/"]: {
+		name: "divide",
+		power: 10,
+		type: "binary"
+	},
+	["./"]: {
+		name: "dotDivide",
+		power: 10,
+		type: "binary"
+	},
+	[".*"]: {
+		name: "dotMultiply",
+		power: 10,
+		type: "binary"
+	},
+	["=="]: {
+		name: "equal",
+		power: 7,
+		type: "comparison"
+	},
+	[">"]: {
+		name: "larger",
+		power: 7,
+		type: "comparison"
+	},
+	[">="]: {
+		name: "largerEq",
+		power: 7,
+		type: "comparison"
+	},
+	["<"]: {
+		name: "smaller",
+		power: 7,
+		type: "comparison"
+	},
+	["<="]: {
+		name: "smallerEq",
+		power: 7,
+		type: "comparison"
+	},
+	["mod"]: {
+		name: "mod",
+		power: 10,
+		type: "binary"
+	},
+	["%"]: {
+		name: "mod",
+		power: 10,
+		type: "binary"
+	},
+	["*"]: {
+		name: "multiply",
+		power: 10,
+		type: "binary"
+	},
+	["!="]: {
+		name: "unequal",
+		power: 7,
+		type: "comparison"
+	},
+	["or"]: {
+		operator: "or",
+		power: 1,
+		type: "logical"
+	},
+	["<<"]: {
+		name: "leftShift",
+		power: 8,
+		type: "binary"
+	},
+	[">>"]: {
+		name: "rightArithShift",
+		power: 8,
+		type: "binary"
+	},
+	["-"]: {
+		name: "subtract",
+		power: 9,
+		type: "binary"
+	},
+	[">>>"]: {
+		name: "rightLogShift",
+		power: 8,
+		type: "binary"
+	},
+	["xor"]: {
+		name: "xor",
+		power: 2,
+		type: "binary"
+	}
+};
 // src/services/parser/rule/parseAssignment.ts
 const parseAssignment = (state, parse) => {
 	if (!checkCanMathExpressionNest(state)) return PLACEHOLDER;
@@ -1733,35 +1840,6 @@ const parseAssignment = (state, parse) => {
 	state.depth--;
 	return node;
 };
-// src/services/parser/createBinaryNode.ts
-const createBinaryNode = (left, name, right) => ({
-	left,
-	name,
-	right,
-	type: "binary"
-});
-// src/services/parser/createLogicalNode.ts
-const createLogicalNode = (left, operator, right) => ({
-	left,
-	operator,
-	right,
-	type: "logical"
-});
-// src/services/parser/createBinaryOperation.ts
-const createBinaryOperation = (left, operator, right) => {
-	if (operator.type === "logical") return createLogicalNode(left, operator.operator, right);
-	if (operator.type === "binary") return createBinaryNode(left, operator.name, right);
-	if (left.type === "comparison") {
-		left.names.push(operator.name);
-		left.operands.push(right);
-		return left;
-	}
-	return {
-		names: [operator.name],
-		operands: [left, right],
-		type: "comparison"
-	};
-};
 // src/services/parser/parseBinaryOperators.ts
 const parseBinaryOperators = (state, parse, minimumPower) => {
 	let node = parse(state, "ImplicitProduct");
@@ -1789,18 +1867,16 @@ const parseConditional = (state, parse) => {
 	if (state.error === null && !checkIsToken(state, ":")) failMathExpression(state, "False part of conditional expression expected");
 	if (state.error !== null) return PLACEHOLDER;
 	getMathExpressionToken(state);
+	state.depth++;
+	const whenFalse = parse(state, "Conditional");
+	state.depth--;
 	return {
 		condition,
 		type: "conditional",
-		whenFalse: parse(state, "Conditional"),
+		whenFalse,
 		whenTrue
 	};
 };
-// 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/rule/parseDivisionBeforeProduct.ts
 const parseDivisionBeforeProduct = (state, parse) => {
 	const dividend = parse(state, "Percentage");
@@ -1817,11 +1893,6 @@ const parseDivisionBeforeProduct = (state, parse) => {
 	Object.assign(state, snapshot);
 	return dividend;
 };
-// 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/rule/parseImplicitProduct.ts
 const parseImplicitProduct = (state, parse) => {
 	let node = parse(state, "DivisionBeforeProduct");
@@ -1860,10 +1931,6 @@ const parseNullish = (state, parse) => {
 	}
 	return node;
 };
-// src/services/parser/checkIsNameToken.ts
-const checkIsNameToken = (state) => state.tokenType === "symbol" || state.tokenType === "delimiter" && getMathExpressionSignatures(state.token) !== void 0;
-// 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/rule/parsePercentage.ts
 const parsePercentage = (state, parse) => {
 	const node = parse(state, "Unary");
@@ -1884,44 +1951,13 @@ const parsePower = (state, parse) => {
 	const base = parse(state, "Nullish");
 	const name = getOwnValue(MathExpressionOperatorMap["Power"], state.token);
 	if (state.error !== null || name === void 0) return base;
+	if (!checkCanMathExpressionNest(state)) return PLACEHOLDER;
 	getMathExpressionToken(state);
+	state.depth++;
 	const exponent = parse(state, "Unary");
+	state.depth--;
 	return createBinaryNode(base, name, exponent);
 };
-// src/services/parser/computeNumberLiteral.ts
-const computeNumberLiteral = (token) => {
-	const radixEntry = MathExpressionRadixMap[token.charAt(1)];
-	if (!token.startsWith("0") || radixEntry === void 0) return Number(token);
-	const { radix } = radixEntry;
-	const [digits = "", wordSize] = token.slice(2).split("i");
-	const [integerDigits = "", fractionDigits = ""] = digits.split(".");
-	let value = 0;
-	for (const digit of integerDigits) value = value * radix + Number.parseInt(digit, radix);
-	let scale = 1 / radix;
-	for (const digit of fractionDigits) {
-		value += Number.parseInt(digit, radix) * scale;
-		scale /= radix;
-	}
-	if (wordSize === void 0) return value;
-	const bits = Number(wordSize);
-	if (value > 2 ** bits - 1) return null;
-	return value >= 2 ** (bits - 1) ? value - 2 ** bits : value;
-};
-// src/services/parser/getArgumentCountText.ts
-const getArgumentCountText = (count) => `${count} ${count === 1 ? "argument" : "arguments"}`;
-// src/services/parser/getMathExpressionArityMessage.ts
-const getMathExpressionArityMessage = (name, minArity, maxArity) => {
-	if (maxArity === Number.POSITIVE_INFINITY) return `"${name}" takes at least ${getArgumentCountText(minArity)}`;
-	if (minArity === maxArity) return `"${name}" takes ${getArgumentCountText(minArity)}`;
-	return `"${name}" takes ${minArity} or ${maxArity} arguments`;
-};
-// src/services/parser/getMathExpressionSignatureError.ts
-const getMathExpressionSignatureError = (name, signatures, parameterTypes) => {
-	const count = parameterTypes.length;
-	if (signatures.filter((signature) => count >= signature.minArity && count <= signature.maxArity).length === 0) return getMathExpressionArityMessage(name, Math.min(...signatures.map((signature) => signature.minArity)), Math.max(...signatures.map((signature) => signature.maxArity)));
-	if (parameterTypes.includes("list")) return `"${name}" does not take a list argument`;
-	return `"${name}" takes a list argument`;
-};
 // src/services/parser/parseSequence.ts
 const parseSequence = (state, closing, parseItem) => {
 	const nodes = [];
@@ -2056,4 +2092,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, 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 };
+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 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-expression-compiler",
-  "version": "4.3.3",
-  "description": "Math expressions compiled once into a function of plain numbers — mathjs's numeric language, held to parity with its recorded answers",
+  "version": "4.5.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"
   ],
@@ -37,16 +37,16 @@
     "lint": "eslint .",
     "lint:fix": "eslint --fix .",
     "test": "vitest",
-    "typecheck": "tsc"
+    "typecheck": "tsrs --fast"
   },
   "dependencies": {
-    "@esposter/shared": "4.3.3",
+    "@esposter/shared": "4.5.0",
     "neverthrow": "^8.2.0"
   },
   "devDependencies": {
-    "@esposter/configuration": "4.3.3",
-    "@esposter/shared-node": "4.3.3",
-    "tsdown": "^0.23.1"
+    "@esposter/configuration": "4.5.0",
+    "@esposter/shared-node": "4.5.0",
+    "tsdown": "^0.23.5"
   },
-  "gitHead": "955bbc130ad9b28877fd4ae8efc73a045141ce01"
+  "gitHead": "e30c001f3b4b15693e75fb53092d62a97ade4d2b"
 }