@danielsimonjr/mathts-expression 0.10.3 → 0.11.1

package/dist/index.js

@@ -465,6 +465,9 @@ const safeNativeMethods = {
 	toLocaleString: true
 };
 //#endregion
+//#region src/limits.ts
+const MAX_EXPRESSION_LENGTH = 1e6;
+//#endregion
 //#region src/parse.ts
 const name$45 = "parse";
 const createParse = /* #__PURE__ */ factory(name$45, [
@@ -489,12 +492,14 @@ const createParse = /* #__PURE__ */ factory(name$45, [
 ], ({ typed, numeric, config, AccessorNode, ArrayNode, AssignmentNode, BlockNode, ConditionalNode, ConstantNode, FunctionAssignmentNode, FunctionNode, IndexNode, ObjectNode, OperatorNode, ParenthesisNode, RangeNode, RelationalNode, SymbolNode }) => {
 	const parse = typed(name$45, {
 		string: function(expression) {
+			if (expression.length > 1e6) throw new SyntaxError(`expression exceeds ${MAX_EXPRESSION_LENGTH} characters`);
 			return parseStart(expression, {});
 		},
 		"Array | Matrix": function(expressions) {
 			return parseMultiple(expressions, {});
 		},
 		"string, Object": function(expression, options) {
+			if (expression.length > 1e6) throw new SyntaxError(`expression exceeds ${MAX_EXPRESSION_LENGTH} characters`);
 			return parseStart(expression, options.nodes !== void 0 ? options.nodes : {});
 		},
 		"Array | Matrix, Object": parseMultiple
@@ -583,7 +588,8 @@ const createParse = /* #__PURE__ */ factory(name$45, [
 			token: "",
 			tokenType: 0,
 			nestingLevel: 0,
-			conditionalLevel: null
+			conditionalLevel: null,
+			recursionDepth: 0
 		};
 	}
 	function currentString(state, length) {
@@ -731,8 +737,12 @@ const createParse = /* #__PURE__ */ factory(name$45, [
 		while (state.token === "\n");
 	}
 	function openParams(state) {
+		if (state.nestingLevel >= 124) throw createSyntaxError(state, "expression exceeds nesting limit");
 		state.nestingLevel++;
 	}
+	function enterRecursion(state) {
+		if (++state.recursionDepth > 500) throw createSyntaxError(state, "expression exceeds nesting limit");
+	}
 	function closeParams(state) {
 		state.nestingLevel--;
 	}
@@ -810,6 +820,14 @@ const createParse = /* #__PURE__ */ factory(name$45, [
 		}
 	}
 	function parseAssignment(state) {
+		enterRecursion(state);
+		try {
+			return parseAssignmentRule(state);
+		} finally {
+			state.recursionDepth--;
+		}
+	}
+	function parseAssignmentRule(state) {
 		let name;
 		let args;
 		let value;
@@ -1092,6 +1110,14 @@ const createParse = /* #__PURE__ */ factory(name$45, [
 		return node;
 	}
 	function parseUnary(state) {
+		enterRecursion(state);
+		try {
+			return parseUnaryRule(state);
+		} finally {
+			state.recursionDepth--;
+		}
+	}
+	function parseUnaryRule(state) {
 		let name;
 		let params;
 		let fn;
@@ -7140,7 +7166,7 @@ const embeddedDocs = {
 //#endregion
 //#region src/compiler/compile.ts
 function compile(node, mathScope) {
-	const evalFn = compileNode(node, mathScope, {});
+	const evalFn = compileNode(node, mathScope, {}, 0);
 	return { evaluate(userScope) {
 		let scope;
 		if (!userScope) scope = new ObjectWrappingMap({});
@@ -7149,23 +7175,25 @@ function compile(node, mathScope) {
 		return evalFn(scope, {}, void 0);
 	} };
 }
-function compileNode(node, math, argNames) {
+function compileNode(node, math, argNames, depth) {
+	if (depth >= 512) throw new Error(`expression exceeds compile depth 512`);
+	const nextDepth = depth + 1;
 	const n = node;
 	if (n.isConstantNode) return compileConstantNode(node);
 	if (n.isSymbolNode) return compileSymbolNode(node, math, argNames);
-	if (n.isOperatorNode) return compileOperatorNode(node, math, argNames);
-	if (n.isFunctionNode) return compileFunctionNode(node, math, argNames);
-	if (n.isParenthesisNode) return compileNode(n.content, math, argNames);
-	if (n.isArrayNode) return compileArrayNode(node, math, argNames);
-	if (n.isAssignmentNode) return compileAssignmentNode(node, math, argNames);
-	if (n.isBlockNode) return compileBlockNode(node, math, argNames);
-	if (n.isConditionalNode) return compileConditionalNode(node, math, argNames);
-	if (n.isObjectNode) return compileObjectNode(node, math, argNames);
-	if (n.isRangeNode) return compileRangeNode(node, math, argNames);
-	if (n.isRelationalNode) return compileRelationalNode(node, math, argNames);
-	if (n.isFunctionAssignmentNode) return compileFunctionAssignmentNode(node, math, argNames);
-	if (n.isAccessorNode) return compileAccessorNode(node, math, argNames);
-	if (n.isIndexNode) return compileIndexNode(node, math, argNames);
+	if (n.isOperatorNode) return compileOperatorNode(node, math, argNames, nextDepth);
+	if (n.isFunctionNode) return compileFunctionNode(node, math, argNames, nextDepth);
+	if (n.isParenthesisNode) return compileNode(n.content, math, argNames, nextDepth);
+	if (n.isArrayNode) return compileArrayNode(node, math, argNames, nextDepth);
+	if (n.isAssignmentNode) return compileAssignmentNode(node, math, argNames, nextDepth);
+	if (n.isBlockNode) return compileBlockNode(node, math, argNames, nextDepth);
+	if (n.isConditionalNode) return compileConditionalNode(node, math, argNames, nextDepth);
+	if (n.isObjectNode) return compileObjectNode(node, math, argNames, nextDepth);
+	if (n.isRangeNode) return compileRangeNode(node, math, argNames, nextDepth);
+	if (n.isRelationalNode) return compileRelationalNode(node, math, argNames, nextDepth);
+	if (n.isFunctionAssignmentNode) return compileFunctionAssignmentNode(node, math, argNames, nextDepth);
+	if (n.isAccessorNode) return compileAccessorNode(node, math, argNames, nextDepth);
+	if (n.isIndexNode) return compileIndexNode(node, math, argNames, nextDepth);
 	throw new Error(`Unknown node type: ${node.type || node.constructor?.name}`);
 }
 function compileConstantNode(node) {
@@ -7193,7 +7221,7 @@ function compileSymbolNode(node, math, argNames) {
 		throw new Error(`Undefined symbol "${name}"`);
 	};
 }
-function compileOperatorNode(node, math, argNames) {
+function compileOperatorNode(node, math, argNames, depth) {
 	const opNode = node;
 	const fnName = opNode.fn;
 	if (typeof fnName !== "string" || !(fnName in math)) throw new Error(`Function "${fnName}" missing in provided namespace "math"`);
@@ -7204,7 +7232,7 @@ function compileOperatorNode(node, math, argNames) {
 			return fn(rawNodes, math, scope);
 		};
 	}
-	const evalArgs = opNode.args.map((arg) => compileNode(arg, math, argNames));
+	const evalArgs = opNode.args.map((arg) => compileNode(arg, math, argNames, depth));
 	if (evalArgs.length === 1) {
 		const evalArg0 = evalArgs[0];
 		return function evalOperatorNode(scope, args, context) {
@@ -7223,7 +7251,7 @@ function compileOperatorNode(node, math, argNames) {
 		return fn(...values);
 	};
 }
-function compileFunctionNode(node, math, argNames) {
+function compileFunctionNode(node, math, argNames, depth) {
 	const fnNodeOuter = node;
 	const fnNode = fnNodeOuter.fn;
 	if (fnNode && fnNode.isSymbolNode) {
@@ -7233,11 +7261,11 @@ function compileFunctionNode(node, math, argNames) {
 			const rawNodes = fnNodeOuter.args;
 			return function evalFunctionNodeRaw(scope) {
 				const shadow = scope.has(name) ? scope.get(name) : void 0;
-				if (typeof shadow === "function" && shadow.rawArgs !== true) return shadow(...rawNodes.map((rn) => compileNode(rn, math, argNames)(scope, {}, void 0)));
+				if (typeof shadow === "function" && shadow.rawArgs !== true) return shadow(...rawNodes.map((rn) => compileNode(rn, math, argNames, depth)(scope, {}, void 0)));
 				return staticFn(rawNodes, math, scope);
 			};
 		}
-		const evalArgs = fnNodeOuter.args.map((arg) => compileNode(arg, math, argNames));
+		const evalArgs = fnNodeOuter.args.map((arg) => compileNode(arg, math, argNames, depth));
 		const resolveFn = (scope) => {
 			if (scope.has(name)) {
 				const value = scope.get(name);
@@ -7275,8 +7303,8 @@ function compileFunctionNode(node, math, argNames) {
 		}
 	}
 	if (fnNode && fnNode.isAccessorNode && fnNode.index && fnNode.index.isObjectProperty && fnNode.index.isObjectProperty()) {
-		const evalArgs = fnNodeOuter.args.map((arg) => compileNode(arg, math, argNames));
-		const evalObject = compileNode(fnNode.object, math, argNames);
+		const evalArgs = fnNodeOuter.args.map((arg) => compileNode(arg, math, argNames, depth));
+		const evalObject = compileNode(fnNode.object, math, argNames, depth);
 		const methodName = fnNode.index.getObjectProperty();
 		return function evalFunctionNode(scope, args, context) {
 			const obj = evalObject(scope, args, context);
@@ -7286,23 +7314,23 @@ function compileFunctionNode(node, math, argNames) {
 			return fn.apply(obj, values);
 		};
 	}
-	const evalArgs = fnNodeOuter.args.map((arg) => compileNode(arg, math, argNames));
-	const evalFn = compileNode(fnNode, math, argNames);
+	const evalArgs = fnNodeOuter.args.map((arg) => compileNode(arg, math, argNames, depth));
+	const evalFn = compileNode(fnNode, math, argNames, depth);
 	return function evalFunctionNode(scope, args, context) {
 		const fn = evalFn(scope, args, context);
 		if (typeof fn !== "function") throw new TypeError("Expression does not evaluate to a function");
 		return fn(...evalArgs.map((e) => e(scope, args, context)));
 	};
 }
-function compileArrayNode(node, math, argNames) {
-	const evalItems = node.items.map((item) => compileNode(item, math, argNames));
+function compileArrayNode(node, math, argNames, depth) {
+	const evalItems = node.items.map((item) => compileNode(item, math, argNames, depth));
 	return function evalArrayNode(scope, args, context) {
 		return evalItems.map((e) => e(scope, args, context));
 	};
 }
-function compileAssignmentNode(node, math, argNames) {
+function compileAssignmentNode(node, math, argNames, depth) {
 	const asgNode = node;
-	const evalValue = compileNode(asgNode.value, math, argNames);
+	const evalValue = compileNode(asgNode.value, math, argNames, depth);
 	if (asgNode.object && asgNode.object.isSymbolNode && !asgNode.index) {
 		const name = asgNode.object.name;
 		return function evalAssignmentNode(scope, args, context) {
@@ -7312,7 +7340,7 @@ function compileAssignmentNode(node, math, argNames) {
 		};
 	}
 	if (asgNode.object && asgNode.object.isAccessorNode) {
-		const evalObject = compileNode(asgNode.object.object, math, argNames);
+		const evalObject = compileNode(asgNode.object.object, math, argNames, depth);
 		if (asgNode.object.index && asgNode.object.index.isObjectProperty()) {
 			const prop = asgNode.object.index.getObjectProperty();
 			return function evalAssignmentNode(scope, args, context) {
@@ -7330,9 +7358,9 @@ function compileAssignmentNode(node, math, argNames) {
 	};
 	throw new Error("Unsupported assignment target");
 }
-function compileBlockNode(node, math, argNames) {
+function compileBlockNode(node, math, argNames, depth) {
 	const evalBlocks = node.blocks.map((block) => ({
-		evaluate: compileNode(block.node, math, argNames),
+		evaluate: compileNode(block.node, math, argNames, depth),
 		visible: block.visible
 	}));
 	return function evalBlockNode(scope, args, context) {
@@ -7345,20 +7373,20 @@ function compileBlockNode(node, math, argNames) {
 		if (results.length > 1) return results;
 	};
 }
-function compileConditionalNode(node, math, argNames) {
+function compileConditionalNode(node, math, argNames, depth) {
 	const condNode = node;
-	const evalCondition = compileNode(condNode.condition, math, argNames);
-	const evalTrueExpr = compileNode(condNode.trueExpr, math, argNames);
-	const evalFalseExpr = compileNode(condNode.falseExpr, math, argNames);
+	const evalCondition = compileNode(condNode.condition, math, argNames, depth);
+	const evalTrueExpr = compileNode(condNode.trueExpr, math, argNames, depth);
+	const evalFalseExpr = compileNode(condNode.falseExpr, math, argNames, depth);
 	return function evalConditionalNode(scope, args, context) {
 		return testCondition(evalCondition(scope, args, context)) ? evalTrueExpr(scope, args, context) : evalFalseExpr(scope, args, context);
 	};
 }
-function compileObjectNode(node, math, argNames) {
+function compileObjectNode(node, math, argNames, depth) {
 	const properties = node.properties;
 	const evalProps = Object.keys(properties).map((key) => ({
 		key,
-		evaluate: compileNode(properties[key], math, argNames)
+		evaluate: compileNode(properties[key], math, argNames, depth)
 	}));
 	return function evalObjectNode(scope, args, context) {
 		const result = {};
@@ -7366,14 +7394,14 @@ function compileObjectNode(node, math, argNames) {
 		return result;
 	};
 }
-function compileRangeNode(node, math, argNames) {
+function compileRangeNode(node, math, argNames, depth) {
 	const rangeFn = math.range;
 	if (!rangeFn) throw new Error("Function \"range\" missing in math namespace (required for range expressions)");
 	const rngNode = node;
-	const evalStart = compileNode(rngNode.start, math, argNames);
-	const evalEnd = compileNode(rngNode.end, math, argNames);
+	const evalStart = compileNode(rngNode.start, math, argNames, depth);
+	const evalEnd = compileNode(rngNode.end, math, argNames, depth);
 	if (rngNode.step) {
-		const evalStep = compileNode(rngNode.step, math, argNames);
+		const evalStep = compileNode(rngNode.step, math, argNames, depth);
 		return function evalRangeNode(scope, args, context) {
 			return rangeFn(evalStart(scope, args, context), evalEnd(scope, args, context), evalStep(scope, args, context));
 		};
@@ -7382,9 +7410,9 @@ function compileRangeNode(node, math, argNames) {
 		return rangeFn(evalStart(scope, args, context), evalEnd(scope, args, context));
 	};
 }
-function compileRelationalNode(node, math, argNames) {
+function compileRelationalNode(node, math, argNames, depth) {
 	const relNode = node;
-	const compiled = relNode.params.map((p) => compileNode(p, math, argNames));
+	const compiled = relNode.params.map((p) => compileNode(p, math, argNames, depth));
 	const conditionals = relNode.conditionals;
 	return function evalRelationalNode(scope, args, context) {
 		let evalLhs;
@@ -7399,11 +7427,11 @@ function compileRelationalNode(node, math, argNames) {
 		return true;
 	};
 }
-function compileFunctionAssignmentNode(node, math, argNames) {
+function compileFunctionAssignmentNode(node, math, argNames, depth) {
 	const faNode = node;
 	const childArgNames = Object.create(argNames);
 	for (const param of faNode.params) childArgNames[param] = true;
-	const evalExpr = compileNode(faNode.expr, math, childArgNames);
+	const evalExpr = compileNode(faNode.expr, math, childArgNames, depth);
 	const name = faNode.name;
 	const params = faNode.params;
 	return function evalFunctionAssignmentNode(scope, args, _context) {
@@ -7417,9 +7445,9 @@ function compileFunctionAssignmentNode(node, math, argNames) {
 		return fn;
 	};
 }
-function compileAccessorNode(node, math, argNames) {
+function compileAccessorNode(node, math, argNames, depth) {
 	const accNode = node;
-	const evalObject = compileNode(accNode.object, math, argNames);
+	const evalObject = compileNode(accNode.object, math, argNames, depth);
 	if (accNode.index && accNode.index.isObjectProperty && accNode.index.isObjectProperty()) {
 		const prop = accNode.index.getObjectProperty();
 		return function evalAccessorNode(scope, args, context) {
@@ -7428,7 +7456,7 @@ function compileAccessorNode(node, math, argNames) {
 			return getSafeProperty(object, prop);
 		};
 	}
-	const evalIndex = compileNode(accNode.index, math, argNames);
+	const evalIndex = compileNode(accNode.index, math, argNames, depth);
 	return function evalAccessorNode(scope, args, context) {
 		const object = evalObject(scope, args, context);
 		if (accNode.optionalChaining && object == null) return void 0;
@@ -7438,16 +7466,16 @@ function compileAccessorNode(node, math, argNames) {
 		return getSafeProperty(object, index);
 	};
 }
-function compileIndexNode(node, math, argNames) {
+function compileIndexNode(node, math, argNames, depth) {
 	const dimensionNodes = node.dimensions;
 	const usesEnd = dimensionNodes.map((dim) => dim.filter?.((n) => n.isSymbolNode === true && n.name === "end")?.length ?? 0);
 	const evalDimensions = dimensionNodes.map((dim, i) => {
 		if (usesEnd[i]) {
 			const childArgNames = Object.create(argNames);
 			childArgNames.end = true;
-			return compileNode(dim, math, childArgNames);
+			return compileNode(dim, math, childArgNames, depth);
 		}
-		return compileNode(dim, math, argNames);
+		return compileNode(dim, math, argNames, depth);
 	});
 	usesEnd.some((n) => n > 0);
 	return function evalIndexNode(scope, args, context) {
@@ -7491,8 +7519,9 @@ const FORBIDDEN_FUNCTIONS = /* @__PURE__ */ new Set([
 	"help",
 	"chain"
 ]);
-function validateAst(node) {
+function validateAst(node, depth = 0) {
 	if (node === null || node === void 0 || typeof node !== "object") return;
+	if (depth >= 512) throw new Error(`expression exceeds compile depth 512`);
 	const n = node;
 	if (n.isAssignmentNode === true) throw new Error("Security: assignment expressions are disabled. Pass `{ unsafe: true }` to opt out.");
 	if (n.isFunctionAssignmentNode === true) throw new Error("Security: function definitions (FunctionAssignmentNode) are disabled. Pass `{ unsafe: true }` to opt out.");
@@ -7502,10 +7531,10 @@ function validateAst(node) {
 		if (fnName && FORBIDDEN_FUNCTIONS.has(fnName)) throw new Error(`Security: call to forbidden function "${fnName}" is disabled. Pass \`{ unsafe: true }\` to opt out.`);
 	}
 	if (typeof n.forEach === "function") try {
-		n.forEach((child) => validateAst(child));
+		n.forEach((child) => validateAst(child, depth + 1));
 		return;
 	} catch (err) {
-		if (err instanceof Error && err.message.startsWith("Security:")) throw err;
+		if (err instanceof RangeError || err instanceof Error && (err.message.startsWith("Security:") || err.message.startsWith("expression exceeds"))) throw err;
 	}
 	for (const key of [
 		"object",
@@ -7520,19 +7549,19 @@ function validateAst(node) {
 		"start",
 		"end",
 		"step"
-	]) if (key in n) validateAst(n[key]);
+	]) if (key in n) validateAst(n[key], depth + 1);
 	for (const key of [
 		"args",
 		"items",
 		"params"
 	]) {
 		const arr = n[key];
-		if (Array.isArray(arr)) for (const child of arr) validateAst(child);
+		if (Array.isArray(arr)) for (const child of arr) validateAst(child, depth + 1);
 	}
-	if (Array.isArray(n.blocks)) for (const b of n.blocks) validateAst(b && b.node);
+	if (Array.isArray(n.blocks)) for (const b of n.blocks) validateAst(b && b.node, depth + 1);
 	if (n.properties && typeof n.properties === "object") {
 		const properties = n.properties;
-		for (const k of Object.keys(properties)) validateAst(properties[k]);
+		for (const k of Object.keys(properties)) validateAst(properties[k], depth + 1);
 	}
 }
 function createEvaluate(parseFn, mathScope) {
@@ -7836,6 +7865,11 @@ const createNode = /* #__PURE__ */ factory("Node", ["mathWithTransform"], ({ mat
 	isClass: true,
 	isNode: true
 });
+function mapChildArray(parent, children, pathPrefix, callback) {
+	const out = [];
+	for (let i = 0; i < children.length; i++) out[i] = parent._ifNode(callback(children[i], pathPrefix + "[" + i + "]", parent));
+	return out;
+}
 //#endregion
 //#region src/transform/utils/errorTransform.ts
 function errorTransform(err) {
@@ -7845,8 +7879,8 @@ function errorTransform(err) {
 }
 //#endregion
 //#region src/node/utils/stringSubset.ts
-function getStringSubset(str, index) {
-	if (!isIndex(index)) throw new TypeError("Index expected");
+function getStringSubset(str, index, invalidIndexMessage = "Index expected") {
+	if (!isIndex(index)) throw new TypeError(invalidIndexMessage);
 	if (isEmptyIndex(index)) return "";
 	validateIndexSourceSize(Array.from(str), index);
 	if (index.size().length !== 1) throw new DimensionError(index.size().length, 1);
@@ -8050,8 +8084,7 @@ const createArrayNode = /* #__PURE__ */ factory(name$39, ["Node"], ({ Node }) =>
 			}
 		}
 		map(callback) {
-			const items = [];
-			for (let i = 0; i < this.items.length; i++) items[i] = this._ifNode(callback(this.items[i], "items[" + i + "]", this));
+			const items = mapChildArray(this, this.items, "items", callback);
 			return new ArrayNode(items);
 		}
 		clone() {
@@ -8130,6 +8163,13 @@ const createAssignmentNode = /* #__PURE__ */ factory(name$38, ["subset", "Node"]
 		const exprPrecedence = getPrecedence(node.value, parenthesis, implicit, void 0);
 		return parenthesis === "all" || exprPrecedence !== null && exprPrecedence <= precedence;
 	}
+	function renderAssignment(node, options, render, markup) {
+		const object = render(node.object, options);
+		const index = node.index ? render(node.index, options) : "";
+		let value = render(node.value, options);
+		if (needParenthesis(node, options && options.parenthesis, options && options.implicit)) value = markup.paren(value);
+		return object + index + markup.eq + value;
+	}
 	class AssignmentNode extends Node {
 		object;
 		index;
@@ -8224,11 +8264,10 @@ const createAssignmentNode = /* #__PURE__ */ factory(name$38, ["subset", "Node"]
 			return new AssignmentNode(this.object, this.index, this.value);
 		}
 		_toString(options) {
-			const object = this.object.toString(options);
-			const index = this.index ? this.index.toString(options) : "";
-			let value = this.value.toString(options);
-			if (needParenthesis(this, options && options.parenthesis, options && options.implicit)) value = "(" + value + ")";
-			return object + index + " = " + value;
+			return renderAssignment(this, options, (node, opts) => node.toString(opts), {
+				paren: (value) => "(" + value + ")",
+				eq: " = "
+			});
 		}
 		toJSON() {
 			return {
@@ -8242,11 +8281,10 @@ const createAssignmentNode = /* #__PURE__ */ factory(name$38, ["subset", "Node"]
 			return new AssignmentNode(json.object, json.index, json.value);
 		}
 		_toHTML(options) {
-			const object = this.object.toHTML(options);
-			const index = this.index ? this.index.toHTML(options) : "";
-			let value = this.value.toHTML(options);
-			if (needParenthesis(this, options && options.parenthesis, options && options.implicit)) value = "<span class=\"math-paranthesis math-round-parenthesis\">(</span>" + value + "<span class=\"math-paranthesis math-round-parenthesis\">)</span>";
-			return object + index + "<span class=\"math-operator math-assignment-operator math-variable-assignment-operator math-binary-operator\">=</span>" + value;
+			return renderAssignment(this, options, (node, opts) => node.toHTML(opts), {
+				paren: (value) => "<span class=\"math-paranthesis math-round-parenthesis\">(</span>" + value + "<span class=\"math-paranthesis math-round-parenthesis\">)</span>",
+				eq: "<span class=\"math-operator math-assignment-operator math-variable-assignment-operator math-binary-operator\">=</span>"
+			});
 		}
 		_toMathML() {
 			const obj = this.object;
@@ -8257,11 +8295,10 @@ const createAssignmentNode = /* #__PURE__ */ factory(name$38, ["subset", "Node"]
 			return `<mtext>${escapeMathML(this.toString())}</mtext>`;
 		}
 		_toTex(options) {
-			const object = this.object.toTex(options);
-			const index = this.index ? this.index.toTex(options) : "";
-			let value = this.value.toTex(options);
-			if (needParenthesis(this, options && options.parenthesis, options && options.implicit)) value = `\\left(${value}\\right)`;
-			return object + index + "=" + value;
+			return renderAssignment(this, options, (node, opts) => node.toTex(opts), {
+				paren: (value) => `\\left(${value}\\right)`,
+				eq: "="
+			});
 		}
 	}
 	return AssignmentNode;
@@ -8380,6 +8417,17 @@ const createConditionalNode = /* #__PURE__ */ factory(name$36, ["Node"], ({ Node
 		if (condition === null || condition === void 0) return false;
 		throw new TypeError("Unsupported type of condition \"" + typeOf(condition) + "\"");
 	}
+	function formatConditionalBranches(self, options, render, wrap, join) {
+		const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
+		const precedence = getPrecedence(self, parenthesis, options && options.implicit, void 0);
+		function branchText(node) {
+			let text = render(node);
+			const nodePrecedence = getPrecedence(node, parenthesis, options && options.implicit, void 0);
+			if (parenthesis === "all" || node.type === "OperatorNode" || nodePrecedence !== null && nodePrecedence <= precedence) text = wrap(text);
+			return text;
+		}
+		return join(branchText(self.condition), branchText(self.trueExpr), branchText(self.falseExpr));
+	}
 	class ConditionalNode extends Node {
 		condition;
 		trueExpr;
@@ -8420,18 +8468,7 @@ const createConditionalNode = /* #__PURE__ */ factory(name$36, ["Node"], ({ Node
 			return new ConditionalNode(this.condition, this.trueExpr, this.falseExpr);
 		}
 		_toString(options) {
-			const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
-			const precedence = getPrecedence(this, parenthesis, options && options.implicit, void 0);
-			let condition = this.condition.toString(options);
-			const conditionPrecedence = getPrecedence(this.condition, parenthesis, options && options.implicit, void 0);
-			if (parenthesis === "all" || this.condition.type === "OperatorNode" || conditionPrecedence !== null && conditionPrecedence <= precedence) condition = "(" + condition + ")";
-			let trueExpr = this.trueExpr.toString(options);
-			const truePrecedence = getPrecedence(this.trueExpr, parenthesis, options && options.implicit, void 0);
-			if (parenthesis === "all" || this.trueExpr.type === "OperatorNode" || truePrecedence !== null && truePrecedence <= precedence) trueExpr = "(" + trueExpr + ")";
-			let falseExpr = this.falseExpr.toString(options);
-			const falsePrecedence = getPrecedence(this.falseExpr, parenthesis, options && options.implicit, void 0);
-			if (parenthesis === "all" || this.falseExpr.type === "OperatorNode" || falsePrecedence !== null && falsePrecedence <= precedence) falseExpr = "(" + falseExpr + ")";
-			return condition + " ? " + trueExpr + " : " + falseExpr;
+			return formatConditionalBranches(this, options, (node) => node.toString(options), (inner) => "(" + inner + ")", (condition, trueExpr, falseExpr) => condition + " ? " + trueExpr + " : " + falseExpr);
 		}
 		toJSON() {
 			return {
@@ -8445,18 +8482,9 @@ const createConditionalNode = /* #__PURE__ */ factory(name$36, ["Node"], ({ Node
 			return new ConditionalNode(json.condition, json.trueExpr, json.falseExpr);
 		}
 		_toHTML(options) {
-			const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
-			const precedence = getPrecedence(this, parenthesis, options && options.implicit, void 0);
-			let condition = this.condition.toHTML(options);
-			const conditionPrecedence = getPrecedence(this.condition, parenthesis, options && options.implicit, void 0);
-			if (parenthesis === "all" || this.condition.type === "OperatorNode" || conditionPrecedence !== null && conditionPrecedence <= precedence) condition = "<span class=\"math-parenthesis math-round-parenthesis\">(</span>" + condition + "<span class=\"math-parenthesis math-round-parenthesis\">)</span>";
-			let trueExpr = this.trueExpr.toHTML(options);
-			const truePrecedence = getPrecedence(this.trueExpr, parenthesis, options && options.implicit, void 0);
-			if (parenthesis === "all" || this.trueExpr.type === "OperatorNode" || truePrecedence !== null && truePrecedence <= precedence) trueExpr = "<span class=\"math-parenthesis math-round-parenthesis\">(</span>" + trueExpr + "<span class=\"math-parenthesis math-round-parenthesis\">)</span>";
-			let falseExpr = this.falseExpr.toHTML(options);
-			const falsePrecedence = getPrecedence(this.falseExpr, parenthesis, options && options.implicit, void 0);
-			if (parenthesis === "all" || this.falseExpr.type === "OperatorNode" || falsePrecedence !== null && falsePrecedence <= precedence) falseExpr = "<span class=\"math-parenthesis math-round-parenthesis\">(</span>" + falseExpr + "<span class=\"math-parenthesis math-round-parenthesis\">)</span>";
-			return condition + "<span class=\"math-operator math-conditional-operator\">?</span>" + trueExpr + "<span class=\"math-operator math-conditional-operator\">:</span>" + falseExpr;
+			const parenOpen = "<span class=\"math-parenthesis math-round-parenthesis\">(</span>";
+			const parenClose = "<span class=\"math-parenthesis math-round-parenthesis\">)</span>";
+			return formatConditionalBranches(this, options, (node) => node.toHTML(options), (inner) => parenOpen + inner + parenClose, (condition, trueExpr, falseExpr) => condition + "<span class=\"math-operator math-conditional-operator\">?</span>" + trueExpr + "<span class=\"math-operator math-conditional-operator\">:</span>" + falseExpr);
 		}
 		_toTex(options) {
 			return "\\begin{cases} {" + this.trueExpr.toTex(options) + "}, &\\quad{\\text{if }\\;" + this.condition.toTex(options) + "}\\\\{" + this.falseExpr.toTex(options) + "}, &\\quad{\\text{otherwise}}\\end{cases}";
@@ -9173,8 +9201,7 @@ const createFunctionNode = /* #__PURE__ */ factory(name$33, [
 		}
 		map(callback) {
 			const fn = this._ifNode(callback(this.fn, "fn", this));
-			const args = [];
-			for (let i = 0; i < this.args.length; i++) args[i] = this._ifNode(callback(this.args[i], "args[" + i + "]", this));
+			const args = mapChildArray(this, this.args, "args", callback);
 			return new FunctionNode(fn, args);
 		}
 		clone() {
@@ -9315,8 +9342,7 @@ const createIndexNode = /* #__PURE__ */ factory(name$32, ["Node", "size"], ({ No
 			for (let i = 0; i < this.dimensions.length; i++) callback(this.dimensions[i], "dimensions[" + i + "]", this);
 		}
 		map(callback) {
-			const dimensions = [];
-			for (let i = 0; i < this.dimensions.length; i++) dimensions[i] = this._ifNode(callback(this.dimensions[i], "dimensions[" + i + "]", this));
+			const dimensions = mapChildArray(this, this.dimensions, "dimensions", callback);
 			return new IndexNode(dimensions, this.dotNotation);
 		}
 		clone() {
@@ -9364,6 +9390,11 @@ const createIndexNode = /* #__PURE__ */ factory(name$32, ["Node", "size"], ({ No
 //#region src/node/ObjectNode.ts
 const name$31 = "ObjectNode";
 const createObjectNode = /* #__PURE__ */ factory(name$31, ["Node"], ({ Node }) => {
+	function renderObjectEntries(properties, entry, separator, wrap) {
+		const entries = [];
+		for (const key in properties) if (hasOwnProperty(properties, key)) entries.push(entry(key, properties[key]));
+		return wrap(entries.join(separator));
+	}
 	class ObjectNode extends Node {
 		properties;
 		constructor(properties) {
@@ -9399,18 +9430,16 @@ const createObjectNode = /* #__PURE__ */ factory(name$31, ["Node"], ({ Node }) =
 		}
 		map(callback) {
 			const properties = {};
-			for (const key in this.properties) if (hasOwnProperty(this.properties, key)) properties[key] = this._ifNode(callback(this.properties[key], "properties[" + stringify(key) + "]", this));
+			for (const key in this.properties) if (hasOwnProperty(this.properties, key)) setSafeProperty(properties, key, this._ifNode(callback(this.properties[key], "properties[" + stringify(key) + "]", this)));
 			return new ObjectNode(properties);
 		}
 		clone() {
 			const properties = {};
-			for (const key in this.properties) if (hasOwnProperty(this.properties, key)) properties[key] = this.properties[key];
+			for (const key in this.properties) if (hasOwnProperty(this.properties, key)) setSafeProperty(properties, key, this.properties[key]);
 			return new ObjectNode(properties);
 		}
 		_toString(options) {
-			const entries = [];
-			for (const key in this.properties) if (hasOwnProperty(this.properties, key)) entries.push(stringify(key) + ": " + this.properties[key].toString(options));
-			return "{" + entries.join(", ") + "}";
+			return renderObjectEntries(this.properties, (key, node) => stringify(key) + ": " + node.toString(options), ", ", (joined) => "{" + joined + "}");
 		}
 		toJSON() {
 			return {
@@ -9422,14 +9451,10 @@ const createObjectNode = /* #__PURE__ */ factory(name$31, ["Node"], ({ Node }) =
 			return new ObjectNode(json.properties);
 		}
 		_toHTML(options) {
-			const entries = [];
-			for (const key in this.properties) if (hasOwnProperty(this.properties, key)) entries.push("<span class=\"math-symbol math-property\">" + escape(key) + "</span><span class=\"math-operator math-assignment-operator math-property-assignment-operator math-binary-operator\">:</span>" + this.properties[key].toHTML(options));
-			return "<span class=\"math-parenthesis math-curly-parenthesis\">{</span>" + entries.join("<span class=\"math-separator\">,</span>") + "<span class=\"math-parenthesis math-curly-parenthesis\">}</span>";
+			return renderObjectEntries(this.properties, (key, node) => "<span class=\"math-symbol math-property\">" + escape(key) + "</span><span class=\"math-operator math-assignment-operator math-property-assignment-operator math-binary-operator\">:</span>" + node.toHTML(options), "<span class=\"math-separator\">,</span>", (joined) => "<span class=\"math-parenthesis math-curly-parenthesis\">{</span>" + joined + "<span class=\"math-parenthesis math-curly-parenthesis\">}</span>");
 		}
 		_toTex(options) {
-			const entries = [];
-			for (const key in this.properties) if (hasOwnProperty(this.properties, key)) entries.push("\\mathbf{" + key + ":} & " + this.properties[key].toTex(options) + "\\\\");
-			return "\\left\\{\\begin{array}{ll}" + entries.join("\n") + "\\end{array}\\right\\}";
+			return renderObjectEntries(this.properties, (key, node) => "\\mathbf{" + key + ":} & " + node.toTex(options) + "\\\\", "\n", (joined) => "\\left\\{\\begin{array}{ll}" + joined + "\\end{array}\\right\\}");
 		}
 	}
 	return ObjectNode;
@@ -9448,10 +9473,19 @@ const createOperatorNode = /* #__PURE__ */ factory(name$30, ["Node"], ({ Node })
 		if (isOperatorNode(curNode)) return startsWithConstant(curNode.args[0], parenthesis);
 		return false;
 	}
+	function isNegativeNumberConstant(arg) {
+		const content = arg.getContent();
+		if (!isConstantNode(content)) return false;
+		const value = content.value;
+		return typeof value === "number" && value < 0;
+	}
+	function parenthesizeNegativeConstants(args, parens) {
+		return args.map((arg, i) => parens[i] === true || isNegativeNumberConstant(arg));
+	}
 	function calculateNecessaryParentheses(root, parenthesis, implicit, args, latex) {
 		const precedence = getPrecedence(root, parenthesis, implicit, void 0);
 		const associativity = getAssociativity(root, parenthesis);
-		if (parenthesis === "all" || args.length > 2 && root.getIdentifier() !== "OperatorNode:add" && root.getIdentifier() !== "OperatorNode:multiply") return args.map(function(arg) {
+		if (parenthesis === "all" || args.length > 2 && root.getIdentifier() !== "OperatorNode:add" && root.getIdentifier() !== "OperatorNode:multiply") return parenthesizeNegativeConstants(args, args.map(function(arg) {
 			switch (arg.getContent().type) {
 				case "ArrayNode":
 				case "ConstantNode":
@@ -9459,7 +9493,7 @@ const createOperatorNode = /* #__PURE__ */ factory(name$30, ["Node"], ({ Node })
 				case "ParenthesisNode": return false;
 				default: return true;
 			}
-		});
+		}));
 		let result = [];
 		switch (args.length) {
 			case 0:
@@ -9552,7 +9586,7 @@ const createOperatorNode = /* #__PURE__ */ factory(name$30, ["Node"], ({ Node })
 		if (args.length >= 2 && root.getIdentifier() === "OperatorNode:multiply" && root.implicit && parenthesis !== "all" && implicit === "hide") {
 			for (let i = 1; i < result.length; ++i) if (startsWithConstant(args[i], parenthesis) && !result[i - 1] && (parenthesis !== "keep" || !isParenthesisNode(args[i - 1]))) result[i] = true;
 		}
-		return result;
+		return parenthesizeNegativeConstants(args, result);
 	}
 	class OperatorNode extends Node {
 		op;
@@ -9613,8 +9647,7 @@ const createOperatorNode = /* #__PURE__ */ factory(name$30, ["Node"], ({ Node })
 			for (let i = 0; i < this.args.length; i++) callback(this.args[i], "args[" + i + "]", this);
 		}
 		map(callback) {
-			const args = [];
-			for (let i = 0; i < this.args.length; i++) args[i] = this._ifNode(callback(this.args[i], "args[" + i + "]", this));
+			const args = mapChildArray(this, this.args, "args", callback);
 			return new OperatorNode(this.op, this.fn, args, this.implicit, this.isPercentage);
 		}
 		clone() {
@@ -9857,6 +9890,21 @@ const createRangeNode = /* #__PURE__ */ factory(name$28, ["Node"], ({ Node }) =>
 		parens.end = endPrecedence !== null && endPrecedence <= precedence || parenthesis === "all";
 		return parens;
 	}
+	function formatRangeDisplay(node, options, render, wrap, rangeSep) {
+		const parens = calculateNecessaryParentheses(node, options && options.parenthesis ? options.parenthesis : "keep", options && options.implicit || "hide");
+		let start = render(node.start);
+		if (parens.start) start = wrap(start);
+		let str = start;
+		if (node.step) {
+			let step = render(node.step);
+			if (parens.step) step = wrap(step);
+			str += rangeSep() + step;
+		}
+		let end = render(node.end);
+		if (parens.end) end = wrap(end);
+		str += rangeSep() + end;
+		return str;
+	}
 	class RangeNode extends Node {
 		start;
 		end;
@@ -9908,21 +9956,7 @@ const createRangeNode = /* #__PURE__ */ factory(name$28, ["Node"], ({ Node }) =>
 			return new RangeNode(this.start, this.end, this.step || void 0);
 		}
 		_toString(options) {
-			const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
-			const parens = calculateNecessaryParentheses(this, parenthesis, options && options.implicit || "hide");
-			let str;
-			let start = this.start.toString(options);
-			if (parens.start) start = "(" + start + ")";
-			str = start;
-			if (this.step) {
-				let step = this.step.toString(options);
-				if (parens.step) step = "(" + step + ")";
-				str += ":" + step;
-			}
-			let end = this.end.toString(options);
-			if (parens.end) end = "(" + end + ")";
-			str += ":" + end;
-			return str;
+			return formatRangeDisplay(this, options, (child) => child.toString(options), (inner) => "(" + inner + ")", () => ":");
 		}
 		toJSON() {
 			return {
@@ -9936,21 +9970,9 @@ const createRangeNode = /* #__PURE__ */ factory(name$28, ["Node"], ({ Node }) =>
 			return new RangeNode(json.start, json.end, json.step);
 		}
 		_toHTML(options) {
-			const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
-			const parens = calculateNecessaryParentheses(this, parenthesis, options && options.implicit || "hide");
-			let str;
-			let start = this.start.toHTML(options);
-			if (parens.start) start = "<span class=\"math-parenthesis math-round-parenthesis\">(</span>" + start + "<span class=\"math-parenthesis math-round-parenthesis\">)</span>";
-			str = start;
-			if (this.step) {
-				let step = this.step.toHTML(options);
-				if (parens.step) step = "<span class=\"math-parenthesis math-round-parenthesis\">(</span>" + step + "<span class=\"math-parenthesis math-round-parenthesis\">)</span>";
-				str += "<span class=\"math-operator math-range-operator\">:</span>" + step;
-			}
-			let end = this.end.toHTML(options);
-			if (parens.end) end = "<span class=\"math-parenthesis math-round-parenthesis\">(</span>" + end + "<span class=\"math-parenthesis math-round-parenthesis\">)</span>";
-			str += "<span class=\"math-operator math-range-operator\">:</span>" + end;
-			return str;
+			const parenOpen = "<span class=\"math-parenthesis math-round-parenthesis\">(</span>";
+			const parenClose = "<span class=\"math-parenthesis math-round-parenthesis\">)</span>";
+			return formatRangeDisplay(this, options, (child) => child.toHTML(options), (inner) => parenOpen + inner + parenClose, () => "<span class=\"math-operator math-range-operator\">:</span>");
 		}
 		_toTex(options) {
 			const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
@@ -9985,6 +10007,18 @@ const createRelationalNode = /* #__PURE__ */ factory(name$27, ["Node"], ({ Node
 		smallerEq: "<=",
 		largerEq: ">="
 	};
+	function renderRelational(self, options, renderParam, wrapParam, join) {
+		const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
+		const precedence = getPrecedence(self, parenthesis, options && options.implicit || "hide", void 0);
+		const paramStrings = self.params.map(function(p) {
+			const paramPrecedence = getPrecedence(p, parenthesis, options && options.implicit || "hide", void 0);
+			const text = renderParam(p);
+			return parenthesis === "all" || paramPrecedence !== null && paramPrecedence <= precedence ? wrapParam(text) : text;
+		});
+		let ret = paramStrings[0];
+		for (let i = 0; i < self.conditionals.length; i++) ret += join(self.conditionals[i], paramStrings[i + 1]);
+		return ret;
+	}
 	class RelationalNode extends Node {
 		conditionals;
 		params;
@@ -10027,18 +10061,7 @@ const createRelationalNode = /* #__PURE__ */ factory(name$27, ["Node"], ({ Node
 			return new RelationalNode(this.conditionals, this.params);
 		}
 		_toString(options) {
-			const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
-			const precedence = getPrecedence(this, parenthesis, options && options.implicit || "hide", void 0);
-			const paramStrings = this.params.map(function(p, _index) {
-				const paramPrecedence = getPrecedence(p, parenthesis, options && options.implicit || "hide", void 0);
-				return parenthesis === "all" || paramPrecedence !== null && paramPrecedence <= precedence ? "(" + p.toString(options) + ")" : p.toString(options);
-			});
-			let ret = paramStrings[0];
-			for (let i = 0; i < this.conditionals.length; i++) {
-				ret += " " + operatorMap[this.conditionals[i]];
-				ret += " " + paramStrings[i + 1];
-			}
-			return ret;
+			return renderRelational(this, options, (p) => p.toString(options), (inner) => "(" + inner + ")", (cond, rhs) => " " + operatorMap[cond] + " " + rhs);
 		}
 		toJSON() {
 			return {
@@ -10051,15 +10074,7 @@ const createRelationalNode = /* #__PURE__ */ factory(name$27, ["Node"], ({ Node
 			return new RelationalNode(json.conditionals, json.params);
 		}
 		_toHTML(options) {
-			const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
-			const precedence = getPrecedence(this, parenthesis, options && options.implicit || "hide", void 0);
-			const paramStrings = this.params.map(function(p, _index) {
-				const paramPrecedence = getPrecedence(p, parenthesis, options && options.implicit || "hide", void 0);
-				return parenthesis === "all" || paramPrecedence !== null && paramPrecedence <= precedence ? "<span class=\"math-parenthesis math-round-parenthesis\">(</span>" + p.toHTML(options) + "<span class=\"math-parenthesis math-round-parenthesis\">)</span>" : p.toHTML(options);
-			});
-			let ret = paramStrings[0];
-			for (let i = 0; i < this.conditionals.length; i++) ret += "<span class=\"math-operator math-binary-operator math-explicit-binary-operator\">" + escape(operatorMap[this.conditionals[i]]) + "</span>" + paramStrings[i + 1];
-			return ret;
+			return renderRelational(this, options, (param) => param.toHTML(options), (inner) => "<span class=\"math-parenthesis math-round-parenthesis\">(</span>" + inner + "<span class=\"math-parenthesis math-round-parenthesis\">)</span>", (conditional, rhs) => "<span class=\"math-operator math-binary-operator math-explicit-binary-operator\">" + escape(operatorMap[conditional]) + "</span>" + rhs);
 		}
 		_toMathML() {
 			const params = this.params;
@@ -10072,15 +10087,8 @@ const createRelationalNode = /* #__PURE__ */ factory(name$27, ["Node"], ({ Node
 			return `<mtext>${escapeMathML(this.toString())}</mtext>`;
 		}
 		_toTex(options) {
-			const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
-			const precedence = getPrecedence(this, parenthesis, options && options.implicit || "hide", void 0);
-			const paramStrings = this.params.map(function(p, _index) {
-				const paramPrecedence = getPrecedence(p, parenthesis, options && options.implicit || "hide", void 0);
-				return parenthesis === "all" || paramPrecedence !== null && paramPrecedence <= precedence ? "\\left(" + p.toTex(options) + "\\right)" : p.toTex(options);
-			});
-			let ret = paramStrings[0];
-			for (let i = 0; i < this.conditionals.length; i++) ret += latexOperators[this.conditionals[i]] + paramStrings[i + 1];
-			return ret;
+			const latex = latexOperators;
+			return renderRelational(this, options, (p) => p.toTex(options), (inner) => "\\left(" + inner + "\\right)", (cond, rhs) => latex[cond] + rhs);
 		}
 	}
 	return RelationalNode;
@@ -10202,7 +10210,7 @@ const SCALAR_FUNCTIONS = [
 	"tanh",
 	"abs"
 ];
-const LOWERED_FUNCTIONS = new Set(Object.values(SCALAR_FUNCTION_LOWERING));
+const LOWERED_FUNCTIONS$1 = new Set(Object.values(SCALAR_FUNCTION_LOWERING));
 var ScalarBuildError = class extends Error {
 	constructor(message) {
 		super(message);
@@ -10222,8 +10230,8 @@ function isOperator(op) {
 function isScalarFunctionName(fn) {
 	return Object.prototype.hasOwnProperty.call(SCALAR_FUNCTION_LOWERING, fn);
 }
-function isLoweredScalarFn(fn) {
-	return LOWERED_FUNCTIONS.has(fn);
+function isLoweredScalarFn$1(fn) {
+	return LOWERED_FUNCTIONS$1.has(fn);
 }
 function isCanonicalNode(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
@@ -10290,7 +10298,7 @@ function createScalarBuilder() {
 			}
 			case "call": {
 				const fn = record.fn;
-				if (typeof fn !== "string" || !isLoweredScalarFn(fn)) throw new ScalarBuildError(`scalar call '${String(fn)}' must already use a lowered MathTS name`);
+				if (typeof fn !== "string" || !isLoweredScalarFn$1(fn)) throw new ScalarBuildError(`scalar call '${String(fn)}' must already use a lowered MathTS name`);
 				return {
 					kind: "call",
 					fn,
@@ -10314,36 +10322,590 @@ function createScalarBuilder() {
 		from
 	};
 }
+//#endregion
+//#region src/scalar-structure.ts
+const LOWERED_FUNCTIONS = new Set(Object.values(SCALAR_FUNCTION_LOWERING));
+function isLoweredScalarFn(fn) {
+	return LOWERED_FUNCTIONS.has(fn);
+}
+function spell(value) {
+	if (Number.isNaN(value)) return "NaN";
+	if (Object.is(value, -0)) return "-0";
+	if (value === Infinity) return "Infinity";
+	if (value === -Infinity) return "-Infinity";
+	return value.toString();
+}
+function assertPowerArity(args) {
+	if (args.length !== 2) throw new ScalarBuildError(`'^' needs exactly 2 args, got ${args.length}`);
+}
+function assertCallFn(fn) {
+	if (!isLoweredScalarFn(fn)) throw new ScalarBuildError(`unknown scalar function '${String(fn)}'`);
+	return fn;
+}
+function forEachScalar(node, visit) {
+	function walk(n, depth) {
+		visit(n, depth);
+		if (n.kind === "call") walk(n.arg, depth + 1);
+		else if (n.kind === "op") for (const child of n.args) walk(child, depth + 1);
+	}
+	walk(node, 0);
+}
+function mapScalar(node, fn) {
+	let rebuilt;
+	if (node.kind === "number" || node.kind === "symbol") rebuilt = node;
+	else if (node.kind === "call") {
+		const newArg = mapScalar(node.arg, fn);
+		rebuilt = newArg === node.arg ? node : {
+			kind: "call",
+			fn: node.fn,
+			arg: newArg
+		};
+	} else {
+		const newArgs = node.args.map((child) => mapScalar(child, fn));
+		rebuilt = newArgs.every((child, i) => child === node.args[i]) ? node : {
+			kind: "op",
+			op: node.op,
+			args: newArgs
+		};
+	}
+	const result = fn(rebuilt);
+	if (result === rebuilt && rebuilt === node) return node;
+	return result;
+}
+function scalarSize(node) {
+	let count = 0;
+	forEachScalar(node, () => {
+		count += 1;
+	});
+	return count;
+}
+function scalarDepth(node) {
+	if (node.kind === "number" || node.kind === "symbol") return 1;
+	if (node.kind === "call") return 1 + scalarDepth(node.arg);
+	if (node.args.length === 0) return 1;
+	let maxChild = 0;
+	for (const child of node.args) {
+		const d = scalarDepth(child);
+		if (d > maxChild) maxChild = d;
+	}
+	return 1 + maxChild;
+}
+function ownWeight(record, key) {
+	return record !== void 0 && hasOwnProperty(record, key) ? record[key] ?? 1 : 1;
+}
+function symbolWeight(name, weights) {
+	const w = weights.symbol;
+	if (w === void 0) return 1;
+	if (typeof w === "number") return w;
+	return ownWeight(w, name);
+}
+function nodeWeight(node, weights) {
+	switch (node.kind) {
+		case "number": return weights.number ?? 1;
+		case "symbol": return symbolWeight(node.name, weights);
+		case "call": return ownWeight(weights.call, node.fn);
+		case "op": return ownWeight(weights.op, node.op);
+	}
+}
+function scalarComplexity(node, weights = {}) {
+	let sum = 0;
+	forEachScalar(node, (n) => {
+		sum += nodeWeight(n, weights);
+	});
+	return Math.round(sum);
+}
+function scalarSymbols(node) {
+	const names = /* @__PURE__ */ new Set();
+	forEachScalar(node, (n) => {
+		if (n.kind === "symbol") names.add(n.name);
+	});
+	return [...names].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+}
+function factorToPowerNode(f) {
+	if (Object.is(f.exp, 1)) return f.base;
+	return {
+		kind: "op",
+		op: "^",
+		args: [f.base, {
+			kind: "number",
+			value: f.exp
+		}]
+	};
+}
+function collectFactors(node) {
+	if (node.kind === "op" && node.op === "*") {
+		const out = [];
+		for (const child of node.args) out.push(...collectFactors(child));
+		return out;
+	}
+	if (node.kind === "op" && node.op === "^") {
+		assertPowerArity(node.args);
+		const [base, expNode] = node.args;
+		if (expNode.kind === "number" && Number.isFinite(expNode.value)) return collectFactors(base).map((f) => ({
+			base: f.base,
+			exp: f.exp * expNode.value
+		}));
+		return [{
+			base: node,
+			exp: 1
+		}];
+	}
+	return [{
+		base: node,
+		exp: 1
+	}];
+}
+function fullyFlattenFactors(factors) {
+	const out = [];
+	for (const f of factors) out.push(...collectFactors(factorToPowerNode(f)));
+	return out;
+}
+function encodeCanonicalKey(node) {
+	switch (node.kind) {
+		case "number": return JSON.stringify({
+			k: "n",
+			v: spell(node.value)
+		});
+		case "symbol": return JSON.stringify({
+			k: "s",
+			v: node.name
+		});
+		case "call": {
+			assertCallFn(node.fn);
+			const argKey = encodeCanonicalKey(node.arg);
+			const obj = {
+				k: "c",
+				f: node.fn,
+				a: JSON.parse(argKey)
+			};
+			return JSON.stringify(obj);
+		}
+		case "op":
+			if (node.op === "^") {
+				assertPowerArity(node.args);
+				const [base, exp] = node.args;
+				const obj = {
+					k: "^",
+					b: JSON.parse(encodeCanonicalKey(base)),
+					e: JSON.parse(encodeCanonicalKey(exp))
+				};
+				return JSON.stringify(obj);
+			}
+			if (node.op === "+" || node.op === "*") {
+				const keys = node.args.map((arg) => encodeCanonicalKey(arg)).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+				const obj = {
+					k: node.op,
+					a: keys.map((k) => JSON.parse(k))
+				};
+				return JSON.stringify(obj);
+			}
+			throw new ScalarBuildError(`scalar canonical: unexpected operator '${node.op}'`);
+	}
+}
+function baseKey(node) {
+	return encodeCanonicalKey(node);
+}
+function fromProduct(factors) {
+	const flat = fullyFlattenFactors(factors);
+	const coefficients = [];
+	const rest = [];
+	for (const f of flat) if (f.base.kind === "number" && Object.is(f.exp, 1)) coefficients.push(f);
+	else rest.push(f);
+	let coeff = 1;
+	for (const c of coefficients) if (c.base.kind === "number") coeff *= c.base.value;
+	const groups = /* @__PURE__ */ new Map();
+	const groupOrder = [];
+	for (const f of rest) {
+		const key = baseKey(f.base);
+		const existing = groups.get(key);
+		if (existing) existing.sum += f.exp;
+		else {
+			groups.set(key, {
+				base: f.base,
+				sum: f.exp
+			});
+			groupOrder.push(key);
+		}
+	}
+	const materialized = [];
+	for (const key of groupOrder) {
+		const { base, sum } = groups.get(key);
+		if (Object.is(sum, 1)) materialized.push(base);
+		else materialized.push({
+			kind: "op",
+			op: "^",
+			args: [base, {
+				kind: "number",
+				value: sum
+			}]
+		});
+	}
+	const hasOther = materialized.length > 0;
+	if (coefficients.length > 0) {
+		if (!Object.is(coeff, 1) || !hasOther) materialized.push({
+			kind: "number",
+			value: coeff
+		});
+	}
+	if (materialized.length === 0) return {
+		kind: "number",
+		value: 1
+	};
+	if (materialized.length === 1) return materialized[0];
+	return {
+		kind: "op",
+		op: "*",
+		args: materialized.map((node) => ({
+			node,
+			key: encodeCanonicalKey(node)
+		})).sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0).map((entry) => entry.node)
+	};
+}
+function fromSum(parts) {
+	const inlined = [];
+	for (const part of parts) if (part.kind === "op" && part.op === "+") inlined.push(...part.args);
+	else inlined.push(part);
+	let numericSum;
+	const nonNumbers = [];
+	for (const part of inlined) if (part.kind === "number") numericSum = numericSum === void 0 ? part.value : numericSum + part.value;
+	else nonNumbers.push(part);
+	const addends = [...nonNumbers];
+	if (numericSum !== void 0) addends.push({
+		kind: "number",
+		value: numericSum
+	});
+	if (addends.length === 0) return {
+		kind: "number",
+		value: 0
+	};
+	if (addends.length === 1) return addends[0];
+	return {
+		kind: "op",
+		op: "+",
+		args: addends.map((node) => ({
+			node,
+			key: encodeCanonicalKey(node)
+		})).sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0).map((entry) => entry.node)
+	};
+}
+function canonProductByNumber(node, coeff) {
+	return fromProduct([{
+		base: {
+			kind: "number",
+			value: coeff
+		},
+		exp: 1
+	}, ...collectFactors(node)]);
+}
+function inversePower(t) {
+	return {
+		kind: "op",
+		op: "^",
+		args: [t, {
+			kind: "number",
+			value: -1
+		}]
+	};
+}
+function canon(node) {
+	switch (node.kind) {
+		case "number":
+		case "symbol": return node;
+		case "call": return {
+			kind: "call",
+			fn: assertCallFn(node.fn),
+			arg: canon(node.arg)
+		};
+		case "op": {
+			const op = node.op;
+			const args = node.args;
+			if (op === "+") {
+				if (args.length === 0) return {
+					kind: "number",
+					value: 0
+				};
+				if (args.length === 1) return canon(args[0]);
+				return fromSum(args.map((a) => canon(a)));
+			}
+			if (op === "-") {
+				if (args.length === 0) return {
+					kind: "number",
+					value: 0
+				};
+				if (args.length === 1) return canon(args[0]);
+				const parts = [canon(args[0])];
+				for (let i = 1; i < args.length; i++) parts.push(canonProductByNumber(canon(args[i]), -1));
+				return fromSum(parts);
+			}
+			if (op === "*") {
+				if (args.length === 0) return {
+					kind: "number",
+					value: 1
+				};
+				if (args.length === 1) return canon(args[0]);
+				const factors = [];
+				for (const a of args) factors.push(...collectFactors(canon(a)));
+				return fromProduct(factors);
+			}
+			if (op === "/") {
+				if (args.length === 0) return {
+					kind: "number",
+					value: 1
+				};
+				if (args.length === 1) return canon(args[0]);
+				let factors = collectFactors(canon(args[0]));
+				for (let i = 1; i < args.length; i++) factors = factors.concat(collectFactors(inversePower(canon(args[i]))));
+				return fromProduct(factors);
+			}
+			if (op === "^") {
+				assertPowerArity(args);
+				const base = canon(args[0]);
+				const expCanon = canon(args[1]);
+				if (expCanon.kind === "number" && Number.isFinite(expCanon.value)) return fromProduct(collectFactors(base).map((f) => ({
+					base: f.base,
+					exp: f.exp * expCanon.value
+				})));
+				return {
+					kind: "op",
+					op: "^",
+					args: [base, expCanon]
+				};
+			}
+			throw new ScalarBuildError(`unknown scalar operator '${String(op)}'`);
+		}
+	}
+}
+function scalarCanonical(node) {
+	return canon(node);
+}
+function scalarCanonicalKey(node) {
+	return encodeCanonicalKey(scalarCanonical(node));
+}
+function scalarEquals(a, b) {
+	return scalarCanonicalKey(a) === scalarCanonicalKey(b);
+}
+//#endregion
+//#region src/scalar-enumerate.ts
+function nodeOperatorName(node) {
+	if (node.kind === "op") return node.op;
+	if (node.kind === "call") return node.fn;
+	return null;
+}
+function countNamedInSubtree(root, inner) {
+	let count = 0;
+	function walk(n, isRoot) {
+		if (!isRoot && nodeOperatorName(n) === inner) count += 1;
+		if (n.kind === "call") walk(n.arg, false);
+		else if (n.kind === "op") for (const child of n.args) walk(child, false);
+	}
+	walk(root, true);
+	return count;
+}
+function argumentLimitsOk(node, argumentLimits) {
+	const name = nodeOperatorName(node);
+	if (name === null || !hasOwnProperty(argumentLimits, name)) return true;
+	const limits = argumentLimits[name];
+	if (node.kind === "call") {
+		const cap = limits[0];
+		if (cap !== void 0 && cap !== -1 && scalarSize(node.arg) > cap) return false;
+		return true;
+	}
+	if (node.kind === "op") for (let i = 0; i < node.args.length; i += 1) {
+		const cap = limits[i];
+		if (cap !== void 0 && cap !== -1 && scalarSize(node.args[i]) > cap) return false;
+	}
+	return true;
+}
+function nestingOk(node, nesting) {
+	let ok = true;
+	forEachScalar(node, (sub) => {
+		const outer = nodeOperatorName(sub);
+		if (outer === null || !hasOwnProperty(nesting, outer)) return;
+		const innerLimits = nesting[outer];
+		for (const inner of Object.keys(innerLimits)) {
+			if (!hasOwnProperty(innerLimits, inner)) continue;
+			const max = innerLimits[inner];
+			if (countNamedInSubtree(sub, inner) > max) ok = false;
+		}
+	});
+	return ok;
+}
+function symbolAllowed(grammar, name) {
+	if (grammar.variables.includes(name)) return true;
+	const params = grammar.parameters;
+	return params !== void 0 && params.includes(name);
+}
+function nodeStructureOk(grammar, node) {
+	switch (node.kind) {
+		case "number": return Number.isFinite(node.value);
+		case "symbol": return symbolAllowed(grammar, node.name);
+		case "call":
+			if (!grammar.unary.includes(node.fn)) return false;
+			return nodeStructureOk(grammar, node.arg);
+		case "op":
+			if (!grammar.binary.includes(node.op)) return false;
+			if (node.args.length !== 2) return false;
+			return nodeStructureOk(grammar, node.args[0]) && nodeStructureOk(grammar, node.args[1]);
+	}
+}
+function scalarGrammarAccepts(grammar, node) {
+	if (!nodeStructureOk(grammar, node)) return false;
+	if (!(scalarSize(node) <= grammar.maxSize)) return false;
+	const maxDepth = grammar.maxDepth;
+	if (maxDepth !== void 0 && !(scalarDepth(node) <= maxDepth)) return false;
+	if (grammar.argumentLimits !== void 0) {
+		let limitsOk = true;
+		forEachScalar(node, (sub) => {
+			if (!argumentLimitsOk(sub, grammar.argumentLimits)) limitsOk = false;
+		});
+		if (!limitsOk) return false;
+	}
+	if (grammar.nesting !== void 0 && !nestingOk(node, grammar.nesting)) return false;
+	return true;
+}
+const INTERRUPT_CHECK_INTERVAL = 128;
+function assertEnumerationInputs(grammar, budget) {
+	if (Number.isNaN(grammar.maxSize)) throw new RangeError("enumerateScalars: grammar.maxSize must not be NaN");
+	if (grammar.maxDepth !== void 0 && Number.isNaN(grammar.maxDepth)) throw new RangeError("enumerateScalars: grammar.maxDepth must not be NaN");
+	if (Number.isNaN(budget.maxCandidates) || budget.maxCandidates < 0) throw new RangeError("enumerateScalars: budget.maxCandidates must be a number >= 0");
+	if (budget.maxWallClockMs !== void 0 && Number.isNaN(budget.maxWallClockMs)) throw new RangeError("enumerateScalars: budget.maxWallClockMs must not be NaN");
+}
+function* enumerateScalars(grammar, budget, signal) {
+	assertEnumerationInputs(grammar, budget);
+	const b = createScalarBuilder();
+	const yieldedKeys = /* @__PURE__ */ new Set();
+	const pooledKeys = /* @__PURE__ */ new Set();
+	const pool = [];
+	const bySize = [];
+	let yieldCount = 0;
+	let sinceCheck = 0;
+	const start = performance.now();
+	const admitMonotone = grammar.admitMonotone === true;
+	const interrupted = () => {
+		if (signal?.aborted) return "cancelled";
+		if (budget.maxWallClockMs !== void 0 && performance.now() - start >= budget.maxWallClockMs) return "time-limit";
+		return null;
+	};
+	const addToPool = (node, size, key) => {
+		if (pooledKeys.has(key)) return;
+		pooledKeys.add(key);
+		const entry = {
+			node,
+			size
+		};
+		pool.push(entry);
+		(bySize[size] ??= []).push(entry);
+	};
+	const consider = function* (node, size) {
+		sinceCheck += 1;
+		if (sinceCheck >= INTERRUPT_CHECK_INTERVAL) {
+			sinceCheck = 0;
+			const stop = interrupted();
+			if (stop !== null) return stop;
+		}
+		if (!scalarGrammarAccepts(grammar, node)) return "ok";
+		const key = scalarCanonicalKey(node);
+		if (yieldedKeys.has(key)) return "ok";
+		if (!(grammar.admit === void 0 || grammar.admit(node))) {
+			if (!admitMonotone) addToPool(node, size, key);
+			return "ok";
+		}
+		const stop = interrupted() ?? (yieldCount >= budget.maxCandidates ? "candidate-limit" : null);
+		if (stop !== null) return stop;
+		sinceCheck = 0;
+		addToPool(node, size, key);
+		yieldedKeys.add(key);
+		yieldCount += 1;
+		yield node;
+		return "ok";
+	};
+	for (let size = 1; size <= grammar.maxSize; size += 1) {
+		if (size === 1) {
+			const leaves = [];
+			for (const name of grammar.variables) leaves.push(b.symbol(name));
+			for (const name of grammar.parameters ?? []) leaves.push(b.symbol(name));
+			for (const value of grammar.literals ?? []) leaves.push(b.number(value));
+			for (const leaf of leaves) {
+				const stop = yield* consider(leaf, 1);
+				if (stop !== "ok") return stop;
+			}
+			continue;
+		}
+		const poolAtStart = pool.length;
+		for (const op of grammar.binary) for (let i = 0; i < poolAtStart; i += 1) {
+			const left = pool[i];
+			const rightSize = size - 1 - left.size;
+			if (rightSize < 1) continue;
+			for (const right of bySize[rightSize] ?? []) {
+				const stop = yield* consider(b.op(op, [left.node, right.node]), size);
+				if (stop !== "ok") return stop;
+			}
+		}
+		for (const fn of grammar.unary) for (const arg of bySize[size - 1] ?? []) {
+			const stop = yield* consider({
+				kind: "call",
+				fn,
+				arg: arg.node
+			}, size);
+			if (stop !== "ok") return stop;
+		}
+	}
+	return "exhausted-space";
+}
+//#endregion
+//#region src/transform/utils/shortCircuitBinary.ts
+function evalShortCircuitBinary(args, scope, op, absorb) {
+	const left = args[0].compile().evaluate(scope);
+	if (!isCollection(left)) {
+		const early = absorb(left);
+		if (early.take) return early.value;
+	}
+	return op(left, args[1].compile().evaluate(scope));
+}
 const createAndTransform = /* #__PURE__ */ factory("and", ["and"], ({ and }) => {
 	function andTransform(args, _math, scope) {
-		const condition1 = args[0].compile().evaluate(scope);
-		if (!isCollection(condition1) && !and(condition1, true)) return false;
-		return and(condition1, args[1].compile().evaluate(scope));
+		return evalShortCircuitBinary(args, scope, and, (left) => !and(left, true) ? {
+			take: true,
+			value: false
+		} : { take: false });
 	}
 	andTransform.rawArgs = true;
 	return andTransform;
 }, { isTransformFunction: true });
 const createBitAndTransform = /* #__PURE__ */ factory("bitAnd", ["bitAnd"], ({ bitAnd }) => {
 	function bitAndTransform(args, _math, scope) {
-		const condition1 = args[0].compile().evaluate(scope);
-		if (!isCollection(condition1)) {
-			if (isNaN(condition1)) return NaN;
-			if (condition1 === 0 || condition1 === false) return 0;
-		}
-		return bitAnd(condition1, args[1].compile().evaluate(scope));
+		return evalShortCircuitBinary(args, scope, bitAnd, (left) => {
+			if (isNaN(left)) return {
+				take: true,
+				value: NaN
+			};
+			if (left === 0 || left === false) return {
+				take: true,
+				value: 0
+			};
+			return { take: false };
+		});
 	}
 	bitAndTransform.rawArgs = true;
 	return bitAndTransform;
 }, { isTransformFunction: true });
 const createBitOrTransform = /* #__PURE__ */ factory("bitOr", ["bitOr"], ({ bitOr }) => {
 	function bitOrTransform(args, _math, scope) {
-		const condition1 = args[0].compile().evaluate(scope);
-		if (!isCollection(condition1)) {
-			if (isNaN(condition1)) return NaN;
-			if (condition1 === -1) return -1;
-			if (condition1 === true) return 1;
-		}
-		return bitOr(condition1, args[1].compile().evaluate(scope));
+		return evalShortCircuitBinary(args, scope, bitOr, (left) => {
+			if (isNaN(left)) return {
+				take: true,
+				value: NaN
+			};
+			if (left === -1) return {
+				take: true,
+				value: -1
+			};
+			if (left === true) return {
+				take: true,
+				value: 1
+			};
+			return { take: false };
+		});
 	}
 	bitOrTransform.rawArgs = true;
 	return bitOrTransform;
@@ -10374,28 +10936,15 @@ const createConcatTransform = /* #__PURE__ */ factory("concat", ["typed", "conca
 	} });
 }, { isTransformFunction: true });
 //#endregion
-//#region src/transform/cumsum.transform.ts
-const name$20 = "cumsum";
-const createCumSumTransform = /* #__PURE__ */ factory(name$20, ["typed", "cumsum"], ({ typed, cumsum }) => {
-	return typed(name$20, { "...any": function(args) {
-		if (args.length === 2 && isCollection(args[0])) {
-			const dim = args[1];
-			if (isNumber(dim)) args[1] = dim - 1;
-			else if (isBigNumber(dim)) args[1] = dim.minus(1);
-		}
-		try {
-			return cumsum(...args);
-		} catch (err) {
-			throw errorTransform(err);
-		}
-	} });
-}, { isTransformFunction: true });
-//#endregion
 //#region src/transform/utils/dimToZeroBase.ts
 function dimToZeroBase(dim) {
 	if (isNumber(dim)) return dim - 1;
-	else if (isBigNumber(dim)) return dim.minus(1);
-	else return dim;
+	else if (isBigNumber(dim)) {
+		const bn = dim;
+		if (typeof bn.sub === "function") return bn.sub(1);
+		if (typeof bn.minus === "function") return bn.minus(1);
+		return dim;
+	} else return dim;
 }
 function isNumberOrBigNumber(n) {
 	return isNumber(n) || isBigNumber(n);
@@ -10411,6 +10960,19 @@ function lastDimToZeroBase(args) {
 	return args;
 }
 //#endregion
+//#region src/transform/cumsum.transform.ts
+const name$20 = "cumsum";
+const createCumSumTransform = /* #__PURE__ */ factory(name$20, ["typed", "cumsum"], ({ typed, cumsum }) => {
+	return typed(name$20, { "...any": function(args) {
+		args = lastDimToZeroBase(args);
+		try {
+			return cumsum(...args);
+		} catch (err) {
+			throw errorTransform(err);
+		}
+	} });
+}, { isTransformFunction: true });
+//#endregion
 //#region src/transform/diff.transform.ts
 const name$19 = "diff";
 const createDiffTransform = /* #__PURE__ */ factory(name$19, ["typed", "diff"], ({ typed, diff }) => {
@@ -10440,6 +11002,33 @@ function compileInlineExpression(expression, math, scope) {
 		return eq.evaluate(subScope);
 	};
 }
+//#endregion
+//#region src/transform/utils/prepareTransformArgs.ts
+function compileAndEvaluate(arg, scope) {
+	return arg.compile().evaluate(scope);
+}
+function prepareTransformArrayAndCallback(args, math, scope) {
+	const callbackArity = args.length - 1;
+	let x = args[0];
+	let callback = args[callbackArity];
+	if (x) x = compileAndEvaluate(x, scope);
+	if (callback) {
+		if (isSymbolNode(callback) || isFunctionAssignmentNode(callback)) callback = compileAndEvaluate(callback, scope);
+		else callback = compileInlineExpression(callback, math, scope);
+	}
+	return {
+		x,
+		callback,
+		callbackArity
+	};
+}
+function applyArrayCallbackTransform(args, math, scope, op, transformCallback) {
+	if (args.length === 0) return op();
+	const x = args[0];
+	if (args.length === 1) return op(x);
+	const prepared = prepareTransformArrayAndCallback(args, math, scope);
+	return op(prepared.x, transformCallback(prepared.callback, prepared.callbackArity));
+}
 const createTransformCallback = /* #__PURE__ */ factory("transformCallback", ["typed"], ({ typed }) => {
 	return function(callback, numberOfArrays) {
 		if (typed.isTypedFunction(callback)) return _transformTypedCallbackFunction(callback, numberOfArrays);
@@ -10479,45 +11068,19 @@ function _transformDims(dims) {
 	return dims.map((dim) => dim + 1);
 }
 const createFilterTransform = /* #__PURE__ */ factory("filter", ["typed", "filter"], ({ typed, filter }) => {
+	const transformCallback = createTransformCallback({ typed });
 	function filterTransform(args, math, scope) {
-		const transformCallback = createTransformCallback({ typed });
-		if (args.length === 0) return filter();
-		let x = args[0];
-		if (args.length === 1) return filter(x);
-		const N = args.length - 1;
-		let callback = args[N];
-		if (x) x = _compileAndEvaluate(x, scope);
-		if (callback) {
-			if (isSymbolNode(callback) || isFunctionAssignmentNode(callback)) callback = _compileAndEvaluate(callback, scope);
-			else callback = compileInlineExpression(callback, math, scope);
-		}
-		return filter(x, transformCallback(callback, N));
+		return applyArrayCallbackTransform(args, math, scope, filter, transformCallback);
 	}
 	filterTransform.rawArgs = true;
-	function _compileAndEvaluate(arg, scope) {
-		return arg.compile().evaluate(scope);
-	}
 	return filterTransform;
 }, { isTransformFunction: true });
 const createForEachTransform = /* #__PURE__ */ factory("forEach", ["typed", "forEach"], ({ typed, forEach }) => {
 	const transformCallback = createTransformCallback({ typed });
 	function forEachTransform(args, math, scope) {
-		if (args.length === 0) return forEach();
-		let x = args[0];
-		if (args.length === 1) return forEach(x);
-		const N = args.length - 1;
-		let callback = args[N];
-		if (x) x = _compileAndEvaluate(x, scope);
-		if (callback) {
-			if (isSymbolNode(callback) || isFunctionAssignmentNode(callback)) callback = _compileAndEvaluate(callback, scope);
-			else callback = compileInlineExpression(callback, math, scope);
-		}
-		return forEach(x, transformCallback(callback, N));
+		return applyArrayCallbackTransform(args, math, scope, forEach, transformCallback);
 	}
 	forEachTransform.rawArgs = true;
-	function _compileAndEvaluate(arg, scope) {
-		return arg.compile().evaluate(scope);
-	}
 	return forEachTransform;
 }, { isTransformFunction: true });
 const createIndexTransform = /* #__PURE__ */ factory("index", ["Index", "getMatrixDataType"], ({ Index, getMatrixDataType }) => {
@@ -10567,8 +11130,7 @@ const createMapTransform = /* #__PURE__ */ factory("map", ["typed", "map"], ({ t
 const createMapSlicesTransform = /* #__PURE__ */ factory("mapSlices", ["typed", "mapSlices"], ({ typed, mapSlices }) => {
 	return typed("mapSlices", { "...any": function(args) {
 		const dim = args[1];
-		if (isNumber(dim)) args[1] = dim - 1;
-		else if (isBigNumber(dim)) args[1] = dim.minus(1);
+		if (isNumberOrBigNumber(dim)) args[1] = dimToZeroBase(dim);
 		try {
 			return mapSlices(...args);
 		} catch (err) {
@@ -10617,9 +11179,10 @@ const createNullishTransform = /* #__PURE__ */ factory("nullish", ["nullish"], (
 }, { isTransformFunction: true });
 const createOrTransform = /* #__PURE__ */ factory("or", ["or"], ({ or }) => {
 	function orTransform(args, _math, scope) {
-		const condition1 = args[0].compile().evaluate(scope);
-		if (!isCollection(condition1) && or(condition1, false)) return true;
-		return or(condition1, args[1].compile().evaluate(scope));
+		return evalShortCircuitBinary(args, scope, or, (left) => or(left, false) ? {
+			take: true,
+			value: true
+		} : { take: false });
 	}
 	orTransform.rawArgs = true;
 	return orTransform;
@@ -10727,4 +11290,4 @@ const createVarianceTransform = /* #__PURE__ */ factory(name, ["typed", "varianc
 	} });
 }, { isTransformFunction: true });
 //#endregion
-export { SCALAR_FUNCTIONS, SCALAR_FUNCTION_LOWERING, ScalarBuildError, compile, compileExpression, createAccessorNode, createAndTransform, createArrayNode, createAssignmentNode, createBitAndTransform, createBitOrTransform, createBlockNode, createColumnTransform, createConcatTransform, createConditionalNode, createConstantNode, createCumSumTransform, createDiffTransform, createEvaluate, createFilterTransform, createForEachTransform, createFunctionAssignmentNode, createFunctionNode, createHelpClass, createIndexNode, createIndexTransform, createMapSlicesTransform, createMapTransform, createMaxTransform, createMeanTransform, createMinTransform, createNode, createNullishTransform, createObjectNode, createOperatorNode, createOrTransform, createParenthesisNode, createParse, createParser, createParserClass, createPrintTransform, createQuantileSeqTransform, createRangeNode, createRangeTransform, createRelationalNode, createRowTransform, createScalarBuilder, createStdTransform, createSubsetTransform, createSumTransform, createSymbolNode, createVarianceTransform, embeddedDocs, escapeMathML, getAssociativity, getOperator, getPrecedence, isAssociativeWith, keywords, mathMLDocument, mathMLError, properties, toMathMLSymbol };
+export { SCALAR_FUNCTIONS, SCALAR_FUNCTION_LOWERING, ScalarBuildError, compile, compileExpression, createAccessorNode, createAndTransform, createArrayNode, createAssignmentNode, createBitAndTransform, createBitOrTransform, createBlockNode, createColumnTransform, createConcatTransform, createConditionalNode, createConstantNode, createCumSumTransform, createDiffTransform, createEvaluate, createFilterTransform, createForEachTransform, createFunctionAssignmentNode, createFunctionNode, createHelpClass, createIndexNode, createIndexTransform, createMapSlicesTransform, createMapTransform, createMaxTransform, createMeanTransform, createMinTransform, createNode, createNullishTransform, createObjectNode, createOperatorNode, createOrTransform, createParenthesisNode, createParse, createParser, createParserClass, createPrintTransform, createQuantileSeqTransform, createRangeNode, createRangeTransform, createRelationalNode, createRowTransform, createScalarBuilder, createStdTransform, createSubsetTransform, createSumTransform, createSymbolNode, createVarianceTransform, embeddedDocs, enumerateScalars, escapeMathML, forEachScalar, getAssociativity, getOperator, getPrecedence, getStringSubset, isAssociativeWith, keywords, mapScalar, mathMLDocument, mathMLError, properties, scalarCanonical, scalarCanonicalKey, scalarComplexity, scalarDepth, scalarEquals, scalarGrammarAccepts, scalarSize, scalarSymbols, setStringSubset, toMathMLSymbol };