@danielsimonjr/mathts-expression 0.2.4 → 0.3.0

package/dist/index.js

@@ -118,10 +118,10 @@ function isBigNumber(x) {
   return false;
 }
 function isComplex(x) {
-  return x && typeof x === "object" && Object.getPrototypeOf(x).isComplex === true || false;
+  return !!(x && typeof x === "object" && Object.getPrototypeOf(x).isComplex === true);
 }
 function isFraction(x) {
-  return x && typeof x === "object" && Object.getPrototypeOf(x).isFraction === true || false;
+  return !!(x && typeof x === "object" && Object.getPrototypeOf(x).isFraction === true);
 }
 function isUnit(x) {
   if (!x || typeof x !== "object") return false;
@@ -575,13 +575,16 @@ var properties = [
 function unwrapParen(_node, parenthesis) {
   if (!parenthesis || parenthesis !== "auto") return _node;
   let node = _node;
-  while (isParenthesisNode(node)) node = node.content;
+  while (isParenthesisNode(node)) {
+    node = node.content;
+  }
   return node;
 }
 function getPrecedence(_node, parenthesis, implicit, parent) {
   let node = _node;
+  const parentNode = parent;
   if (parenthesis !== "keep") {
-    node = _node.getContent();
+    node = node.getContent();
   }
   const identifier = node.getIdentifier();
   let precedence = null;
@@ -593,8 +596,8 @@ function getPrecedence(_node, parenthesis, implicit, parent) {
   }
   if (identifier === "OperatorNode:multiply" && node.implicit && implicit !== "show") {
     const leftArg = unwrapParen(node.args[0], parenthesis);
-    if (!(isConstantNode(leftArg) && parent && parent.getIdentifier() === "OperatorNode:divide" && rule2Node(unwrapParen(parent.args[0], parenthesis))) && !(leftArg.getIdentifier() === "OperatorNode:divide" && rule2Node(unwrapParen(leftArg.args[0], parenthesis)) && isConstantNode(unwrapParen(leftArg.args[1], parenthesis)))) {
-      precedence += 1;
+    if (!(isConstantNode(leftArg) && parentNode && parentNode.getIdentifier() === "OperatorNode:divide" && rule2Node(unwrapParen(parentNode.args[0], parenthesis))) && !(leftArg.getIdentifier() === "OperatorNode:divide" && rule2Node(unwrapParen(leftArg.args[0], parenthesis)) && isConstantNode(unwrapParen(leftArg.args[1], parenthesis)))) {
+      precedence = (precedence ?? 0) + 1;
     }
   }
   return precedence;
@@ -602,7 +605,7 @@ function getPrecedence(_node, parenthesis, implicit, parent) {
 function getAssociativity(_node, parenthesis) {
   let node = _node;
   if (parenthesis !== "keep") {
-    node = _node.getContent();
+    node = node.getContent();
   }
   const identifier = node.getIdentifier();
   const index = getPrecedence(node, parenthesis, void 0, void 0);
@@ -624,8 +627,10 @@ function getAssociativity(_node, parenthesis) {
   return null;
 }
 function isAssociativeWith(nodeA, nodeB, parenthesis) {
-  const a = parenthesis !== "keep" ? nodeA.getContent() : nodeA;
-  const b = parenthesis !== "keep" ? nodeA.getContent() : nodeB;
+  const nA = nodeA;
+  const nB = nodeB;
+  const a = parenthesis !== "keep" ? nA.getContent() : nA;
+  const b = parenthesis !== "keep" ? nA.getContent() : nB;
   const identifierA = a.getIdentifier();
   const identifierB = b.getIdentifier();
   const index = getPrecedence(a, parenthesis, void 0, void 0);
@@ -647,7 +652,7 @@ function getOperator(fn) {
   const identifier = "OperatorNode:" + fn;
   for (const group of properties) {
     if (identifier in group) {
-      return group[identifier].op;
+      return group[identifier].op ?? null;
     }
   }
   return null;
@@ -663,8 +668,9 @@ var MathjsError = class _MathjsError extends Error {
   constructor(message) {
     super(message);
     this.name = "MathjsError";
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _MathjsError);
+    const { captureStackTrace } = Error;
+    if (captureStackTrace) {
+      captureStackTrace(this, _MathjsError);
     }
   }
 };
@@ -696,7 +702,7 @@ function assertDependencies(name21, dependencies21, scope) {
   }
 }
 function isOptionalDependency(dependency) {
-  return dependency && dependency[0] === "?";
+  return Boolean(dependency && dependency[0] === "?");
 }
 function stripOptionalNotation(dependency) {
   return dependency && dependency[0] === "?" ? dependency.slice(1) : dependency;
@@ -742,8 +748,9 @@ var IndexError = class _IndexError extends RangeError {
     this.min = actualMin;
     this.max = actualMax;
     this.name = "IndexError";
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _IndexError);
+    const { captureStackTrace } = Error;
+    if (captureStackTrace) {
+      captureStackTrace(this, _IndexError);
     }
   }
 };
@@ -822,9 +829,7 @@ function format(value, options) {
     case "auto":
       return toPrecision(value, precision, options).replace(
         /((\.\d*?)(0+))($|e)/,
-        function() {
-          const digits = arguments[2];
-          const e = arguments[4];
+        function(_match, _g1, digits, _g3, e) {
           return digits !== "." ? digits + e : e;
         }
       );
@@ -1093,8 +1098,9 @@ function format2(value, options) {
     case "hex":
       return formatBigNumberToBase(value, 16, wordSize);
     case "auto": {
-      const lowerExp = _toNumberOrDefault2(options?.lowerExp, -3);
-      const upperExp = _toNumberOrDefault2(options?.upperExp, 5);
+      const optionsObject = typeof options === "object" ? options : void 0;
+      const lowerExp = _toNumberOrDefault2(optionsObject?.lowerExp, -3);
+      const upperExp = _toNumberOrDefault2(optionsObject?.upperExp, 5);
       if (value.isZero()) return "0";
       let str;
       const rounded = value.toSignificantDigits(precision);
@@ -1104,11 +1110,12 @@ function format2(value, options) {
       } else {
         str = toExponential2(value, precision);
       }
-      return str.replace(/((\.\d*?)(0+))($|e)/, function() {
-        const digits = arguments[2];
-        const e = arguments[4];
-        return digits !== "." ? digits + e : e;
-      });
+      return str.replace(
+        /((\.\d*?)(0+))($|e)/,
+        function(_match, _g1, digits, _g3, e) {
+          return digits !== "." ? digits + e : e;
+        }
+      );
     }
     default:
       throw new Error(
@@ -1160,14 +1167,19 @@ function _format(value, options) {
     return format(value, options);
   }
   if (isBigNumber(value)) {
-    return format2(value, options);
+    return format2(
+      value,
+      options
+    );
   }
   if (looksLikeFraction(value)) {
-    if (!options || options.fraction !== "decimal") {
-      const signedNumerator = typeof value.n === "bigint" ? BigInt(value.s) * value.n : value.s * value.n;
-      return `${signedNumerator}/${value.d}`;
+    const v = value;
+    const opts = options;
+    if (!opts || opts.fraction !== "decimal") {
+      const signedNumerator = typeof v.n === "bigint" ? BigInt(v.s) * v.n : v.s * v.n;
+      return `${signedNumerator}/${v.d}`;
     } else {
-      return value.toString();
+      return v.toString();
     }
   }
   if (Array.isArray(value)) {
@@ -1177,13 +1189,15 @@ function _format(value, options) {
     return stringify(value);
   }
   if (typeof value === "function") {
-    return value.syntax ? String(value.syntax) : "function";
+    const fn = value;
+    return fn.syntax ? String(fn.syntax) : "function";
   }
   if (value && typeof value === "object") {
-    if (typeof value.format === "function") {
-      return value.format(options);
-    } else if (value && value.toString(options) !== {}.toString()) {
-      return value.toString(options);
+    const v = value;
+    if (typeof v.format === "function") {
+      return v.format(options);
+    } else if (value && v.toString(options) !== {}.toString()) {
+      return v.toString(options);
     } else {
       const entries = Object.keys(value).map((key) => {
         return stringify(key) + ": " + format3(value[key], options);
@@ -1235,7 +1249,7 @@ function formatArray(array, options) {
   }
 }
 function looksLikeFraction(value) {
-  return value && typeof value === "object" && typeof value.s === "bigint" && typeof value.n === "bigint" && typeof value.d === "bigint" || false;
+  return !!value && typeof value === "object" && typeof value.s === "bigint" && typeof value.n === "bigint" && typeof value.d === "bigint" || false;
 }
 
 // src/utils/array.ts
@@ -1365,10 +1379,13 @@ var createParse = /* @__PURE__ */ factory(
     });
     function parseMultiple(expressions, options = {}) {
       const extraNodes = options.nodes !== void 0 ? options.nodes : {};
-      return deepMap2(expressions, function(elem) {
-        if (typeof elem !== "string") throw new TypeError("String expected");
-        return parseStart(elem, extraNodes);
-      });
+      return deepMap2(
+        expressions,
+        function(elem) {
+          if (typeof elem !== "string") throw new TypeError("String expected");
+          return parseStart(elem, extraNodes);
+        }
+      );
     }
     const DELIMITERS = {
       ",": true,
@@ -1722,17 +1739,19 @@ var createParse = /* @__PURE__ */ factory(
           value = parseAssignment(state);
           return new AssignmentNode(new SymbolNode(name21), value);
         } else if (isAccessorNode(node)) {
-          if (node.optionalChaining) {
+          const accessor = node;
+          if (accessor.optionalChaining) {
             throw createSyntaxError(state, "Cannot assign to optional chain");
           }
           getTokenSkipNewline(state);
           value = parseAssignment(state);
-          return new AssignmentNode(node.object, node.index, value);
+          return new AssignmentNode(accessor.object, accessor.index, value);
         } else if (isFunctionNode(node) && isSymbolNode(node.fn)) {
           valid = true;
           args = [];
-          name21 = node.name;
-          node.args.forEach(function(arg, index) {
+          const fnNode = node;
+          name21 = fnNode.name;
+          fnNode.args.forEach(function(arg, index) {
             if (isSymbolNode(arg)) {
               args[index] = arg.name;
             } else {
@@ -2278,12 +2297,13 @@ var createParse = /* @__PURE__ */ factory(
             }
             closeParams(state);
             getToken(state);
-            cols = params[0].items.length;
+            const rowItems = (row2) => row2.items;
+            cols = rowItems(params[0]).length;
             for (let r = 1; r < rows; r++) {
-              if (params[r].items.length !== cols) {
+              if (rowItems(params[r]).length !== cols) {
                 throw createError(
                   state,
-                  "Column dimensions mismatch (" + params[r].items.length + " !== " + cols + ")"
+                  "Column dimensions mismatch (" + rowItems(params[r]).length + " !== " + cols + ")"
                 );
               }
             }
@@ -2412,16 +2432,16 @@ function getSafeProperty(object, prop) {
     return object[prop];
   }
   if (typeof object[prop] === "function" && isSafeMethod(object, prop)) {
-    throw new Error('Cannot access method "' + prop + '" as a property');
+    throw new Error('Cannot access method "' + String(prop) + '" as a property');
   }
-  throw new Error('No access to property "' + prop + '"');
+  throw new Error('No access to property "' + String(prop) + '"');
 }
 function setSafeProperty(object, prop, value) {
   if (isSafeProperty(object, prop)) {
     object[prop] = value;
     return value;
   }
-  throw new Error('No access to property "' + prop + '"');
+  throw new Error('No access to property "' + String(prop) + '"');
 }
 function isSafeProperty(object, prop) {
   if (!isPlainObject(object) && !Array.isArray(object)) {
@@ -2440,7 +2460,7 @@ function isSafeProperty(object, prop) {
 }
 function getSafeMethod(object, method) {
   if (!isSafeMethod(object, method)) {
-    throw new Error('No access to method "' + method + '"');
+    throw new Error('No access to method "' + String(method) + '"');
   }
   return object[method];
 }
@@ -2463,7 +2483,7 @@ function isSafeMethod(object, method) {
   return true;
 }
 function isPlainObject(object) {
-  return typeof object === "object" && object && object.constructor === Object;
+  return typeof object === "object" && !!object && object.constructor === Object;
 }
 var safeNativeProperties = {
   length: true,
@@ -2648,9 +2668,7 @@ var createParserClass = /* @__PURE__ */ factory(
       return evaluate(expr, this.scope);
     };
     Parser.prototype.get = function(name21) {
-      if (this.scope.has(name21)) {
-        return this.scope.get(name21);
-      }
+      return this.scope.has(name21) ? this.scope.get(name21) : void 0;
     };
     Parser.prototype.getAll = function() {
       return toObject(this.scope);
@@ -2717,7 +2735,8 @@ var createParserClass = /* @__PURE__ */ factory(
   { isClass: true }
 );
 function isExpressionFunction(value) {
-  return typeof value === "function" && typeof value.syntax === "string" && typeof value.expr === "string";
+  const fn = value;
+  return typeof value === "function" && typeof fn.syntax === "string" && typeof fn.expr === "string";
 }
 
 // src/function/parser.ts
@@ -2726,7 +2745,10 @@ var dependencies3 = ["typed", "Parser"];
 var createParser = /* @__PURE__ */ factory(
   name3,
   dependencies3,
-  ({ typed, Parser }) => {
+  ({
+    typed,
+    Parser
+  }) => {
     return typed(name3, {
       "": function() {
         return new Parser();
@@ -2838,49 +2860,50 @@ function compile(node, mathScope) {
   };
 }
 function compileNode(node, math, argNames) {
-  if (node.isConstantNode) {
+  const n = node;
+  if (n.isConstantNode) {
     return compileConstantNode(node);
   }
-  if (node.isSymbolNode) {
+  if (n.isSymbolNode) {
     return compileSymbolNode(node, math, argNames);
   }
-  if (node.isOperatorNode) {
+  if (n.isOperatorNode) {
     return compileOperatorNode(node, math, argNames);
   }
-  if (node.isFunctionNode) {
+  if (n.isFunctionNode) {
     return compileFunctionNode(node, math, argNames);
   }
-  if (node.isParenthesisNode) {
-    return compileNode(node.content, math, argNames);
+  if (n.isParenthesisNode) {
+    return compileNode(n.content, math, argNames);
   }
-  if (node.isArrayNode) {
+  if (n.isArrayNode) {
     return compileArrayNode(node, math, argNames);
   }
-  if (node.isAssignmentNode) {
+  if (n.isAssignmentNode) {
     return compileAssignmentNode(node, math, argNames);
   }
-  if (node.isBlockNode) {
+  if (n.isBlockNode) {
     return compileBlockNode(node, math, argNames);
   }
-  if (node.isConditionalNode) {
+  if (n.isConditionalNode) {
     return compileConditionalNode(node, math, argNames);
   }
-  if (node.isObjectNode) {
+  if (n.isObjectNode) {
     return compileObjectNode(node, math, argNames);
   }
-  if (node.isRangeNode) {
+  if (n.isRangeNode) {
     return compileRangeNode(node, math, argNames);
   }
-  if (node.isRelationalNode) {
+  if (n.isRelationalNode) {
     return compileRelationalNode(node, math, argNames);
   }
-  if (node.isFunctionAssignmentNode) {
+  if (n.isFunctionAssignmentNode) {
     return compileFunctionAssignmentNode(node, math, argNames);
   }
-  if (node.isAccessorNode) {
+  if (n.isAccessorNode) {
     return compileAccessorNode(node, math, argNames);
   }
-  if (node.isIndexNode) {
+  if (n.isIndexNode) {
     return compileIndexNode(node, math, argNames);
   }
   throw new Error(`Unknown node type: ${node.type || node.constructor?.name}`);
@@ -2914,12 +2937,13 @@ function compileSymbolNode(node, math, argNames) {
   };
 }
 function compileOperatorNode(node, math, argNames) {
-  const fnName = node.fn;
+  const opNode = node;
+  const fnName = opNode.fn;
   if (typeof fnName !== "string" || !(fnName in math)) {
     throw new Error(`Function "${fnName}" missing in provided namespace "math"`);
   }
   const fn = math[fnName];
-  const evalArgs = node.args.map((arg) => compileNode(arg, math, argNames));
+  const evalArgs = opNode.args.map((arg) => compileNode(arg, math, argNames));
   if (evalArgs.length === 1) {
     const evalArg0 = evalArgs[0];
     return function evalOperatorNode(scope, args, context) {
@@ -2939,8 +2963,9 @@ function compileOperatorNode(node, math, argNames) {
   };
 }
 function compileFunctionNode(node, math, argNames) {
-  const evalArgs = node.args.map((arg) => compileNode(arg, math, argNames));
-  const fnNode = node.fn;
+  const fnNodeOuter = node;
+  const evalArgs = fnNodeOuter.args.map((arg) => compileNode(arg, math, argNames));
+  const fnNode = fnNodeOuter.fn;
   if (fnNode && fnNode.isSymbolNode) {
     const name21 = fnNode.name;
     const resolveFn = (scope) => {
@@ -3007,27 +3032,27 @@ function compileFunctionNode(node, math, argNames) {
   };
 }
 function compileArrayNode(node, math, argNames) {
-  const evalItems = node.items.map(
-    (item) => compileNode(item, math, argNames)
-  );
+  const items = node.items;
+  const evalItems = items.map((item) => compileNode(item, math, argNames));
   return function evalArrayNode(scope, args, context) {
     return evalItems.map((e) => e(scope, args, context));
   };
 }
 function compileAssignmentNode(node, math, argNames) {
-  const evalValue = compileNode(node.value, math, argNames);
-  if (node.object && node.object.isSymbolNode && !node.index) {
-    const name22 = node.object.name;
+  const asgNode = node;
+  const evalValue = compileNode(asgNode.value, math, argNames);
+  if (asgNode.object && asgNode.object.isSymbolNode && !asgNode.index) {
+    const name22 = asgNode.object.name;
     return function evalAssignmentNode(scope, args, context) {
       const value = evalValue(scope, args, context);
       scope.set(name22, value);
       return value;
     };
   }
-  if (node.object && node.object.isAccessorNode) {
-    const evalObject = compileNode(node.object.object, math, argNames);
-    if (node.object.index && node.object.index.isObjectProperty()) {
-      const prop = node.object.index.getObjectProperty();
+  if (asgNode.object && asgNode.object.isAccessorNode) {
+    const evalObject = compileNode(asgNode.object.object, math, argNames);
+    if (asgNode.object.index && asgNode.object.index.isObjectProperty()) {
+      const prop = asgNode.object.index.getObjectProperty();
       return function evalAssignmentNode(scope, args, context) {
         const obj = evalObject(scope, args, context);
         const value = evalValue(scope, args, context);
@@ -3035,7 +3060,7 @@ function compileAssignmentNode(node, math, argNames) {
       };
     }
   }
-  const name21 = node.name || node.object && node.object.name;
+  const name21 = asgNode.name || asgNode.object && asgNode.object.name;
   if (name21) {
     return function evalAssignmentNode(scope, args, context) {
       const value = evalValue(scope, args, context);
@@ -3046,7 +3071,8 @@ function compileAssignmentNode(node, math, argNames) {
   throw new Error("Unsupported assignment target");
 }
 function compileBlockNode(node, math, argNames) {
-  const evalBlocks = node.blocks.map((block) => ({
+  const blocks = node.blocks;
+  const evalBlocks = blocks.map((block) => ({
     evaluate: compileNode(block.node, math, argNames),
     visible: block.visible
   }));
@@ -3064,19 +3090,21 @@ function compileBlockNode(node, math, argNames) {
   };
 }
 function compileConditionalNode(node, math, argNames) {
-  const evalCondition = compileNode(node.condition, math, argNames);
-  const evalTrueExpr = compileNode(node.trueExpr, math, argNames);
-  const evalFalseExpr = compileNode(node.falseExpr, math, argNames);
+  const condNode = node;
+  const evalCondition = compileNode(condNode.condition, math, argNames);
+  const evalTrueExpr = compileNode(condNode.trueExpr, math, argNames);
+  const evalFalseExpr = compileNode(condNode.falseExpr, math, argNames);
   return function evalConditionalNode(scope, args, context) {
     const condition = evalCondition(scope, args, context);
     return testCondition(condition) ? evalTrueExpr(scope, args, context) : evalFalseExpr(scope, args, context);
   };
 }
 function compileObjectNode(node, math, argNames) {
-  const keys = Object.keys(node.properties);
+  const properties2 = node.properties;
+  const keys = Object.keys(properties2);
   const evalProps = keys.map((key) => ({
     key,
-    evaluate: compileNode(node.properties[key], math, argNames)
+    evaluate: compileNode(properties2[key], math, argNames)
   }));
   return function evalObjectNode(scope, args, context) {
     const result = {};
@@ -3091,10 +3119,11 @@ function compileRangeNode(node, math, argNames) {
   if (!rangeFn) {
     throw new Error('Function "range" missing in math namespace (required for range expressions)');
   }
-  const evalStart = compileNode(node.start, math, argNames);
-  const evalEnd = compileNode(node.end, math, argNames);
-  if (node.step) {
-    const evalStep = compileNode(node.step, math, argNames);
+  const rngNode = node;
+  const evalStart = compileNode(rngNode.start, math, argNames);
+  const evalEnd = compileNode(rngNode.end, math, argNames);
+  if (rngNode.step) {
+    const evalStep = compileNode(rngNode.step, math, argNames);
     return function evalRangeNode(scope, args, context) {
       return rangeFn(
         evalStart(scope, args, context),
@@ -3108,8 +3137,9 @@ function compileRangeNode(node, math, argNames) {
   };
 }
 function compileRelationalNode(node, math, argNames) {
-  const compiled = node.params.map((p) => compileNode(p, math, argNames));
-  const conditionals = node.conditionals;
+  const relNode = node;
+  const compiled = relNode.params.map((p) => compileNode(p, math, argNames));
+  const conditionals = relNode.conditionals;
   return function evalRelationalNode(scope, args, context) {
     let evalLhs;
     let evalRhs = compiled[0](scope, args, context);
@@ -3128,13 +3158,14 @@ function compileRelationalNode(node, math, argNames) {
   };
 }
 function compileFunctionAssignmentNode(node, math, argNames) {
+  const faNode = node;
   const childArgNames = Object.create(argNames);
-  for (const param of node.params) {
+  for (const param of faNode.params) {
     childArgNames[param] = true;
   }
-  const evalExpr = compileNode(node.expr, math, childArgNames);
-  const name21 = node.name;
-  const params = node.params;
+  const evalExpr = compileNode(faNode.expr, math, childArgNames);
+  const name21 = faNode.name;
+  const params = faNode.params;
   return function evalFunctionAssignmentNode(scope, args, _context) {
     const fn = function(...fnArgs) {
       const childArgs = Object.create(args);
@@ -3149,19 +3180,20 @@ function compileFunctionAssignmentNode(node, math, argNames) {
   };
 }
 function compileAccessorNode(node, math, argNames) {
-  const evalObject = compileNode(node.object, math, argNames);
-  if (node.index && node.index.isObjectProperty && node.index.isObjectProperty()) {
-    const prop = node.index.getObjectProperty();
+  const accNode = node;
+  const evalObject = compileNode(accNode.object, math, argNames);
+  if (accNode.index && accNode.index.isObjectProperty && accNode.index.isObjectProperty()) {
+    const prop = accNode.index.getObjectProperty();
     return function evalAccessorNode(scope, args, context) {
       const object = evalObject(scope, args, context);
-      if (node.optionalChaining && object == null) return void 0;
+      if (accNode.optionalChaining && object == null) return void 0;
       return getSafeProperty(object, prop);
     };
   }
-  const evalIndex = compileNode(node.index, math, argNames);
+  const evalIndex = compileNode(accNode.index, math, argNames);
   return function evalAccessorNode(scope, args, context) {
     const object = evalObject(scope, args, context);
-    if (node.optionalChaining && object == null) return void 0;
+    if (accNode.optionalChaining && object == null) return void 0;
     const index = evalIndex(scope, args, context);
     if (math.subset) {
       return math.subset(object, index);
@@ -3173,7 +3205,8 @@ function compileAccessorNode(node, math, argNames) {
   };
 }
 function compileIndexNode(node, math, argNames) {
-  const evalDimensions = node.dimensions.map(
+  const dimensionNodes = node.dimensions;
+  const evalDimensions = dimensionNodes.map(
     (dim) => compileNode(dim, math, argNames)
   );
   return function evalIndexNode(scope, args, context) {
@@ -3190,11 +3223,12 @@ function testCondition(condition) {
     return !!condition;
   }
   if (condition) {
-    if (typeof condition.isZero === "function") {
-      return !condition.isZero();
+    const c = condition;
+    if (typeof c.isZero === "function") {
+      return !c.isZero();
     }
-    if (condition.re !== void 0 || condition.im !== void 0) {
-      return !!(condition.re || condition.im);
+    if (c.re !== void 0 || c.im !== void 0) {
+      return !!(c.re || c.im);
     }
   }
   if (condition === null || condition === void 0) {
@@ -3219,27 +3253,29 @@ function validateAst(node) {
   if (node === null || node === void 0 || typeof node !== "object") {
     return;
   }
-  if (node.isAssignmentNode === true) {
+  const n = node;
+  if (n.isAssignmentNode === true) {
     throw new Error(
       "Security: assignment expressions are disabled. Pass `{ unsafe: true }` to opt out."
     );
   }
-  if (node.isFunctionAssignmentNode === true) {
+  if (n.isFunctionAssignmentNode === true) {
     throw new Error(
       "Security: function definitions (FunctionAssignmentNode) are disabled. Pass `{ unsafe: true }` to opt out."
     );
   }
-  if (node.isFunctionNode === true) {
-    const fnName = node.fn && typeof node.fn === "object" && node.fn.isSymbolNode && node.fn.name || (typeof node.name === "string" ? node.name : void 0);
+  if (n.isFunctionNode === true) {
+    const fn = n.fn;
+    const fnName = (fn && typeof fn === "object" && fn.isSymbolNode && typeof fn.name === "string" ? fn.name : void 0) || (typeof n.name === "string" ? n.name : void 0);
     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 node.forEach === "function") {
+  if (typeof n.forEach === "function") {
     try {
-      node.forEach((child) => validateAst(child));
+      n.forEach((child) => validateAst(child));
       return;
     } catch (err) {
       if (err instanceof Error && err.message.startsWith("Security:")) throw err;
@@ -3259,15 +3295,18 @@ function validateAst(node) {
     "end",
     "step"
   ]) {
-    if (key in node) validateAst(node[key]);
+    if (key in n) validateAst(n[key]);
   }
   for (const key of ["args", "items", "params"]) {
-    const arr = node[key];
+    const arr = n[key];
     if (Array.isArray(arr)) for (const child of arr) validateAst(child);
   }
-  if (Array.isArray(node.blocks)) for (const b of node.blocks) validateAst(b && b.node);
-  if (node.properties && typeof node.properties === "object") {
-    for (const k of Object.keys(node.properties)) validateAst(node.properties[k]);
+  if (Array.isArray(n.blocks)) {
+    for (const b of n.blocks) validateAst(b && b.node);
+  }
+  if (n.properties && typeof n.properties === "object") {
+    const properties2 = n.properties;
+    for (const k of Object.keys(properties2)) validateAst(properties2[k]);
   }
 }
 function createEvaluate(parseFn, mathScope) {
@@ -3295,6 +3334,128 @@ function compileExpression(parseFn, mathScope, expr, options) {
   return compile(node, mathScope);
 }
 
+// src/utils/mathml.ts
+var mathmlSymbols = {
+  alpha: "\u03B1",
+  beta: "\u03B2",
+  gamma: "\u03B3",
+  delta: "\u03B4",
+  epsilon: "\u03B5",
+  zeta: "\u03B6",
+  eta: "\u03B7",
+  theta: "\u03B8",
+  iota: "\u03B9",
+  kappa: "\u03BA",
+  lambda: "\u03BB",
+  mu: "\u03BC",
+  nu: "\u03BD",
+  xi: "\u03BE",
+  omicron: "\u03BF",
+  pi: "\u03C0",
+  rho: "\u03C1",
+  sigma: "\u03C3",
+  tau: "\u03C4",
+  upsilon: "\u03C5",
+  phi: "\u03C6",
+  chi: "\u03C7",
+  psi: "\u03C8",
+  omega: "\u03C9",
+  Gamma: "\u0393",
+  Delta: "\u0394",
+  Theta: "\u0398",
+  Lambda: "\u039B",
+  Xi: "\u039E",
+  Pi: "\u03A0",
+  Sigma: "\u03A3",
+  Upsilon: "\u03A5",
+  Phi: "\u03A6",
+  Psi: "\u03A8",
+  Omega: "\u03A9"
+};
+var PRECEDENCE = {
+  equal: 1,
+  unequal: 1,
+  smaller: 1,
+  larger: 1,
+  smallerEq: 1,
+  largerEq: 1,
+  add: 2,
+  subtract: 2,
+  multiply: 3,
+  divide: 3,
+  dotMultiply: 3,
+  dotDivide: 3,
+  mod: 3,
+  unaryMinus: 4,
+  unaryPlus: 4,
+  pow: 5
+};
+var INLINE_OP = {
+  add: "+",
+  subtract: "-",
+  equal: "=",
+  unequal: "\u2260",
+  smaller: "<",
+  larger: ">",
+  smallerEq: "\u2264",
+  largerEq: "\u2265",
+  mod: "mod"
+};
+function escapeMathML(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function mi(name21) {
+  return `<mi>${mathmlSymbols[name21] ?? escapeMathML(name21)}</mi>`;
+}
+function toMathMLSymbol(name21) {
+  const us = name21.indexOf("_");
+  if (us > 0 && us < name21.length - 1) {
+    const base = name21.slice(0, us);
+    const sub = name21.slice(us + 1);
+    const subEl = /^\d+$/.test(sub) ? `<mn>${sub}</mn>` : mi(sub);
+    return `<msub>${mi(base)}${subEl}</msub>`;
+  }
+  return mi(name21);
+}
+function numberToMathML(value) {
+  if (!Number.isFinite(value)) return `<mn>${escapeMathML(String(value))}</mn>`;
+  const s = String(value);
+  const sci = /^(-?)(\d+(?:\.\d+)?)[eE]([+-]?\d+)$/.exec(s);
+  if (sci) {
+    const sign = sci[1] ? "<mo>-</mo>" : "";
+    const exp = String(parseInt(sci[3], 10));
+    return `<mrow>${sign}<mn>${sci[2]}</mn><mo>&#xD7;</mo><msup><mn>10</mn><mn>${exp}</mn></msup></mrow>`;
+  }
+  if (value < 0) return `<mrow><mo>-</mo><mn>${escapeMathML(String(-value))}</mn></mrow>`;
+  return `<mn>${escapeMathML(s)}</mn>`;
+}
+function constantToMathML(value) {
+  const t = typeof value;
+  if (t === "number") return numberToMathML(value);
+  if (t === "bigint") return `<mn>${escapeMathML(String(value))}</mn>`;
+  if (t === "boolean") return `<mi>${value}</mi>`;
+  if (t === "string") return `<mtext>${escapeMathML(value)}</mtext>`;
+  return `<mtext>${escapeMathML(value === null ? "null" : String(value))}</mtext>`;
+}
+function inlineOperator(fn, op) {
+  return `<mo>${escapeMathML(INLINE_OP[fn] ?? op)}</mo>`;
+}
+function parenthesizeLower(childFragment, childFn, parentFn) {
+  if (childFn !== void 0) {
+    const cp = PRECEDENCE[childFn] ?? 0;
+    const pp = PRECEDENCE[parentFn] ?? 0;
+    if (cp > 0 && cp < pp) return `<mrow><mo>(</mo>${childFragment}<mo>)</mo></mrow>`;
+  }
+  return childFragment;
+}
+var MATH_OPEN = '<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">';
+function mathMLDocument(node) {
+  return `${MATH_OPEN}${node.toMathML()}</math>`;
+}
+function mathMLError(src) {
+  return `${MATH_OPEN}<merror><mtext>${escapeMathML(src)}</mtext></merror></math>`;
+}
+
 // src/node/Node.ts
 var name5 = "Node";
 var dependencies5 = ["mathWithTransform"];
@@ -3581,6 +3742,28 @@ var createNode = /* @__PURE__ */ factory(
         }
         return this._toTex(options);
       }
+      /**
+       * Render this node to a MathML fragment (the MathML analog of `toTex`).
+       * Like `toTex`, this returns the body — wrap it in a `<math>` element with
+       * `mathMLDocument(node)` to render. Never throws: a failing node degrades
+       * to an escaped `<merror>` fragment.
+       * @return {string}
+       */
+      toMathML() {
+        try {
+          return this._toMathML();
+        } catch {
+          return "<merror><mtext>render error</mtext></merror>";
+        }
+      }
+      /**
+       * Internal MathML generator. Overridden by the node types that render as
+       * typeset math; the base falls back to escaped text (best-effort display),
+       * rather than throwing like `_toTex`, so unhandled nodes degrade gracefully.
+       */
+      _toMathML() {
+        return `<mtext>${escapeMathML(this._toString())}</mtext>`;
+      }
       /**
        * Internal function to generate the LaTeX output.
        * This has to be implemented by every Node
@@ -3606,6 +3789,7 @@ var createNode = /* @__PURE__ */ factory(
               throw new TypeError("Object or function expected as callback");
           }
         }
+        return void 0;
       }
       /**
        * Get identifier.
@@ -3629,12 +3813,9 @@ var createNode = /* @__PURE__ */ factory(
 
 // src/transform/utils/errorTransform.ts
 function errorTransform(err) {
-  if (err && err.isIndexError) {
-    return new IndexError(
-      err.index + 1,
-      err.min + 1,
-      err.max !== void 0 ? err.max + 1 : void 0
-    );
+  const e = err;
+  if (e && e.isIndexError) {
+    return new IndexError(e.index + 1, e.min + 1, e.max !== void 0 ? e.max + 1 : void 0);
   }
   return err;
 }
@@ -3669,7 +3850,10 @@ var dependencies6 = ["subset", "Node"];
 var createAccessorNode = /* @__PURE__ */ factory(
   name6,
   dependencies6,
-  ({ subset, Node }) => {
+  ({
+    subset,
+    Node
+  }) => {
     const access = accessFactory({ subset });
     function needParenthesis(node) {
       return !(isAccessorNode(node) || isArrayNode(node) || isConstantNode(node) || isFunctionNode(node) || isObjectNode(node) || isParenthesisNode(node) || isSymbolNode(node));
@@ -4010,8 +4194,9 @@ var createArrayNode = /* @__PURE__ */ factory(
           const itemsFormRow = nested || mixedItems;
           const itemSep = itemsFormRow ? "&" : "\\\\";
           const itemsTex = items.map(function(node) {
-            if (node.items) {
-              return itemsToTex(node.items, !nested);
+            const arrayItems = node.items;
+            if (arrayItems) {
+              return itemsToTex(arrayItems, !nested);
             } else {
               return node.toTex(options);
             }
@@ -4061,7 +4246,10 @@ var dependencies8 = ["subset", "Node"];
 var createAssignmentNode = /* @__PURE__ */ factory(
   name8,
   dependencies8,
-  ({ subset, Node }) => {
+  ({
+    subset,
+    Node
+  }) => {
     const access = accessFactory({ subset });
     const assign = assignFactory({ subset });
     function needParenthesis(node, parenthesis, implicit) {
@@ -4186,9 +4374,10 @@ var createAssignmentNode = /* @__PURE__ */ factory(
             return value;
           };
         } else {
-          const evalParentObject = this.object.object._compile(math, argNames);
-          if (this.object.index.isObjectProperty()) {
-            const parentProp = this.object.index.getObjectProperty();
+          const accessorObject = this.object;
+          const evalParentObject = accessorObject.object._compile(math, argNames);
+          if (accessorObject.index.isObjectProperty()) {
+            const parentProp = accessorObject.index.getObjectProperty();
             return function evalAssignmentNode(scope, args, context) {
               const parent = evalParentObject(scope, args, context);
               const childObject = getSafeProperty(parent, parentProp);
@@ -4198,7 +4387,7 @@ var createAssignmentNode = /* @__PURE__ */ factory(
               return value;
             };
           } else {
-            const evalParentIndex = this.object.index._compile(math, argNames);
+            const evalParentIndex = accessorObject.index._compile(math, argNames);
             return function evalAssignmentNode(scope, args, context) {
               const parent = evalParentObject(scope, args, context);
               const parentIndex = evalParentIndex(scope, args, parent);
@@ -4297,6 +4486,14 @@ var createAssignmentNode = /* @__PURE__ */ factory(
        * @param {Object} options
        * @return {string}
        */
+      _toMathML() {
+        const obj = this.object;
+        if (obj && isSymbolNode(obj) && !this.index && this.value) {
+          const name21 = obj.name;
+          return `<mrow>${toMathMLSymbol(name21)}<mo>=</mo>${this.value.toMathML()}</mrow>`;
+        }
+        return `<mtext>${escapeMathML(this.toString())}</mtext>`;
+      }
       _toTex(options) {
         const object = this.object.toTex(options);
         const index = this.index ? this.index.toTex(options) : "";
@@ -4318,7 +4515,10 @@ var dependencies9 = ["ResultSet", "Node"];
 var createBlockNode = /* @__PURE__ */ factory(
   name9,
   dependencies9,
-  ({ ResultSet, Node }) => {
+  ({
+    ResultSet,
+    Node
+  }) => {
     class BlockNode extends Node {
       blocks;
       /**
@@ -4601,7 +4801,12 @@ var createConditionalNode = /* @__PURE__ */ factory(
        */
       _toString(options) {
         const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
-        const precedence = getPrecedence(this, parenthesis, options && options.implicit, void 0);
+        const precedence = getPrecedence(
+          this,
+          parenthesis,
+          options && options.implicit,
+          void 0
+        );
         let condition = this.condition.toString(options);
         const conditionPrecedence = getPrecedence(
           this.condition,
@@ -4669,7 +4874,12 @@ var createConditionalNode = /* @__PURE__ */ factory(
        */
       _toHTML(options) {
         const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
-        const precedence = getPrecedence(this, parenthesis, options && options.implicit, void 0);
+        const precedence = getPrecedence(
+          this,
+          parenthesis,
+          options && options.implicit,
+          void 0
+        );
         let condition = this.condition.toHTML(options);
         const conditionPrecedence = getPrecedence(
           this.condition,
@@ -5182,6 +5392,9 @@ var createConstantNode = /* @__PURE__ */ factory(
        * @param {Object} options
        * @return {string} str
        */
+      _toMathML() {
+        return constantToMathML(this.value);
+      }
       _toTex(options) {
         const value = this._toString(options);
         const type = typeOf(this.value);
@@ -5220,7 +5433,10 @@ var dependencies12 = ["typed", "Node"];
 var createFunctionAssignmentNode = /* @__PURE__ */ factory(
   name12,
   dependencies12,
-  ({ typed, Node }) => {
+  ({
+    typed,
+    Node
+  }) => {
     function needParenthesis(node, parenthesis, implicit) {
       const precedence = getPrecedence(node, parenthesis, implicit, void 0);
       const exprPrecedence = getPrecedence(node.expr, parenthesis, implicit, void 0);
@@ -5457,8 +5673,9 @@ var createFunctionNode = /* @__PURE__ */ factory(
       let latex = "";
       const regex = /\$(?:\{([a-z_][a-z_0-9]*)(?:\[([0-9]+)\])?\}|\$)/gi;
       let inputPos = 0;
-      let match;
-      while ((match = regex.exec(template)) !== null) {
+      let matchOrNull;
+      while ((matchOrNull = regex.exec(template)) !== null) {
+        const match = matchOrNull;
         latex += template.substring(inputPos, match.index);
         inputPos = match.index;
         if (match[0] === "$$") {
@@ -5499,8 +5716,9 @@ var createFunctionNode = /* @__PURE__ */ factory(
                 );
             }
           } else {
-            if (isNode(property[match[2]] && property[match[2]])) {
-              latex += property[match[2]].toTex(options);
+            const indexed = property[match[2]];
+            if (isNode(indexed && indexed)) {
+              latex += indexed.toTex(options);
             } else {
               throw new TypeError("Template: " + match[1] + "[" + match[2] + "] is not a Node.");
             }
@@ -5648,8 +5866,9 @@ var createFunctionNode = /* @__PURE__ */ factory(
             };
           }
         } else if (isAccessorNode(this.fn) && isIndexNode(this.fn.index) && this.fn.index.isObjectProperty()) {
-          const evalObject = this.fn.object._compile(math2, argNames);
-          const prop = this.fn.index.getObjectProperty();
+          const accessor = this.fn;
+          const evalObject = accessor.object._compile(math2, argNames);
+          const prop = accessor.index.getObjectProperty();
           const rawArgs = this.args;
           return function evalFunctionNode(scope, args, context) {
             const object = evalObject(scope, args, context);
@@ -5817,6 +6036,23 @@ var createFunctionNode = /* @__PURE__ */ factory(
        * @param {Object} options
        * @return {string} str
        */
+      _toMathML() {
+        const fnNode = this.fn;
+        const name21 = fnNode.name ?? String(this.fn);
+        const args = this.args;
+        if (name21 === "sqrt" && args.length === 1) return `<msqrt>${args[0].toMathML()}</msqrt>`;
+        if (name21 === "cbrt" && args.length === 1) {
+          return `<mroot><mrow>${args[0].toMathML()}</mrow><mn>3</mn></mroot>`;
+        }
+        if (name21 === "nthRoot" && args.length === 2) {
+          return `<mroot><mrow>${args[0].toMathML()}</mrow><mrow>${args[1].toMathML()}</mrow></mroot>`;
+        }
+        if (name21 === "abs" && args.length === 1) {
+          return `<mrow><mo>|</mo>${args[0].toMathML()}<mo>|</mo></mrow>`;
+        }
+        const inner = args.map((a) => a.toMathML()).join("<mo>,</mo>");
+        return `<mrow>${toMathMLSymbol(name21)}<mo>&#x2061;</mo><mrow><mo>(</mo>${inner}<mo>)</mo></mrow></mrow>`;
+      }
       _toTex(options) {
         const args = this.args.map(function(arg) {
           return arg.toTex(options);
@@ -5825,8 +6061,9 @@ var createFunctionNode = /* @__PURE__ */ factory(
         if (latexFunctions[this.name]) {
           latexConverter = latexFunctions[this.name];
         }
-        if (math[this.name] && (typeof math[this.name].toTex === "function" || typeof math[this.name].toTex === "object" || typeof math[this.name].toTex === "string")) {
-          latexConverter = math[this.name].toTex;
+        const mathEntry = math[this.name];
+        if (mathEntry && (typeof mathEntry.toTex === "function" || typeof mathEntry.toTex === "object" || typeof mathEntry.toTex === "string")) {
+          latexConverter = mathEntry.toTex;
         }
         let customToTex;
         switch (typeof latexConverter) {
@@ -5836,15 +6073,18 @@ var createFunctionNode = /* @__PURE__ */ factory(
           case "string":
             customToTex = expandTemplate(latexConverter, this, options);
             break;
-          case "object":
-            switch (typeof latexConverter[args.length]) {
+          case "object": {
+            const conv = latexConverter[args.length];
+            switch (typeof conv) {
               case "function":
-                customToTex = latexConverter[args.length](this, options);
+                customToTex = conv(this, options);
                 break;
               case "string":
-                customToTex = expandTemplate(latexConverter[args.length], this, options);
+                customToTex = expandTemplate(conv, this, options);
                 break;
             }
+            break;
+          }
         }
         if (typeof customToTex !== "undefined") {
           return customToTex;
@@ -5924,7 +6164,7 @@ var createIndexNode = /* @__PURE__ */ factory(
         const evalDimensions = map(
           this.dimensions,
           function(dimension, i) {
-            const needsEnd = dimension.filter((node) => node.isSymbolNode && node.name === "end").length > 0;
+            const needsEnd = dimension.filter((node) => !!(node.isSymbolNode && node.name === "end")).length > 0;
             if (needsEnd) {
               const childArgNames = Object.create(argNames);
               childArgNames.end = true;
@@ -5947,9 +6187,12 @@ var createIndexNode = /* @__PURE__ */ factory(
         );
         const index = getSafeProperty(math, "index");
         return function evalIndexNode(scope, args, context) {
-          const dimensions = map(evalDimensions, function(evalDimension) {
-            return evalDimension(scope, args, context);
-          });
+          const dimensions = map(
+            evalDimensions,
+            function(evalDimension) {
+              return evalDimension(scope, args, context);
+            }
+          );
           return index(...dimensions);
         };
       }
@@ -6253,7 +6496,8 @@ var createOperatorNode = /* @__PURE__ */ factory(
     function startsWithConstant(expr, parenthesis) {
       let curNode = expr;
       if (parenthesis === "auto") {
-        while (isParenthesisNode(curNode)) curNode = curNode.content;
+        while (isParenthesisNode(curNode))
+          curNode = curNode.content;
       }
       if (isConstantNode(curNode)) return true;
       if (isOperatorNode(curNode)) {
@@ -6277,19 +6521,14 @@ var createOperatorNode = /* @__PURE__ */ factory(
           }
         });
       }
-      let result;
+      let result = [];
       switch (args.length) {
         case 0:
           result = [];
           break;
         case 1:
           {
-            const operandPrecedence = getPrecedence(
-              args[0],
-              parenthesis,
-              implicit,
-              root
-            );
+            const operandPrecedence = getPrecedence(args[0], parenthesis, implicit, root);
             if (latex && operandPrecedence !== null) {
               let operandIdentifier;
               let rootIdentifier;
@@ -6695,6 +6934,27 @@ var createOperatorNode = /* @__PURE__ */ factory(
        * @param {Object} options
        * @return {string} str
        */
+      _toMathML() {
+        const fn = this.fn;
+        const args = this.args;
+        if (fn === "divide" && args.length === 2) {
+          return `<mfrac><mrow>${args[0].toMathML()}</mrow><mrow>${args[1].toMathML()}</mrow></mfrac>`;
+        }
+        if (fn === "pow" && args.length === 2) {
+          return `<msup><mrow>${args[0].toMathML()}</mrow><mrow>${args[1].toMathML()}</mrow></msup>`;
+        }
+        const child = (arg) => parenthesizeLower(arg.toMathML(), isOperatorNode(arg) ? arg.fn : void 0, fn);
+        if (args.length === 1) {
+          const op = this.op === "-" || this.op === "+" ? this.op : escapeMathML(this.op);
+          const operand = child(args[0]);
+          return getAssociativity(this, "keep") === "right" ? `<mrow><mo>${op}</mo>${operand}</mrow>` : `<mrow>${operand}<mo>${op}</mo></mrow>`;
+        }
+        if (args.length >= 2) {
+          const opMml = fn === "multiply" ? this.implicit ? "<mo>&#x2062;</mo>" : "<mo>&#x22C5;</mo>" : inlineOperator(fn, this.op);
+          return `<mrow>${args.map(child).join(opMml)}</mrow>`;
+        }
+        return `<mtext>${escapeMathML(this.toString())}</mtext>`;
+      }
       _toTex(options) {
         const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
         const implicit = options && options.implicit ? options.implicit : "hide";
@@ -6909,6 +7169,9 @@ var createParenthesisNode = /* @__PURE__ */ factory(
        * @return {string} str
        * @override
        */
+      _toMathML() {
+        return `<mrow><mo>(</mo>${this.content.toMathML()}<mo>)</mo></mrow>`;
+      }
       _toTex(options) {
         if (!options || options && !options.parenthesis || options && options.parenthesis === "keep") {
           return `\\left(${this.content.toTex(options)}\\right)`;
@@ -7364,6 +7627,18 @@ var createRelationalNode = /* @__PURE__ */ factory(
        * @param {Object} options
        * @return {string} str
        */
+      _toMathML() {
+        const params = this.params;
+        const conds = this.conditionals;
+        if (params.length >= 2 && conds.length === params.length - 1) {
+          let out = params[0].toMathML();
+          for (let i = 0; i < conds.length; i++) {
+            out += `${inlineOperator(conds[i], conds[i])}${params[i + 1].toMathML()}`;
+          }
+          return `<mrow>${out}</mrow>`;
+        }
+        return `<mtext>${escapeMathML(this.toString())}</mtext>`;
+      }
       _toTex(options) {
         const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
         const precedence = getPrecedence(
@@ -7441,7 +7716,7 @@ var createSymbolNode = /* @__PURE__ */ factory(
       _compile(math2, argNames) {
         const name21 = this.name;
         if (argNames[name21] === true) {
-          return function(scope, args, _context) {
+          return function(_scope, args, _context) {
             return getSafeProperty(args, name21);
           };
         } else if (name21 in math2) {
@@ -7543,6 +7818,9 @@ var createSymbolNode = /* @__PURE__ */ factory(
        * @return {string} str
        * @override
        */
+      _toMathML() {
+        return toMathMLSymbol(this.name);
+      }
       _toTex(_options) {
         let isUnit2 = false;
         if (typeof math[this.name] === "undefined" && isValuelessUnit(this.name)) {
@@ -7583,10 +7861,14 @@ export {
   createRangeNode,
   createRelationalNode,
   createSymbolNode,
+  escapeMathML,
   getAssociativity,
   getOperator,
   getPrecedence,
   isAssociativeWith,
   keywords,
-  properties
+  mathMLDocument,
+  mathMLError,
+  properties,
+  toMathMLSymbol
 };