@danielsimonjr/mathts-expression 0.11.1 → 0.12.0

package/dist/evaluator/evaluate.d.ts

@@ -35,7 +35,16 @@ export interface EvaluateOptions {
  * evaluate('x^2', { x: 3 }); // 9
  * ```
  */
-export declare function createEvaluate(parseFn: (expr: string) => MathNode, mathScope: Record<string, unknown>): {
+export declare function createEvaluate(parseFn: (expr: string) => MathNode, mathScope: Record<string, unknown>, 
+/**
+ * Optional fingerprint of the state `parseFn` depends on besides the text
+ * (for example the live `number` / `precision` config, which decides the
+ * numeric type of literals at parse time). Called on every evaluate; its
+ * value becomes part of the cache key, so a parse made under one config is
+ * never reused under another. Omit when `parseFn` is a pure function of its
+ * input.
+ */
+cacheKey?: () => string): {
     (expr: string, scope?: Record<string, unknown> | Scope, options?: EvaluateOptions): unknown;
     (exprs: string[], scope?: Record<string, unknown> | Scope, options?: EvaluateOptions): unknown[];
 };

package/dist/evaluator/evaluate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"evaluate.d.ts","sourceRoot":"","sources":["../../src/evaluator/evaluate.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAuHD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ,EACnC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;WAW1B,MAAM,UACJ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,YAC7B,eAAe,GACxB,OAAO;YAUD,MAAM,EAAE,UACP,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,YAC7B,eAAe,GACxB,OAAO,EAAE;EA0Bb;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ,EACnC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,eAAe,GACxB,kBAAkB,CAMpB"}
+{"version":3,"file":"evaluate.d.ts","sourceRoot":"","sources":["../../src/evaluator/evaluate.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AACxE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAmJD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ,EACnC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;AAClC;;;;;;;GAOG;AACH,QAAQ,CAAC,EAAE,MAAM,MAAM;WAWf,MAAM,UACJ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,YAC7B,eAAe,GACxB,OAAO;YAUD,MAAM,EAAE,UACP,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,YAC7B,eAAe,GACxB,OAAO,EAAE;EA2Cb;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ,EACnC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,eAAe,GACxB,kBAAkB,CAMpB"}

package/dist/index.js

@@ -470,7 +470,7 @@ const MAX_EXPRESSION_LENGTH = 1e6;
 //#endregion
 //#region src/parse.ts
 const name$45 = "parse";
-const createParse = /* #__PURE__ */ factory(name$45, [
+const dependencies$45 = [
 	"typed",
 	"numeric",
 	"config",
@@ -489,7 +489,47 @@ const createParse = /* #__PURE__ */ factory(name$45, [
 	"RangeNode",
 	"RelationalNode",
 	"SymbolNode"
-], ({ typed, numeric, config, AccessorNode, ArrayNode, AssignmentNode, BlockNode, ConditionalNode, ConstantNode, FunctionAssignmentNode, FunctionNode, IndexNode, ObjectNode, OperatorNode, ParenthesisNode, RangeNode, RelationalNode, SymbolNode }) => {
+];
+const RELATIONAL_OPERATORS = Object.freeze({
+	"==": "equal",
+	"!=": "unequal",
+	"<": "smaller",
+	">": "larger",
+	"<=": "smallerEq",
+	">=": "largerEq"
+});
+const SHIFT_OPERATORS = Object.freeze({
+	"<<": "leftShift",
+	">>": "rightArithShift",
+	">>>": "rightLogShift"
+});
+const CONVERSION_OPERATORS = Object.freeze({
+	to: "to",
+	in: "to"
+});
+const ADD_SUBTRACT_OPERATORS = Object.freeze({
+	"+": "add",
+	"-": "subtract"
+});
+const MULTIPLY_DIVIDE_OPERATORS = Object.freeze({
+	"*": "multiply",
+	".*": "dotMultiply",
+	"/": "divide",
+	"./": "dotDivide",
+	"%": "mod",
+	mod: "mod"
+});
+const UNARY_OPERATORS = Object.freeze({
+	"-": "unaryMinus",
+	"+": "unaryPlus",
+	"~": "bitNot",
+	not: "not"
+});
+const POSTFIX_OPERATORS = Object.freeze({
+	"!": "factorial",
+	"'": "ctranspose"
+});
+const createParse = /* #__PURE__ */ factory(name$45, dependencies$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`);
@@ -931,18 +971,10 @@ const createParse = /* #__PURE__ */ factory(name$45, [
 	function parseRelational(state) {
 		const params = [parseShift(state)];
 		const conditionals = [];
-		const operators = {
-			"==": "equal",
-			"!=": "unequal",
-			"<": "smaller",
-			">": "larger",
-			"<=": "smallerEq",
-			">=": "largerEq"
-		};
-		while (hasOwnProperty(operators, state.token)) {
+		while (hasOwnProperty(RELATIONAL_OPERATORS, state.token)) {
 			const cond = {
 				name: state.token,
-				fn: operators[state.token]
+				fn: RELATIONAL_OPERATORS[state.token]
 			};
 			conditionals.push(cond);
 			getTokenSkipNewline(state);
@@ -958,14 +990,9 @@ const createParse = /* #__PURE__ */ factory(name$45, [
 		let fn;
 		let params;
 		node = parseConversion(state);
-		const operators = {
-			"<<": "leftShift",
-			">>": "rightArithShift",
-			">>>": "rightLogShift"
-		};
-		while (hasOwnProperty(operators, state.token)) {
+		while (hasOwnProperty(SHIFT_OPERATORS, state.token)) {
 			name = state.token;
-			fn = operators[name];
+			fn = SHIFT_OPERATORS[name];
 			getTokenSkipNewline(state);
 			params = [node, parseConversion(state)];
 			node = new OperatorNode(name, fn, params);
@@ -978,13 +1005,9 @@ const createParse = /* #__PURE__ */ factory(name$45, [
 		let fn;
 		let params;
 		node = parseRange(state);
-		const operators = {
-			to: "to",
-			in: "to"
-		};
-		while (hasOwnProperty(operators, state.token)) {
+		while (hasOwnProperty(CONVERSION_OPERATORS, state.token)) {
 			name = state.token;
-			fn = operators[name];
+			fn = CONVERSION_OPERATORS[name];
 			getTokenSkipNewline(state);
 			if (name === "in" && "])},;".includes(state.token)) node = new OperatorNode("*", "multiply", [node, new SymbolNode("in")], true);
 			else {
@@ -1019,13 +1042,9 @@ const createParse = /* #__PURE__ */ factory(name$45, [
 		let fn;
 		let params;
 		node = parseMultiplyDivideModulus(state);
-		const operators = {
-			"+": "add",
-			"-": "subtract"
-		};
-		while (hasOwnProperty(operators, state.token)) {
+		while (hasOwnProperty(ADD_SUBTRACT_OPERATORS, state.token)) {
 			name = state.token;
-			fn = operators[name];
+			fn = ADD_SUBTRACT_OPERATORS[name];
 			getTokenSkipNewline(state);
 			const rightNode = parseMultiplyDivideModulus(state);
 			if (rightNode.isPercentage) params = [node, new OperatorNode("*", "multiply", [node, rightNode])];
@@ -1040,17 +1059,9 @@ const createParse = /* #__PURE__ */ factory(name$45, [
 		let name;
 		let fn;
 		node = parseImplicitMultiplication(state);
-		const operators = {
-			"*": "multiply",
-			".*": "dotMultiply",
-			"/": "divide",
-			"./": "dotDivide",
-			"%": "mod",
-			mod: "mod"
-		};
-		while (true) if (hasOwnProperty(operators, state.token)) {
+		while (true) if (hasOwnProperty(MULTIPLY_DIVIDE_OPERATORS, state.token)) {
 			name = state.token;
-			fn = operators[name];
+			fn = MULTIPLY_DIVIDE_OPERATORS[name];
 			getTokenSkipNewline(state);
 			last = parseImplicitMultiplication(state);
 			node = new OperatorNode(name, fn, [node, last]);
@@ -1121,14 +1132,8 @@ const createParse = /* #__PURE__ */ factory(name$45, [
 		let name;
 		let params;
 		let fn;
-		const operators = {
-			"-": "unaryMinus",
-			"+": "unaryPlus",
-			"~": "bitNot",
-			not: "not"
-		};
-		if (hasOwnProperty(operators, state.token)) {
-			fn = operators[state.token];
+		if (hasOwnProperty(UNARY_OPERATORS, state.token)) {
+			fn = UNARY_OPERATORS[state.token];
 			name = state.token;
 			getTokenSkipNewline(state);
 			params = [parseUnary(state)];
@@ -1165,13 +1170,9 @@ const createParse = /* #__PURE__ */ factory(name$45, [
 		let fn;
 		let params;
 		node = parseCustomNodes(state);
-		const operators = {
-			"!": "factorial",
-			"'": "ctranspose"
-		};
-		while (hasOwnProperty(operators, state.token)) {
+		while (hasOwnProperty(POSTFIX_OPERATORS, state.token)) {
 			name = state.token;
-			fn = operators[name];
+			fn = POSTFIX_OPERATORS[name];
 			getToken(state);
 			params = [node];
 			node = new OperatorNode(name, fn, params);
@@ -7564,15 +7565,45 @@ function validateAst(node, depth = 0) {
 		for (const k of Object.keys(properties)) validateAst(properties[k], depth + 1);
 	}
 }
-function createEvaluate(parseFn, mathScope) {
+const COMPILE_CACHE_SIZE = 256;
+const compileCaches = /* @__PURE__ */ new WeakMap();
+function cacheFor(mathScope, parseFn) {
+	let byParser = compileCaches.get(mathScope);
+	if (!byParser) {
+		byParser = /* @__PURE__ */ new WeakMap();
+		compileCaches.set(mathScope, byParser);
+	}
+	let cache = byParser.get(parseFn);
+	if (!cache) {
+		cache = /* @__PURE__ */ new Map();
+		byParser.set(parseFn, cache);
+	}
+	return cache;
+}
+function createEvaluate(parseFn, mathScope, cacheKey) {
 	function evaluate(exprOrExprs, scope, options) {
 		if (Array.isArray(exprOrExprs)) return exprOrExprs.map((expr) => evaluateOne(expr, scope, options));
 		return evaluateOne(exprOrExprs, scope, options);
 	}
+	const cache = cacheFor(mathScope, parseFn);
 	function evaluateOne(expr, scope, options) {
-		const node = parseFn(expr);
-		if (!options || options.unsafe !== true) validateAst(node);
-		return compile(node, mathScope).evaluate(scope);
+		const unsafe = options?.unsafe === true;
+		const key = (unsafe ? "u:" : "s:") + (cacheKey ? cacheKey() + "\0" : "") + expr;
+		let compiled = cache.get(key);
+		if (compiled !== void 0) {
+			cache.delete(key);
+			cache.set(key, compiled);
+		} else {
+			const node = parseFn(expr);
+			if (!unsafe) validateAst(node);
+			compiled = compile(node, mathScope);
+			cache.set(key, compiled);
+			if (cache.size > COMPILE_CACHE_SIZE) {
+				const oldest = cache.keys().next().value;
+				if (oldest !== void 0) cache.delete(oldest);
+			}
+		}
+		return compiled.evaluate(scope);
 	}
 	return evaluate;
 }
@@ -7878,6 +7909,17 @@ function errorTransform(err) {
 	return err;
 }
 //#endregion
+//#region src/node/utils/describeType.ts
+function describeType(value) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "array";
+	if (typeof value === "object") {
+		const name = value.constructor?.name;
+		return typeof name === "string" && name !== "" ? name : "object";
+	}
+	return typeof value;
+}
+//#endregion
 //#region src/node/utils/stringSubset.ts
 function getStringSubset(str, index, invalidIndexMessage = "Index expected") {
 	if (!isIndex(index)) throw new TypeError(invalidIndexMessage);
@@ -7931,9 +7973,9 @@ function accessFactory({ subset }) {
 			else if (object && typeof object.subset === "function") return object.subset(index);
 			else if (typeof object === "string") return getStringSubset(object, index);
 			else if (typeof object === "object") {
-				if (!index.isObjectProperty()) throw new TypeError("Cannot apply a numeric index as object property");
+				if (!index.isObjectProperty()) throw new TypeError(`Cannot apply a numeric index as object property (object is ${describeType(object)})`);
 				return getSafeProperty(object, index.getObjectProperty());
-			} else throw new TypeError("Cannot apply index: unsupported type of object");
+			} else throw new TypeError(`Cannot apply index: unsupported type of object (got ${describeType(object)})`);
 		} catch (err) {
 			throw errorTransform(err);
 		}
@@ -8025,6 +8067,12 @@ const createAccessorNode = /* #__PURE__ */ factory(name$40, ["subset", "Node"],
 			if (needParenthesis(this.object)) object = "\\left(' + object + '\\right)";
 			return object + this.index.toTex(options);
 		}
+		_toMathML() {
+			let object = this.object.toMathML();
+			if (needParenthesis(this.object)) object = `<mrow><mo>(</mo>${object}<mo>)</mo></mrow>`;
+			if (this.index.dotNotation) return `<mrow>${object}${this.index.toMathML()}</mrow>`;
+			return `<msub><mrow>${object}</mrow>${this.index.toMathML()}</msub>`;
+		}
 		toJSON() {
 			return {
 				mathjs: name$40,
@@ -8109,6 +8157,26 @@ const createArrayNode = /* #__PURE__ */ factory(name$39, ["Node"], ({ Node }) =>
 				return node.toHTML(options);
 			}).join("<span class=\"math-separator\">,</span>") + "<span class=\"math-parenthesis math-square-parenthesis\">]</span>";
 		}
+		_toMathML() {
+			const tableOf = (rows) => "<mrow><mo>[</mo><mtable>" + rows.map((row) => "<mtr>" + row.map((cell) => `<mtd>${cell}</mtd>`).join("") + "</mtr>").join("") + "</mtable><mo>]</mo></mrow>";
+			const build = (items, nested) => {
+				const mixedItems = items.some(isArrayNode) && !items.every(isArrayNode);
+				const itemsFormRow = nested || mixedItems;
+				const pieces = items.map((node) => {
+					const arrayItems = node.items;
+					if (arrayItems) {
+						const sub = build(arrayItems, !nested);
+						return sub.wrapped ? [tableOf(sub.rows)] : sub.rows[0];
+					}
+					return [node.toMathML()];
+				});
+				return {
+					wrapped: mixedItems || !itemsFormRow || itemsFormRow && !nested,
+					rows: itemsFormRow ? [pieces.flat()] : pieces
+				};
+			};
+			return tableOf(build(this.items, false).rows);
+		}
 		_toTex(options) {
 			function itemsToTex(items, nested) {
 				const mixedItems = items.some(isArrayNode) && !items.every(isArrayNode);
@@ -8142,10 +8210,10 @@ function assignFactory({ subset }) {
 			} else if (object && typeof object.subset === "function") return object.subset(index, value);
 			else if (typeof object === "string") return setStringSubset(object, index, String(value));
 			else if (typeof object === "object") {
-				if (!index.isObjectProperty()) throw TypeError("Cannot apply a numeric index as object property");
+				if (!index.isObjectProperty()) throw TypeError(`Cannot apply a numeric index as object property (object is ${describeType(object)})`);
 				setSafeProperty(object, index.getObjectProperty(), value);
 				return object;
-			} else throw new TypeError("Cannot apply index: unsupported type of object");
+			} else throw new TypeError(`Cannot apply index: unsupported type of object (got ${describeType(object)})`);
 		} catch (err) {
 			throw errorTransform(err);
 		}
@@ -8392,6 +8460,9 @@ const createBlockNode = /* #__PURE__ */ factory(name$37, ["ResultSet", "Node"],
 				return param.node.toHTML(options) + (param.visible ? "" : "<span class=\"math-separator\">;</span>");
 			}).join("<span class=\"math-separator\"><br /></span>");
 		}
+		_toMathML() {
+			return `<mrow>${this.blocks.map((param) => param.node.toMathML() + (param.visible ? "" : "<mo>;</mo>")).join("<mspace width=\"1em\"/>")}</mrow>`;
+		}
 		_toTex(options) {
 			return this.blocks.map(function(param) {
 				return param.node.toTex(options) + (param.visible ? "" : ";");
@@ -8486,6 +8557,9 @@ const createConditionalNode = /* #__PURE__ */ factory(name$36, ["Node"], ({ Node
 			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);
 		}
+		_toMathML() {
+			return `<mrow><mo>{</mo><mtable columnalign="left left"><mtr><mtd>${this.trueExpr.toMathML()}</mtd><mtd><mtext>if </mtext>${this.condition.toMathML()}</mtd></mtr><mtr><mtd>${this.falseExpr.toMathML()}</mtd><mtd><mtext>otherwise</mtext></mtd></mtr></mtable></mrow>`;
+		}
 		_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}";
 		}
@@ -9011,6 +9085,12 @@ const createFunctionAssignmentNode = /* #__PURE__ */ factory(name$34, ["typed",
 			if (needParenthesis(this, parenthesis, options && options.implicit)) expr = "<span class=\"math-parenthesis math-round-parenthesis\">(</span>" + expr + "<span class=\"math-parenthesis math-round-parenthesis\">)</span>";
 			return "<span class=\"math-function\">" + escape(this.name) + "</span><span class=\"math-parenthesis math-round-parenthesis\">(</span>" + params.join("<span class=\"math-separator\">,</span>") + "<span class=\"math-parenthesis math-round-parenthesis\">)</span><span class=\"math-operator math-assignment-operator math-variable-assignment-operator math-binary-operator\">=</span>" + expr;
 		}
+		_toMathML() {
+			let expr = this.expr.toMathML();
+			if (needParenthesis(this, "keep", void 0)) expr = `<mrow><mo>(</mo>${expr}<mo>)</mo></mrow>`;
+			const params = this.params.map((p) => toMathMLSymbol(p)).join("<mo>,</mo>");
+			return `<mrow>${toMathMLSymbol(this.name)}<mo>&#x2061;</mo><mrow><mo>(</mo>${params}<mo>)</mo></mrow><mo>=</mo>${expr}</mrow>`;
+		}
 		_toTex(options) {
 			const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
 			let expr = this.expr.toTex(options);
@@ -9031,11 +9111,18 @@ function createSubScope(parentScope, args) {
 //#endregion
 //#region src/node/FunctionNode.ts
 const name$33 = "FunctionNode";
-const createFunctionNode = /* #__PURE__ */ factory(name$33, [
+const dependencies$33 = [
 	"math",
 	"Node",
 	"SymbolNode"
-], ({ math, Node, SymbolNode }) => {
+];
+function isMissingMember(object, prop) {
+	if (!(prop in Object(object))) return true;
+	if (isSafeMethod(object, prop)) return false;
+	if (isSafeProperty(object, prop)) return getSafeProperty(object, prop) === void 0;
+	return false;
+}
+const createFunctionNode = /* #__PURE__ */ factory(name$33, dependencies$33, ({ math, Node, SymbolNode }) => {
 	const strin = (entity) => format(entity, { truncate: 78 });
 	function expandTemplate(template, node, options) {
 		let latex = "";
@@ -9171,7 +9258,7 @@ const createFunctionNode = /* #__PURE__ */ factory(name$33, [
 				const rawArgs = this.args;
 				return function evalFunctionNode(scope, args, context) {
 					const object = evalObject(scope, args, context);
-					if (fromOptionalChaining && (object == null || object[prop] === void 0)) return;
+					if (fromOptionalChaining && (object == null || isMissingMember(object, prop))) return;
 					const fn = getSafeMethod(object, prop);
 					if (fn?.rawArgs) return fn(rawArgs, math, createSubScope(scope, args));
 					else {
@@ -9296,6 +9383,15 @@ const createFunctionNode = /* #__PURE__ */ factory(name$33, [
 });
 //#endregion
 //#region src/node/IndexNode.ts
+function coerceIndexValue(value) {
+	if (isBigNumber(value)) {
+		const big = value;
+		const n = big.toNumber();
+		if (!big.isInteger() || !Number.isSafeInteger(n)) throw new RangeError(`Index must be an integer within the safe range, got BigNumber ${big.toString()}`);
+		return n;
+	}
+	return value;
+}
 const name$32 = "IndexNode";
 const createIndexNode = /* #__PURE__ */ factory(name$32, ["Node", "size"], ({ Node, size }) => {
 	class IndexNode extends Node {
@@ -9333,7 +9429,7 @@ const createIndexNode = /* #__PURE__ */ factory(name$32, ["Node", "size"], ({ No
 			const index = getSafeProperty(math, "index");
 			return function evalIndexNode(scope, args, context) {
 				const dimensions = map(evalDimensions, function(evalDimension) {
-					return evalDimension(scope, args, context);
+					return coerceIndexValue(evalDimension(scope, args, context));
 				});
 				return index(...dimensions);
 			};
@@ -9374,6 +9470,10 @@ const createIndexNode = /* #__PURE__ */ factory(name$32, ["Node", "size"], ({ No
 			if (this.dotNotation) return "<span class=\"math-operator math-accessor-operator\">.</span><span class=\"math-symbol math-property\">" + escape(this.getObjectProperty()) + "</span>";
 			else return "<span class=\"math-parenthesis math-square-parenthesis\">[</span>" + dimensions.join("<span class=\"math-separator\">,</span>") + "<span class=\"math-parenthesis math-square-parenthesis\">]</span>";
 		}
+		_toMathML() {
+			if (this.dotNotation) return `<mo>.</mo>${toMathMLSymbol(String(this.getObjectProperty()))}`;
+			return `<mrow>${this.dimensions.map((range) => range.toMathML()).join("<mo>,</mo>")}</mrow>`;
+		}
 		_toTex(options) {
 			const dimensions = this.dimensions.map(function(range) {
 				return range.toTex(options);
@@ -9453,6 +9553,9 @@ const createObjectNode = /* #__PURE__ */ factory(name$31, ["Node"], ({ Node }) =
 		_toHTML(options) {
 			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>");
 		}
+		_toMathML() {
+			return renderObjectEntries(this.properties, (key, node) => `<mtr><mtd><mtext>${escapeMathML(key)}:</mtext></mtd><mtd>${node.toMathML()}</mtd></mtr>`, "", (joined) => `<mrow><mo>{</mo><mtable columnalign="left left">${joined}</mtable><mo>}</mo></mrow>`);
+		}
 		_toTex(options) {
 			return renderObjectEntries(this.properties, (key, node) => "\\mathbf{" + key + ":} & " + node.toTex(options) + "\\\\", "\n", (joined) => "\\left\\{\\begin{array}{ll}" + joined + "\\end{array}\\right\\}");
 		}
@@ -9974,6 +10077,14 @@ const createRangeNode = /* #__PURE__ */ factory(name$28, ["Node"], ({ Node }) =>
 			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>");
 		}
+		_toMathML() {
+			const parens = calculateNecessaryParentheses(this, "keep", "hide");
+			const wrap = (s, need) => need ? `<mrow><mo>(</mo>${s}<mo>)</mo></mrow>` : s;
+			let str = wrap(this.start.toMathML(), parens.start);
+			if (this.step) str += "<mo>:</mo>" + wrap(this.step.toMathML(), parens.step);
+			str += "<mo>:</mo>" + wrap(this.end.toMathML(), parens.end);
+			return `<mrow>${str}</mrow>`;
+		}
 		_toTex(options) {
 			const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
 			const parens = calculateNecessaryParentheses(this, parenthesis, options && options.implicit || "hide");