@danielsimonjr/mathts-expression 0.7.1 → 0.8.1

package/dist/index.js

@@ -1065,7 +1065,7 @@ var createParse = /* @__PURE__ */ factory(
       );
     };
     parse.isWhitespace = function isWhitespace(c, nestingLevel) {
-      return c === " " || c === "	" || c === "\xA0" || c === "\n" && nestingLevel > 0;
+      return c === " " || c === "	" || c === "\xA0" || (c === "\n" || c === "\r") && nestingLevel > 0;
     };
     parse.isDecimalMark = function isDecimalMark(c, cNext) {
       return c === "." && cNext !== "/" && cNext !== "*" && cNext !== "^";
@@ -1113,7 +1113,6 @@ var createParse = /* @__PURE__ */ factory(
         } else {
           if (node && hasSeparators && !nodePushed) {
             blocks.push({ node, visible: state.token !== ";" });
-            nodePushed = true;
           }
           break;
         }
@@ -1373,7 +1372,6 @@ var createParse = /* @__PURE__ */ factory(
       let name47;
       let fn;
       node = parseImplicitMultiplication(state);
-      last2 = node;
       const operators = {
         "*": "multiply",
         ".*": "dotMultiply",
@@ -7958,15 +7956,15 @@ var createNode = /* @__PURE__ */ factory(
       }
       /**
        * Evaluate the node
-       * @param {Object} [scope]  Scope to read/write variables
-       * @return {*}              Returns the result
+       * @param scope - Optional. Scope to read/write variables
+       * @returns Returns the result
        */
       evaluate(scope) {
         return this.compile().evaluate(scope);
       }
       /**
        * Compile the node into an optimized, evauatable JavaScript function
-       * @return {{evaluate: function([Object])}} object
+       * @returns object
        *                Returns an object with a function 'evaluate',
        *                which can be invoked as expr.evaluate([scope: Object]),
        *                where scope is an optional object with
@@ -7989,13 +7987,13 @@ var createNode = /* @__PURE__ */ factory(
        * Compile a node into a JavaScript function.
        * This basically pre-calculates as much as possible and only leaves open
        * calculations which depend on a dynamic scope with variables.
-       * @param {Object} math     Math.js namespace with functions and constants.
-       * @param {Object} argNames An object with argument names as key and `true`
+       * @param _math - Math.js namespace with functions and constants.
+       * @param _argNames - An object with argument names as key and `true`
        *                          as value. Used in the SymbolNode to optimize
        *                          for arguments from user assigned functions
        *                          (see FunctionAssignmentNode) or special symbols
        *                          like `end` (see IndexNode).
-       * @return {function} Returns a function which can be called like:
+       * @returns Returns a function which can be called like:
        *                        evalNode(scope: Object, args: Object, context: *)
        */
       _compile(_math, _argNames) {
@@ -8003,7 +8001,7 @@ var createNode = /* @__PURE__ */ factory(
       }
       /**
        * Execute a callback for each of the child nodes of this node
-       * @param {function(child: Node, path: string, parent: Node)} callback
+       * @param _callback
        */
       forEach(_callback) {
         throw new Error("Cannot run forEach on a Node interface");
@@ -8011,16 +8009,16 @@ var createNode = /* @__PURE__ */ factory(
       /**
        * Create a new Node whose children are the results of calling the
        * provided callback function for each child of the original node.
-       * @param {function(child: Node, path: string, parent: Node): Node} callback
-       * @returns {OperatorNode} Returns a transformed copy of the node
+       * @param _callback
+       * @returns Returns a transformed copy of the node
        */
       map(_callback) {
         throw new Error("Cannot run map on a Node interface");
       }
       /**
        * Validate whether an object is a Node, for use with map
-       * @param {Node} node
-       * @returns {Node} Returns the input if it's a node, else throws an Error
+       * @param node
+       * @returns Returns the input if it's a node, else throws an Error
        * @protected
        */
       _ifNode(node) {
@@ -8032,7 +8030,7 @@ var createNode = /* @__PURE__ */ factory(
       /**
        * Recursively traverse all nodes in a node tree. Executes given callback for
        * this node and each of its child nodes.
-       * @param {function(node: Node, path: string, parent: Node)} callback
+       * @param callback
        *          A callback called for every node in the node tree.
        */
       traverse(callback) {
@@ -8060,12 +8058,12 @@ var createNode = /* @__PURE__ */ factory(
        *       }
        *     })
        *
-       * @param {function(node: Node, path: string, parent: Node) : Node} callback
+       * @param callback
        *          A mapping function accepting a node, and returning
        *          a replacement for the node or the original node. The "signature"
        *          of the callback must be:
        *          callback(node: Node, index: string, parent: Node) : Node
-       * @return {Node} Returns the original node or its replacement
+       * @returns Returns the original node or its replacement
        */
       transform(callback) {
         function _transform(child, path, parent) {
@@ -8085,11 +8083,11 @@ var createNode = /* @__PURE__ */ factory(
        *       return (node && node.isSymbolNode) && (node.name === 'x')
        *     })
        *
-       * @param {function(node: Node, path: string, parent: Node) : Node} callback
+       * @param callback
        *            A test function returning true when a node matches, and false
        *            otherwise. Function signature:
        *            callback(node: Node, index: string, parent: Node) : boolean
-       * @return {Node[]} nodes
+       * @returns nodes
        *            An array with nodes matching given filter criteria
        */
       filter(callback) {
@@ -8103,14 +8101,12 @@ var createNode = /* @__PURE__ */ factory(
       }
       /**
        * Create a shallow clone of this node
-       * @return {Node}
        */
       clone() {
         throw new Error("Cannot clone a Node interface");
       }
       /**
        * Create a deep clone of this node
-       * @return {Node}
        */
       cloneDeep() {
         return this.map(function(node) {
@@ -8119,8 +8115,8 @@ var createNode = /* @__PURE__ */ factory(
       }
       /**
        * Deep compare this node with another node.
-       * @param {Node} other
-       * @return {boolean} Returns true when both nodes are of the same type and
+       * @param other
+       * @returns Returns true when both nodes are of the same type and
        *                   contain the same values (as do their childs)
        */
       equals(other) {
@@ -8138,8 +8134,7 @@ var createNode = /* @__PURE__ */ factory(
        *    parenthesis: "keep" //the parenthesis option (This is optional)
        * }
        *
-       * @param {Object} [options]
-       * @return {string}
+       * @param options - Optional.
        */
       toString(options) {
         const customString = this._getCustomString(options);
@@ -8152,7 +8147,7 @@ var createNode = /* @__PURE__ */ factory(
        * Internal function to generate the string output.
        * This has to be implemented by every Node
        *
-       * @throws {Error}
+       * @throws Error
        */
       _toString(_options) {
         throw new Error("_toString not implemented for " + this.type);
@@ -8161,7 +8156,6 @@ var createNode = /* @__PURE__ */ factory(
        * Get a JSON representation of the node
        * Both .toJSON() and the static .fromJSON(json) should be implemented by all
        * implementations of Node
-       * @returns {Object}
        */
       toJSON() {
         throw new Error("Cannot serialize object: toJSON not implemented by " + this.type);
@@ -8178,8 +8172,7 @@ var createNode = /* @__PURE__ */ factory(
        *    parenthesis: "keep" //the parenthesis option (This is optional)
        * }
        *
-       * @param {Object} [options]
-       * @return {string}
+       * @param options - Optional.
        */
       toHTML(options) {
         const customString = this._getCustomString(options);
@@ -8192,7 +8185,7 @@ var createNode = /* @__PURE__ */ factory(
        * Internal function to generate the HTML output.
        * This has to be implemented by every Node
        *
-       * @throws {Error}
+       * @throws Error
        */
       _toHTML(_options) {
         throw new Error("_toHTML not implemented for " + this.type);
@@ -8209,8 +8202,7 @@ var createNode = /* @__PURE__ */ factory(
        *    parenthesis: "keep" //the parenthesis option (This is optional)
        * }
        *
-       * @param {Object} [options]
-       * @return {string}
+       * @param options - Optional.
        */
       toTex(options) {
         const customString = this._getCustomString(options);
@@ -8223,8 +8215,7 @@ var createNode = /* @__PURE__ */ factory(
        * Render this node as Markdown-embeddable math. Display (block) math by
        * default (`$$…$$`), inline (`$…$`) when `options.inline` is true. Thin
        * wrapper over toTex(); adds no failure mode beyond toTex's own.
-       * @param {Object} [options]
-       * @return {string}
+       * @param options - Optional.
        */
       toMarkdown(options) {
         const tex = this.toTex(options);
@@ -8234,8 +8225,7 @@ var createNode = /* @__PURE__ */ factory(
        * Render the AST subtree rooted at this node as a Graphviz digraph: one
        * DOT node per AST node (label = node type + a value for leaves), with
        * parent→child edges. Never throws.
-       * @param {Object} [options]
-       * @return {string}
+       * @param options - Optional.
        */
       toDOT(options) {
         const ids = /* @__PURE__ */ new Map();
@@ -8261,7 +8251,6 @@ ${nodes.concat(edges).join("\n")}
        * 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 {
@@ -8282,8 +8271,8 @@ ${nodes.concat(edges).join("\n")}
        * Internal function to generate the LaTeX output.
        * This has to be implemented by every Node
        *
-       * @param {Object} [options]
-       * @throws {Error}
+       * @param _options - Optional.
+       * @throws Error
        */
       _toTex(_options) {
         throw new Error("_toTex not implemented for " + this.type);
@@ -8307,14 +8296,13 @@ ${nodes.concat(edges).join("\n")}
       }
       /**
        * Get identifier.
-       * @return {string}
        */
       getIdentifier() {
         return this.type;
       }
       /**
        * Get the content of the current Node.
-       * @return {Node} node
+       * @returns node
        **/
       getContent() {
         return this;
@@ -8402,6 +8390,54 @@ function getStringSubset(str, index) {
   }
   return substr;
 }
+function setStringSubset(str, index, replacement, defaultValue) {
+  if (!index || index.isIndex !== true) {
+    throw new TypeError("Invalid index: must be an Index or Index-like object");
+  }
+  const idx = index;
+  if (isEmptyIndex(idx)) {
+    return str;
+  }
+  validateIndexSourceSize(Array.from(str), idx);
+  if (index.size().length !== 1) {
+    throw new DimensionError(index.size().length, 1);
+  }
+  if (defaultValue !== void 0) {
+    if (typeof defaultValue !== "string" || defaultValue.length !== 1) {
+      throw new TypeError("Single character expected as defaultValue");
+    }
+  } else {
+    defaultValue = " ";
+  }
+  const range = index.dimension(0);
+  const len = Number.isInteger(range) ? 1 : range.size()[0];
+  if (len !== replacement.length) {
+    throw new DimensionError(range.size()[0], replacement.length);
+  }
+  const strLen = str.length;
+  validateIndex(index.min()[0]);
+  validateIndex(index.max()[0]);
+  const chars = [];
+  for (let i = 0; i < strLen; i++) {
+    chars[i] = str.charAt(i);
+  }
+  function callback(v, i) {
+    chars[v] = replacement.charAt(i[0]);
+  }
+  if (Number.isInteger(range)) {
+    callback(range, [0]);
+  } else {
+    range.forEach(callback);
+  }
+  if (chars.length > strLen) {
+    for (let i = strLen - 1, len2 = chars.length; i < len2; i++) {
+      if (!chars[i]) {
+        chars[i] = defaultValue;
+      }
+    }
+  }
+  return chars.join("");
+}
 
 // src/node/utils/access.ts
 function accessFactory({ subset }) {
@@ -8451,10 +8487,10 @@ var createAccessorNode = /* @__PURE__ */ factory(
        * @extends {Node}
        * Access an object property or get a matrix subset
        *
-       * @param {Node} object                 The object from which to retrieve
+       * @param object - The object from which to retrieve
        *                                      a property or subset.
-       * @param {IndexNode} index             IndexNode containing ranges
-       * @param {boolean} [optionalChaining=false]
+       * @param index - IndexNode containing ranges
+       * @param optionalChaining - Default is `false`.
        *     Optional property, if the accessor was written as optional-chaining
        *     using `a?.b`, or `a?.["b"] with bracket notation.
        *     Forces evaluate to undefined if the given object is undefined or null.
@@ -8490,13 +8526,13 @@ var createAccessorNode = /* @__PURE__ */ factory(
        * Compile a node into a JavaScript function.
        * This basically pre-calculates as much as possible and only leaves open
        * calculations which depend on a dynamic scope with variables.
-       * @param {Object} math     Math.js namespace with functions and constants.
-       * @param {Object} argNames An object with argument names as key and `true`
+       * @param math - Math.js namespace with functions and constants.
+       * @param argNames - An object with argument names as key and `true`
        *                          as value. Used in the SymbolNode to optimize
        *                          for arguments from user assigned functions
        *                          (see FunctionAssignmentNode) or special symbols
        *                          like `end` (see IndexNode).
-       * @return {function} Returns a function which can be called like:
+       * @returns Returns a function which can be called like:
        *                        evalNode(scope: Object, args: Object, context: *)
        */
       _compile(math, argNames) {
@@ -8536,7 +8572,7 @@ var createAccessorNode = /* @__PURE__ */ factory(
       }
       /**
        * Execute a callback for each of the child nodes of this node
-       * @param {function(child: Node, path: string, parent: Node)} callback
+       * @param callback
        */
       forEach(callback) {
         callback(this.object, "object", this);
@@ -8545,8 +8581,8 @@ var createAccessorNode = /* @__PURE__ */ factory(
       /**
        * Create a new AccessorNode whose children are the results of calling
        * the provided callback function for each child of the original node.
-       * @param {function(child: Node, path: string, parent: Node): Node} callback
-       * @returns {AccessorNode} Returns a transformed copy of the node
+       * @param callback
+       * @returns Returns a transformed copy of the node
        */
       map(callback) {
         return new AccessorNode(
@@ -8557,15 +8593,13 @@ var createAccessorNode = /* @__PURE__ */ factory(
       }
       /**
        * Create a clone of this node, a shallow copy
-       * @return {AccessorNode}
        */
       clone() {
         return new AccessorNode(this.object, this.index, this.optionalChaining);
       }
       /**
        * Get string representation
-       * @param {Object} options
-       * @return {string}
+       * @param options
        */
       _toString(options) {
         let object = this.object.toString(options);
@@ -8577,8 +8611,7 @@ var createAccessorNode = /* @__PURE__ */ factory(
       }
       /**
        * Get HTML representation
-       * @param {Object} options
-       * @return {string}
+       * @param options
        */
       _toHTML(options) {
         let object = this.object.toHTML(options);
@@ -8589,8 +8622,7 @@ var createAccessorNode = /* @__PURE__ */ factory(
       }
       /**
        * Get LaTeX representation
-       * @param {Object} options
-       * @return {string}
+       * @param options
        */
       _toTex(options) {
         let object = this.object.toTex(options);
@@ -8601,7 +8633,6 @@ var createAccessorNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -8613,11 +8644,10 @@ var createAccessorNode = /* @__PURE__ */ factory(
       }
       /**
        * Instantiate an AccessorNode from its JSON representation
-       * @param {Object} json
+       * @param json
        *     An object structured like
        *     `{"mathjs": "AccessorNode", object: ..., index: ...}`,
        *     where mathjs is optional
-       * @returns {AccessorNode}
        */
       static fromJSON(json) {
         return new AccessorNode(json.object, json.index, json.optionalChaining);
@@ -8641,7 +8671,7 @@ var createArrayNode = /* @__PURE__ */ factory(
        * @constructor ArrayNode
        * @extends {Node}
        * Holds an 1-dimensional array with items
-       * @param {Node[]} [items]   1 dimensional array with items
+       * @param items - Optional. 1 dimensional array with items
        */
       constructor(items) {
         super();
@@ -8661,13 +8691,13 @@ var createArrayNode = /* @__PURE__ */ factory(
        * Compile a node into a JavaScript function.
        * This basically pre-calculates as much as possible and only leaves open
        * calculations which depend on a dynamic scope with variables.
-       * @param {Object} math     Math.js namespace with functions and constants.
-       * @param {Object} argNames An object with argument names as key and `true`
+       * @param math - Math.js namespace with functions and constants.
+       * @param argNames - An object with argument names as key and `true`
        *                          as value. Used in the SymbolNode to optimize
        *                          for arguments from user assigned functions
        *                          (see FunctionAssignmentNode) or special symbols
        *                          like `end` (see IndexNode).
-       * @return {function} Returns a function which can be called like:
+       * @returns Returns a function which can be called like:
        *                        evalNode(scope: Object, args: Object, context: *)
        */
       _compile(math, argNames) {
@@ -8694,7 +8724,7 @@ var createArrayNode = /* @__PURE__ */ factory(
       }
       /**
        * Execute a callback for each of the child nodes of this node
-       * @param {function(child: Node, path: string, parent: Node)} callback
+       * @param callback
        */
       forEach(callback) {
         for (let i = 0; i < this.items.length; i++) {
@@ -8705,8 +8735,8 @@ var createArrayNode = /* @__PURE__ */ factory(
       /**
        * Create a new ArrayNode whose children are the results of calling
        * the provided callback function for each child of the original node.
-       * @param {function(child: Node, path: string, parent: Node): Node} callback
-       * @returns {ArrayNode} Returns a transformed copy of the node
+       * @param callback
+       * @returns Returns a transformed copy of the node
        */
       map(callback) {
         const items = [];
@@ -8717,15 +8747,14 @@ var createArrayNode = /* @__PURE__ */ factory(
       }
       /**
        * Create a clone of this node, a shallow copy
-       * @return {ArrayNode}
        */
       clone() {
         return new ArrayNode(this.items.slice(0));
       }
       /**
        * Get string representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        * @override
        */
       _toString(options) {
@@ -8736,7 +8765,6 @@ var createArrayNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -8746,18 +8774,17 @@ var createArrayNode = /* @__PURE__ */ factory(
       }
       /**
        * Instantiate an ArrayNode from its JSON representation
-       * @param {Object} json  An object structured like
+       * @param json - An object structured like
        *                       `{"mathjs": "ArrayNode", items: [...]}`,
        *                       where mathjs is optional
-       * @returns {ArrayNode}
        */
       static fromJSON(json) {
         return new ArrayNode(json.items);
       }
       /**
        * Get HTML representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        * @override
        */
       _toHTML(options) {
@@ -8768,8 +8795,8 @@ var createArrayNode = /* @__PURE__ */ factory(
       }
       /**
        * Get LaTeX representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toTex(options) {
         function itemsToTex(items, nested) {
@@ -8807,7 +8834,7 @@ function assignFactory({ subset }) {
       } else if (object && typeof object.subset === "function") {
         return object.subset(index, value);
       } else if (typeof object === "string") {
-        return subset(object, index, value);
+        return setStringSubset(object, index, String(value));
       } else if (typeof object === "object") {
         if (!index.isObjectProperty()) {
           throw TypeError("Cannot apply a numeric index as object property");
@@ -8870,13 +8897,13 @@ var createAssignmentNode = /* @__PURE__ */ factory(
        *                       new IndexNode(1, 2),
        *                       new ConstantNode(3))  // a[1,2]=3
        *
-       * @param {SymbolNode | AccessorNode} object
+       * @param object
        *     Object on which to assign a value
-       * @param {IndexNode} [index=null]
+       * @param index - Default is `null`.
        *     Index, property name or matrix index. Optional. If not provided
        *     and `object` is a SymbolNode, the property is assigned to the
        *     global scope.
-       * @param {Node} value
+       * @param value
        *     The value to be assigned
        */
       constructor(object, index, value) {
@@ -8917,13 +8944,13 @@ var createAssignmentNode = /* @__PURE__ */ factory(
        * Compile a node into a JavaScript function.
        * This basically pre-calculates as much as possible and only leaves open
        * calculations which depend on a dynamic scope with variables.
-       * @param {Object} math     Math.js namespace with functions and constants.
-       * @param {Object} argNames An object with argument names as key and `true`
+       * @param math - Math.js namespace with functions and constants.
+       * @param argNames - An object with argument names as key and `true`
        *                          as value. Used in the SymbolNode to optimize
        *                          for arguments from user assigned functions
        *                          (see FunctionAssignmentNode) or special symbols
        *                          like `end` (see IndexNode).
-       * @return {function} Returns a function which can be called like:
+       * @returns Returns a function which can be called like:
        *                        evalNode(scope: Object, args: Object, context: *)
        */
       _compile(math, argNames) {
@@ -8985,7 +9012,7 @@ var createAssignmentNode = /* @__PURE__ */ factory(
       }
       /**
        * Execute a callback for each of the child nodes of this node
-       * @param {function(child: Node, path: string, parent: Node)} callback
+       * @param callback
        */
       forEach(callback) {
         callback(this.object, "object", this);
@@ -8997,8 +9024,8 @@ var createAssignmentNode = /* @__PURE__ */ factory(
       /**
        * Create a new AssignmentNode whose children are the results of calling
        * the provided callback function for each child of the original node.
-       * @param {function(child: Node, path: string, parent: Node): Node} callback
-       * @returns {AssignmentNode} Returns a transformed copy of the node
+       * @param callback
+       * @returns Returns a transformed copy of the node
        */
       map(callback) {
         const object = this._ifNode(callback(this.object, "object", this));
@@ -9008,15 +9035,13 @@ var createAssignmentNode = /* @__PURE__ */ factory(
       }
       /**
        * Create a clone of this node, a shallow copy
-       * @return {AssignmentNode}
        */
       clone() {
         return new AssignmentNode(this.object, this.index, this.value);
       }
       /**
        * Get string representation
-       * @param {Object} options
-       * @return {string}
+       * @param options
        */
       _toString(options) {
         const object = this.object.toString(options);
@@ -9029,7 +9054,6 @@ var createAssignmentNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -9041,19 +9065,17 @@ var createAssignmentNode = /* @__PURE__ */ factory(
       }
       /**
        * Instantiate an AssignmentNode from its JSON representation
-       * @param {Object} json
+       * @param json
        *     An object structured like
        *     `{"mathjs": "AssignmentNode", object: ..., index: ..., value: ...}`,
        *     where mathjs is optional
-       * @returns {AssignmentNode}
        */
       static fromJSON(json) {
         return new AssignmentNode(json.object, json.index, json.value);
       }
       /**
        * Get HTML representation
-       * @param {Object} options
-       * @return {string}
+       * @param options
        */
       _toHTML(options) {
         const object = this.object.toHTML(options);
@@ -9065,9 +9087,7 @@ var createAssignmentNode = /* @__PURE__ */ factory(
         return object + index + '<span class="math-operator math-assignment-operator math-variable-assignment-operator math-binary-operator">=</span>' + value;
       }
       /**
-       * Get LaTeX representation
-       * @param {Object} options
-       * @return {string}
+       * Get the MathML representation of this node.
        */
       _toMathML() {
         const obj = this.object;
@@ -9108,7 +9128,7 @@ var createBlockNode = /* @__PURE__ */ factory(
        * @constructor BlockNode
        * @extends {Node}
        * Holds a set with blocks
-       * @param {Array.<{node: Node} | {node: Node, visible: boolean}>} blocks
+       * @param blocks
        *            An array with blocks, where a block is constructed as an
        *            Object with properties block, which is a Node, and visible,
        *            which is a boolean. The property visible is optional and
@@ -9138,13 +9158,13 @@ var createBlockNode = /* @__PURE__ */ factory(
        * Compile a node into a JavaScript function.
        * This basically pre-calculates as much as possible and only leaves open
        * calculations which depend on a dynamic scope with variables.
-       * @param {Object} math     Math.js namespace with functions and constants.
-       * @param {Object} argNames An object with argument names as key and `true`
+       * @param math - Math.js namespace with functions and constants.
+       * @param argNames - An object with argument names as key and `true`
        *                          as value. Used in the SymbolNode to optimize
        *                          for arguments from user assigned functions
        *                          (see FunctionAssignmentNode) or special symbols
        *                          like `end` (see IndexNode).
-       * @return {function} Returns a function which can be called like:
+       * @returns Returns a function which can be called like:
        *                        evalNode(scope: Object, args: Object, context: *)
        */
       _compile(math, argNames) {
@@ -9167,7 +9187,7 @@ var createBlockNode = /* @__PURE__ */ factory(
       }
       /**
        * Execute a callback for each of the child blocks of this node
-       * @param {function(child: Node, path: string, parent: Node)} callback
+       * @param callback
        */
       forEach(callback) {
         for (let i = 0; i < this.blocks.length; i++) {
@@ -9177,8 +9197,8 @@ var createBlockNode = /* @__PURE__ */ factory(
       /**
        * Create a new BlockNode whose children are the results of calling
        * the provided callback function for each child of the original node.
-       * @param {function(child: Node, path: string, parent: Node): Node} callback
-       * @returns {BlockNode} Returns a transformed copy of the node
+       * @param callback
+       * @returns Returns a transformed copy of the node
        */
       map(callback) {
         const blocks = [];
@@ -9194,7 +9214,6 @@ var createBlockNode = /* @__PURE__ */ factory(
       }
       /**
        * Create a clone of this node, a shallow copy
-       * @return {BlockNode}
        */
       clone() {
         const blocks = this.blocks.map(function(block) {
@@ -9207,8 +9226,8 @@ var createBlockNode = /* @__PURE__ */ factory(
       }
       /**
        * Get string representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        * @override
        */
       _toString(options) {
@@ -9218,7 +9237,6 @@ var createBlockNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -9228,19 +9246,18 @@ var createBlockNode = /* @__PURE__ */ factory(
       }
       /**
        * Instantiate an BlockNode from its JSON representation
-       * @param {Object} json
+       * @param json
        *     An object structured like
        *     `{"mathjs": "BlockNode", blocks: [{node: ..., visible: false}, ...]}`,
        *     where mathjs is optional
-       * @returns {BlockNode}
        */
       static fromJSON(json) {
         return new BlockNode(json.blocks);
       }
       /**
        * Get HTML representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        * @override
        */
       _toHTML(options) {
@@ -9250,8 +9267,8 @@ var createBlockNode = /* @__PURE__ */ factory(
       }
       /**
        * Get LaTeX representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toTex(options) {
         return this.blocks.map(function(param) {
@@ -9298,9 +9315,9 @@ var createConditionalNode = /* @__PURE__ */ factory(
       /**
        * A lazy evaluating conditional operator: 'condition ? trueExpr : falseExpr'
        *
-       * @param {Node} condition   Condition, must result in a boolean
-       * @param {Node} trueExpr    Expression evaluated when condition is true
-       * @param {Node} falseExpr   Expression evaluated when condition is true
+       * @param condition - Condition, must result in a boolean
+       * @param trueExpr - Expression evaluated when condition is true
+       * @param falseExpr - Expression evaluated when condition is true
        *
        * @constructor ConditionalNode
        * @extends {Node}
@@ -9331,13 +9348,13 @@ var createConditionalNode = /* @__PURE__ */ factory(
        * Compile a node into a JavaScript function.
        * This basically pre-calculates as much as possible and only leaves open
        * calculations which depend on a dynamic scope with variables.
-       * @param {Object} math     Math.js namespace with functions and constants.
-       * @param {Object} argNames An object with argument names as key and `true`
+       * @param math - Math.js namespace with functions and constants.
+       * @param argNames - An object with argument names as key and `true`
        *                          as value. Used in the SymbolNode to optimize
        *                          for arguments from user assigned functions
        *                          (see FunctionAssignmentNode) or special symbols
        *                          like `end` (see IndexNode).
-       * @return {function} Returns a function which can be called like:
+       * @returns Returns a function which can be called like:
        *                        evalNode(scope: Object, args: Object, context: *)
        */
       _compile(math, argNames) {
@@ -9350,7 +9367,7 @@ var createConditionalNode = /* @__PURE__ */ factory(
       }
       /**
        * Execute a callback for each of the child nodes of this node
-       * @param {function(child: Node, path: string, parent: Node)} callback
+       * @param callback
        */
       forEach(callback) {
         callback(this.condition, "condition", this);
@@ -9360,8 +9377,8 @@ var createConditionalNode = /* @__PURE__ */ factory(
       /**
        * Create a new ConditionalNode whose children are the results of calling
        * the provided callback function for each child of the original node.
-       * @param {function(child: Node, path: string, parent: Node): Node} callback
-       * @returns {ConditionalNode} Returns a transformed copy of the node
+       * @param callback
+       * @returns Returns a transformed copy of the node
        */
       map(callback) {
         return new ConditionalNode(
@@ -9372,15 +9389,14 @@ var createConditionalNode = /* @__PURE__ */ factory(
       }
       /**
        * Create a clone of this node, a shallow copy
-       * @return {ConditionalNode}
        */
       clone() {
         return new ConditionalNode(this.condition, this.trueExpr, this.falseExpr);
       }
       /**
        * Get string representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toString(options) {
         const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
@@ -9424,7 +9440,6 @@ var createConditionalNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -9436,7 +9451,7 @@ var createConditionalNode = /* @__PURE__ */ factory(
       }
       /**
        * Instantiate an ConditionalNode from its JSON representation
-       * @param {Object} json
+       * @param json
        *     An object structured like
        *     ```
        *     {"mathjs": "ConditionalNode",
@@ -9445,15 +9460,14 @@ var createConditionalNode = /* @__PURE__ */ factory(
        *      "falseExpr": ...}
        *     ```
        *     where mathjs is optional
-       * @returns {ConditionalNode}
        */
       static fromJSON(json) {
         return new ConditionalNode(json.condition, json.trueExpr, json.falseExpr);
       }
       /**
        * Get HTML representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toHTML(options) {
         const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
@@ -9497,8 +9511,8 @@ var createConditionalNode = /* @__PURE__ */ factory(
       }
       /**
        * Get LaTeX representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _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}";
@@ -9864,7 +9878,7 @@ var createConstantNode = /* @__PURE__ */ factory(
        *     new ConstantNode(2.3)
        *     new ConstantNode('hello')
        *
-       * @param {*} value    Value can be any type (number, BigNumber, bigint, string, ...)
+       * @param value - Value can be any type (number, BigNumber, bigint, string, ...)
        * @constructor ConstantNode
        * @extends {Node}
        */
@@ -9883,13 +9897,13 @@ var createConstantNode = /* @__PURE__ */ factory(
        * Compile a node into a JavaScript function.
        * This basically pre-calculates as much as possible and only leaves open
        * calculations which depend on a dynamic scope with variables.
-       * @param {Object} math     Math.js namespace with functions and constants.
-       * @param {Object} argNames An object with argument names as key and `true`
+       * @param _math - Math.js namespace with functions and constants.
+       * @param _argNames - An object with argument names as key and `true`
        *                          as value. Used in the SymbolNode to optimize
        *                          for arguments from user assigned functions
        *                          (see FunctionAssignmentNode) or special symbols
        *                          like `end` (see IndexNode).
-       * @return {function} Returns a function which can be called like:
+       * @returns Returns a function which can be called like:
        *                        evalNode(scope: Object, args: Object, context: *)
        */
       _compile(_math, _argNames) {
@@ -9900,38 +9914,37 @@ var createConstantNode = /* @__PURE__ */ factory(
       }
       /**
        * Execute a callback for each of the child nodes of this node
-       * @param {function(child: Node, path: string, parent: Node)} callback
+       * @param _callback
        */
       forEach(_callback) {
       }
       /**
        * Create a new ConstantNode with children produced by the given callback.
        * Trivial because there are no children.
-       * @param {function(child: Node, path: string, parent: Node) : Node} callback
-       * @returns {ConstantNode} Returns a clone of the node
+       * @param _callback
+       * @returns Returns a clone of the node
        */
       map(_callback) {
         return this.clone();
       }
       /**
        * Create a clone of this node, a shallow copy
-       * @return {ConstantNode}
        */
       clone() {
         return new ConstantNode(this.value);
       }
       /**
        * Get string representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toString(options) {
         return formatGeneric(this.value, options);
       }
       /**
        * Get HTML representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toHTML(options) {
         const value = this._toString(options);
@@ -9955,25 +9968,22 @@ var createConstantNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return { mathjs: name11, value: this.value };
       }
       /**
        * Instantiate a ConstantNode from its JSON representation
-       * @param {Object} json  An object structured like
+       * @param json - An object structured like
        *                       `{"mathjs": "SymbolNode", value: 2.3}`,
        *                       where mathjs is optional
-       * @returns {ConstantNode}
        */
       static fromJSON(json) {
         return new ConstantNode(json.value);
       }
       /**
-       * Get LaTeX representation
-       * @param {Object} options
-       * @return {string} str
+       * Get the MathML representation of this node.
+       * @returns str
        */
       _toMathML() {
         return constantToMathML(this.value);
@@ -10035,12 +10045,12 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
        * @extends {Node}
        * Function assignment
        *
-       * @param {string} name           Function name
-       * @param {string[] | Array.<{name: string, type: string}>} params
+       * @param name - Function name
+       * @param params
        *                                Array with function parameter names, or an
        *                                array with objects containing the name
        *                                and type of the parameter
-       * @param {Node} expr             The function expression
+       * @param expr - The function expression
        */
       constructor(name47, params, expr) {
         super();
@@ -10087,13 +10097,13 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
        * Compile a node into a JavaScript function.
        * This basically pre-calculates as much as possible and only leaves open
        * calculations which depend on a dynamic scope with variables.
-       * @param {Object} math     Math.js namespace with functions and constants.
-       * @param {Object} argNames An object with argument names as key and `true`
+       * @param math - Math.js namespace with functions and constants.
+       * @param argNames - An object with argument names as key and `true`
        *                          as value. Used in the SymbolNode to optimize
        *                          for arguments from user assigned functions
        *                          (see FunctionAssignmentNode) or special symbols
        *                          like `end` (see IndexNode).
-       * @return {function} Returns a function which can be called like:
+       * @returns Returns a function which can be called like:
        *                        evalNode(scope: Object, args: Object, context: *)
        */
       _compile(math, argNames) {
@@ -10125,7 +10135,7 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
       }
       /**
        * Execute a callback for each of the child nodes of this node
-       * @param {function(child: Node, path: string, parent: Node)} callback
+       * @param callback
        */
       forEach(callback) {
         callback(this.expr, "expr", this);
@@ -10134,8 +10144,8 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
        * Create a new FunctionAssignmentNode whose children are the results of
        * calling the provided callback function for each child of the original
        * node.
-       * @param {function(child: Node, path: string, parent: Node): Node} callback
-       * @returns {FunctionAssignmentNode} Returns a transformed copy of the node
+       * @param callback
+       * @returns Returns a transformed copy of the node
        */
       map(callback) {
         const expr = this._ifNode(callback(this.expr, "expr", this));
@@ -10143,15 +10153,14 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
       }
       /**
        * Create a clone of this node, a shallow copy
-       * @return {FunctionAssignmentNode}
        */
       clone() {
         return new FunctionAssignmentNode(this.name, this.params.slice(0), this.expr);
       }
       /**
        * get string representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toString(options) {
         const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
@@ -10163,7 +10172,6 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         const types = this.types;
@@ -10181,22 +10189,21 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
       }
       /**
        * Instantiate an FunctionAssignmentNode from its JSON representation
-       * @param {Object} json
+       * @param json
        *     An object structured like
        *     ```
        *     {"mathjs": "FunctionAssignmentNode",
        *      name: ..., params: ..., expr: ...}
        *     ```
        *     where mathjs is optional
-       * @returns {FunctionAssignmentNode}
        */
       static fromJSON(json) {
         return new FunctionAssignmentNode(json.name, json.params, json.expr);
       }
       /**
        * get HTML representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toHTML(options) {
         const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
@@ -10214,8 +10221,8 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
       }
       /**
        * get LaTeX representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toTex(options) {
         const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
@@ -10300,7 +10307,7 @@ var createFunctionNode = /* @__PURE__ */ factory(
             }
           } else {
             const indexed = property[match[2]];
-            if (isNode(indexed && indexed)) {
+            if (isNode(indexed)) {
               latex += indexed.toTex(options);
             } else {
               throw new TypeError("Template: " + match[1] + "[" + match[2] + "] is not a Node.");
@@ -10319,10 +10326,10 @@ var createFunctionNode = /* @__PURE__ */ factory(
        * @constructor FunctionNode
        * @extends {./Node}
        * invoke a list with arguments on a node
-       * @param {./Node | string} fn
+       * @param fn
        *     Item resolving to a function on which to invoke
        *     the arguments, typically a SymbolNode or AccessorNode
-       * @param {./Node[]} args
+       * @param args
        */
       constructor(fn, args, optional) {
         super();
@@ -10356,13 +10363,13 @@ var createFunctionNode = /* @__PURE__ */ factory(
        * Compile a node into a JavaScript function.
        * This basically pre-calculates as much as possible and only leaves open
        * calculations which depend on a dynamic scope with variables.
-       * @param {Object} math     Math.js namespace with functions and constants.
-       * @param {Object} argNames An object with argument names as key and `true`
+       * @param math - Math.js namespace with functions and constants.
+       * @param argNames - An object with argument names as key and `true`
        *                          as value. Used in the SymbolNode to optimize
        *                          for arguments from user assigned functions
        *                          (see FunctionAssignmentNode) or special symbols
        *                          like `end` (see IndexNode).
-       * @return {function} Returns a function which can be called like:
+       * @returns Returns a function which can be called like:
        *                        evalNode(scope: Object, args: Object, context: *)
        */
       _compile(math2, argNames) {
@@ -10490,7 +10497,7 @@ var createFunctionNode = /* @__PURE__ */ factory(
       }
       /**
        * Execute a callback for each of the child nodes of this node
-       * @param {function(child: Node, path: string, parent: Node)} callback
+       * @param callback
        */
       forEach(callback) {
         callback(this.fn, "fn", this);
@@ -10501,8 +10508,8 @@ var createFunctionNode = /* @__PURE__ */ factory(
       /**
        * Create a new FunctionNode whose children are the results of calling
        * the provided callback function for each child of the original node.
-       * @param {function(child: Node, path: string, parent: Node): Node} callback
-       * @returns {FunctionNode} Returns a transformed copy of the node
+       * @param callback
+       * @returns Returns a transformed copy of the node
        */
       map(callback) {
         const fn = this._ifNode(callback(this.fn, "fn", this));
@@ -10514,14 +10521,13 @@ var createFunctionNode = /* @__PURE__ */ factory(
       }
       /**
        * Create a clone of this node, a shallow copy
-       * @return {FunctionNode}
        */
       clone() {
         return new FunctionNode(this.fn, this.args.slice(0));
       }
       /**
        * Throws an error 'Undefined function {name}'
-       * @param {string} name
+       * @param name
        */
       static onUndefinedFunction = function(name47) {
         throw new Error("Undefined function " + name47);
@@ -10534,8 +10540,8 @@ var createFunctionNode = /* @__PURE__ */ factory(
        * otherwise it falls back to calling Node's toString
        * function.
        *
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        * @override
        */
       toString(options) {
@@ -10551,8 +10557,8 @@ var createFunctionNode = /* @__PURE__ */ factory(
       }
       /**
        * Get string representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toString(options) {
         const args = this.args.map(function(arg) {
@@ -10563,7 +10569,6 @@ var createFunctionNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -10574,18 +10579,17 @@ var createFunctionNode = /* @__PURE__ */ factory(
       }
       /**
        * Instantiate an AssignmentNode from its JSON representation
-       * @param {Object} json  An object structured like
+       * @param json - An object structured like
        *                       `{"mathjs": "FunctionNode", fn: ..., args: ...}`,
        *                       where mathjs is optional
-       * @returns {FunctionNode}
        */
       static fromJSON = function(json) {
         return new FunctionNode(json.fn, json.args);
       };
       /**
        * Get HTML representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toHTML(options) {
         const args = this.args.map(function(arg) {
@@ -10601,8 +10605,7 @@ var createFunctionNode = /* @__PURE__ */ factory(
        * otherwise it falls back to calling Node's toTex
        * function.
        *
-       * @param {Object} options
-       * @return {string}
+       * @param options
        */
       toTex(options) {
         let customTex;
@@ -10615,9 +10618,8 @@ var createFunctionNode = /* @__PURE__ */ factory(
         return super.toTex(options);
       }
       /**
-       * Get LaTeX representation
-       * @param {Object} options
-       * @return {string} str
+       * Get the MathML representation of this node.
+       * @returns str
        */
       _toMathML() {
         const fnNode = this.fn;
@@ -10676,7 +10678,6 @@ var createFunctionNode = /* @__PURE__ */ factory(
       }
       /**
        * Get identifier.
-       * @return {string}
        */
       getIdentifier() {
         return this.type + ":" + this.name;
@@ -10705,8 +10706,8 @@ var createIndexNode = /* @__PURE__ */ factory(
        * Cannot be used on its own, needs to be used within an AccessorNode or
        * AssignmentNode.
        *
-       * @param {Node[]} dimensions
-       * @param {boolean} [dotNotation=false]
+       * @param dimensions
+       * @param dotNotation - Default is `false`.
        *     Optional property describing whether this index was written using dot
        *     notation like `a.b`, or using bracket notation like `a["b"]`
        *     (which is the default). This property is used for string conversion.
@@ -10733,13 +10734,13 @@ var createIndexNode = /* @__PURE__ */ factory(
        * Compile a node into a JavaScript function.
        * This basically pre-calculates as much as possible and only leaves open
        * calculations which depend on a dynamic scope with variables.
-       * @param {Object} math     Math.js namespace with functions and constants.
-       * @param {Object} argNames An object with argument names as key and `true`
+       * @param math - Math.js namespace with functions and constants.
+       * @param argNames - An object with argument names as key and `true`
        *                          as value. Used in the SymbolNode to optimize
        *                          for arguments from user assigned functions
        *                          (see FunctionAssignmentNode) or special symbols
        *                          like `end` (see IndexNode).
-       * @return {function} Returns a function which can be called like:
+       * @returns Returns a function which can be called like:
        *                        evalNode(scope: Object, args: Object, context: *)
        */
       // @ts-expect-error - method overrides property from Node base class
@@ -10781,7 +10782,7 @@ var createIndexNode = /* @__PURE__ */ factory(
       }
       /**
        * Execute a callback for each of the child nodes of this node
-       * @param {function(child: Node, path: string, parent: Node)} callback
+       * @param callback
        */
       forEach(callback) {
         for (let i = 0; i < this.dimensions.length; i++) {
@@ -10791,8 +10792,8 @@ var createIndexNode = /* @__PURE__ */ factory(
       /**
        * Create a new IndexNode whose children are the results of calling
        * the provided callback function for each child of the original node.
-       * @param {function(child: Node, path: string, parent: Node): Node} callback
-       * @returns {IndexNode} Returns a transformed copy of the node
+       * @param callback
+       * @returns Returns a transformed copy of the node
        */
       map(callback) {
         const dimensions = [];
@@ -10803,14 +10804,12 @@ var createIndexNode = /* @__PURE__ */ factory(
       }
       /**
        * Create a clone of this node, a shallow copy
-       * @return {IndexNode}
        */
       clone() {
         return new IndexNode(this.dimensions.slice(0), this.dotNotation);
       }
       /**
        * Test whether this IndexNode contains a single property name
-       * @return {boolean}
        */
       isObjectProperty() {
         return this.dimensions.length === 1 && isConstantNode(this.dimensions[0]) && typeof this.dimensions[0].value === "string";
@@ -10818,22 +10817,20 @@ var createIndexNode = /* @__PURE__ */ factory(
       /**
        * Returns the property name if IndexNode contains a property.
        * If not, returns null.
-       * @return {string | null}
        */
       getObjectProperty() {
         return this.isObjectProperty() ? this.dimensions[0].value : null;
       }
       /**
        * Get string representation
-       * @param {Object} options
-       * @return {string} str
+       * @param _options
+       * @returns str
        */
       _toString(_options) {
         return this.dotNotation ? "." + this.getObjectProperty() : "[" + this.dimensions.join(", ") + "]";
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -10844,19 +10841,18 @@ var createIndexNode = /* @__PURE__ */ factory(
       }
       /**
        * Instantiate an IndexNode from its JSON representation
-       * @param {Object} json
+       * @param json
        *     An object structured like
        *     `{"mathjs": "IndexNode", dimensions: [...], dotNotation: false}`,
        *     where mathjs is optional
-       * @returns {IndexNode}
        */
       static fromJSON(json) {
         return new IndexNode(json.dimensions, json.dotNotation);
       }
       /**
        * Get HTML representation
-       * @param {Object} options
-       * @return {string} str
+       * @param _options
+       * @returns str
        */
       _toHTML(_options) {
         const dimensions = [];
@@ -10871,8 +10867,8 @@ var createIndexNode = /* @__PURE__ */ factory(
       }
       /**
        * Get LaTeX representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toTex(options) {
         const dimensions = this.dimensions.map(function(range) {
@@ -10899,7 +10895,7 @@ var createObjectNode = /* @__PURE__ */ factory(
        * @constructor ObjectNode
        * @extends {Node}
        * Holds an object with keys/values
-       * @param {Object.<string, Node>} [properties]   object with key/value pairs
+       * @param properties - Optional. object with key/value pairs
        */
       constructor(properties2) {
         super();
@@ -10923,13 +10919,13 @@ var createObjectNode = /* @__PURE__ */ factory(
        * Compile a node into a JavaScript function.
        * This basically pre-calculates as much as possible and only leaves open
        * calculations which depend on a dynamic scope with variables.
-       * @param {Object} math     Math.js namespace with functions and constants.
-       * @param {Object} argNames An object with argument names as key and `true`
+       * @param math - Math.js namespace with functions and constants.
+       * @param argNames - An object with argument names as key and `true`
        *                          as value. Used in the SymbolNode to optimize
        *                          for arguments from user assigned functions
        *                          (see FunctionAssignmentNode) or special symbols
        *                          like `end` (see IndexNode).
-       * @return {function} Returns a function which can be called like:
+       * @returns Returns a function which can be called like:
        *                        evalNode(scope: Object, args: Object, context: *)
        */
       // @ts-expect-error - method overrides property from Node base class
@@ -10955,7 +10951,7 @@ var createObjectNode = /* @__PURE__ */ factory(
       }
       /**
        * Execute a callback for each of the child nodes of this node
-       * @param {function(child: Node, path: string, parent: Node)} callback
+       * @param callback
        */
       forEach(callback) {
         for (const key in this.properties) {
@@ -10967,8 +10963,8 @@ var createObjectNode = /* @__PURE__ */ factory(
       /**
        * Create a new ObjectNode whose children are the results of calling
        * the provided callback function for each child of the original node.
-       * @param {function(child: Node, path: string, parent: Node): Node} callback
-       * @returns {ObjectNode} Returns a transformed copy of the node
+       * @param callback
+       * @returns Returns a transformed copy of the node
        */
       map(callback) {
         const properties2 = {};
@@ -10983,7 +10979,6 @@ var createObjectNode = /* @__PURE__ */ factory(
       }
       /**
        * Create a clone of this node, a shallow copy
-       * @return {ObjectNode}
        */
       clone() {
         const properties2 = {};
@@ -10996,8 +10991,8 @@ var createObjectNode = /* @__PURE__ */ factory(
       }
       /**
        * Get string representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        * @override
        */
       _toString(options) {
@@ -11011,7 +11006,6 @@ var createObjectNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -11021,18 +11015,17 @@ var createObjectNode = /* @__PURE__ */ factory(
       }
       /**
        * Instantiate an OperatorNode from its JSON representation
-       * @param {Object} json  An object structured like
+       * @param json - An object structured like
        *                       `{"mathjs": "ObjectNode", "properties": {...}}`,
        *                       where mathjs is optional
-       * @returns {ObjectNode}
        */
       static fromJSON(json) {
         return new ObjectNode(json.properties);
       }
       /**
        * Get HTML representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        * @override
        */
       _toHTML(options) {
@@ -11048,8 +11041,8 @@ var createObjectNode = /* @__PURE__ */ factory(
       }
       /**
        * Get LaTeX representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toTex(options) {
         const entries = [];
@@ -11239,11 +11232,11 @@ var createOperatorNode = /* @__PURE__ */ factory(
        * @extends {Node}
        * An operator with two arguments, like 2+3
        *
-       * @param {string} op           Operator name, for example '+'
-       * @param {string} fn           Function name, for example 'add'
-       * @param {Node[]} args         Operator arguments
-       * @param {boolean} [implicit]  Is this an implicit multiplication?
-       * @param {boolean} [isPercentage] Is this an percentage Operation?
+       * @param op - Operator name, for example '+'
+       * @param fn - Function name, for example 'add'
+       * @param args - Operator arguments
+       * @param implicit - Optional. Is this an implicit multiplication?
+       * @param isPercentage - Optional. Is this an percentage Operation?
        */
       constructor(op, fn, args, implicit, isPercentage) {
         super();
@@ -11273,13 +11266,13 @@ var createOperatorNode = /* @__PURE__ */ factory(
        * Compile a node into a JavaScript function.
        * This basically pre-calculates as much as possible and only leaves open
        * calculations which depend on a dynamic scope with variables.
-       * @param {Object} math     Math.js namespace with functions and constants.
-       * @param {Object} argNames An object with argument names as key and `true`
+       * @param math - Math.js namespace with functions and constants.
+       * @param argNames - An object with argument names as key and `true`
        *                          as value. Used in the SymbolNode to optimize
        *                          for arguments from user assigned functions
        *                          (see FunctionAssignmentNode) or special symbols
        *                          like `end` (see IndexNode).
-       * @return {function} Returns a function which can be called like:
+       * @returns Returns a function which can be called like:
        *                        evalNode(scope: Object, args: Object, context: *)
        */
       // @ts-expect-error - method overrides property from Node base class
@@ -11323,7 +11316,7 @@ var createOperatorNode = /* @__PURE__ */ factory(
       }
       /**
        * Execute a callback for each of the child nodes of this node
-       * @param {function(child: Node, path: string, parent: Node)} callback
+       * @param callback
        */
       forEach(callback) {
         for (let i = 0; i < this.args.length; i++) {
@@ -11333,8 +11326,8 @@ var createOperatorNode = /* @__PURE__ */ factory(
       /**
        * Create a new OperatorNode whose children are the results of calling
        * the provided callback function for each child of the original node.
-       * @param {function(child: Node, path: string, parent: Node): Node} callback
-       * @returns {OperatorNode} Returns a transformed copy of the node
+       * @param callback
+       * @returns Returns a transformed copy of the node
        */
       map(callback) {
         const args = [];
@@ -11345,7 +11338,6 @@ var createOperatorNode = /* @__PURE__ */ factory(
       }
       /**
        * Create a clone of this node, a shallow copy
-       * @return {OperatorNode}
        */
       clone() {
         return new OperatorNode(
@@ -11359,8 +11351,7 @@ var createOperatorNode = /* @__PURE__ */ factory(
       /**
        * Check whether this is an unary OperatorNode:
        * has exactly one argument, like `-a`.
-       * @return {boolean}
-       *     Returns true when an unary operator node, false otherwise.
+       * @returns `true` when an unary operator node, `false` otherwise.
        */
       isUnary() {
         return this.args.length === 1;
@@ -11368,16 +11359,15 @@ var createOperatorNode = /* @__PURE__ */ factory(
       /**
        * Check whether this is a binary OperatorNode:
        * has exactly two arguments, like `a + b`.
-       * @return {boolean}
-       *     Returns true when a binary operator node, false otherwise.
+       * @returns `true` when a binary operator node, `false` otherwise.
        */
       isBinary() {
         return this.args.length === 2;
       }
       /**
        * Get string representation.
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toString(options) {
         const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
@@ -11428,7 +11418,6 @@ var createOperatorNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -11442,7 +11431,7 @@ var createOperatorNode = /* @__PURE__ */ factory(
       }
       /**
        * Instantiate an OperatorNode from its JSON representation
-       * @param {Object} json
+       * @param json
        *     An object structured like
        *     ```
        *     {"mathjs": "OperatorNode",
@@ -11451,15 +11440,14 @@ var createOperatorNode = /* @__PURE__ */ factory(
        *      "isPercentage":false}
        *     ```
        *     where mathjs is optional
-       * @returns {OperatorNode}
        */
       static fromJSON(json) {
         return new OperatorNode(json.op, json.fn, json.args, json.implicit, json.isPercentage);
       }
       /**
        * Get HTML representation.
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toHTML(options) {
         const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
@@ -11513,9 +11501,8 @@ var createOperatorNode = /* @__PURE__ */ factory(
         }
       }
       /**
-       * Get LaTeX representation
-       * @param {Object} options
-       * @return {string} str
+       * Get the MathML representation of this node.
+       * @returns str
        */
       _toMathML() {
         const fn = this.fn;
@@ -11526,7 +11513,11 @@ var createOperatorNode = /* @__PURE__ */ factory(
         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);
+        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]);
@@ -11613,7 +11604,6 @@ var createOperatorNode = /* @__PURE__ */ factory(
       }
       /**
        * Get identifier.
-       * @return {string}
        */
       // @ts-expect-error - method overrides property from Node base class
       getIdentifier() {
@@ -11638,7 +11628,7 @@ var createParenthesisNode = /* @__PURE__ */ factory(
        * @constructor ParenthesisNode
        * @extends {Node}
        * A parenthesis node describes manual parenthesis from the user input
-       * @param {Node} content
+       * @param content
        * @extends {Node}
        */
       constructor(content) {
@@ -11659,13 +11649,13 @@ var createParenthesisNode = /* @__PURE__ */ factory(
        * Compile a node into a JavaScript function.
        * This basically pre-calculates as much as possible and only leaves open
        * calculations which depend on a dynamic scope with variables.
-       * @param {Object} math     Math.js namespace with functions and constants.
-       * @param {Object} argNames An object with argument names as key and `true`
+       * @param math - Math.js namespace with functions and constants.
+       * @param argNames - An object with argument names as key and `true`
        *                          as value. Used in the SymbolNode to optimize
        *                          for arguments from user assigned functions
        *                          (see FunctionAssignmentNode) or special symbols
        *                          like `end` (see IndexNode).
-       * @return {function} Returns a function which can be called like:
+       * @returns Returns a function which can be called like:
        *                        evalNode(scope: Object, args: Object, context: *)
        */
       // @ts-expect-error - method overrides property from Node base class
@@ -11674,7 +11664,7 @@ var createParenthesisNode = /* @__PURE__ */ factory(
       }
       /**
        * Get the content of the current Node.
-       * @return {Node} content
+       * @returns content
        * @override
        **/
       // @ts-expect-error - method overrides property from Node base class
@@ -11683,7 +11673,7 @@ var createParenthesisNode = /* @__PURE__ */ factory(
       }
       /**
        * Execute a callback for each of the child nodes of this node
-       * @param {function(child: Node, path: string, parent: Node)} callback
+       * @param callback
        */
       forEach(callback) {
         callback(this.content, "content", this);
@@ -11691,8 +11681,8 @@ var createParenthesisNode = /* @__PURE__ */ factory(
       /**
        * Create a new ParenthesisNode whose child is the result of calling
        * the provided callback function on the child of this node.
-       * @param {function(child: Node, path: string, parent: Node) : Node} callback
-       * @returns {ParenthesisNode} Returns a clone of the node
+       * @param callback
+       * @returns Returns a clone of the node
        */
       map(callback) {
         const content = callback(this.content, "content", this);
@@ -11700,15 +11690,14 @@ var createParenthesisNode = /* @__PURE__ */ factory(
       }
       /**
        * Create a clone of this node, a shallow copy
-       * @return {ParenthesisNode}
        */
       clone() {
         return new ParenthesisNode(this.content);
       }
       /**
        * Get string representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        * @override
        */
       _toString(options) {
@@ -11719,25 +11708,23 @@ var createParenthesisNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return { mathjs: name17, content: this.content };
       }
       /**
        * Instantiate an ParenthesisNode from its JSON representation
-       * @param {Object} json  An object structured like
+       * @param json - An object structured like
        *                       `{"mathjs": "ParenthesisNode", "content": ...}`,
        *                       where mathjs is optional
-       * @returns {ParenthesisNode}
        */
       static fromJSON(json) {
         return new ParenthesisNode(json.content);
       }
       /**
        * Get HTML representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        * @override
        */
       _toHTML(options) {
@@ -11747,9 +11734,8 @@ var createParenthesisNode = /* @__PURE__ */ factory(
         return this.content.toHTML(options);
       }
       /**
-       * Get LaTeX representation
-       * @param {Object} options
-       * @return {string} str
+       * Get the MathML representation of this node.
+       * @returns str
        * @override
        */
       _toMathML() {
@@ -11795,9 +11781,9 @@ var createRangeNode = /* @__PURE__ */ factory(
        * @constructor RangeNode
        * @extends {Node}
        * create a range
-       * @param {Node} start  included lower-bound
-       * @param {Node} end    included upper-bound
-       * @param {Node} [step] optional step
+       * @param start - included lower-bound
+       * @param end - included upper-bound
+       * @param step - optional step
        */
       constructor(start, end, step) {
         super();
@@ -11819,7 +11805,6 @@ var createRangeNode = /* @__PURE__ */ factory(
       /**
        * Check whether the RangeNode needs the `end` symbol to be defined.
        * This end is the size of the Matrix in current dimension.
-       * @return {boolean}
        */
       needsEnd() {
         const endSymbols = this.filter(function(node) {
@@ -11831,13 +11816,13 @@ var createRangeNode = /* @__PURE__ */ factory(
        * Compile a node into a JavaScript function.
        * This basically pre-calculates as much as possible and only leaves open
        * calculations which depend on a dynamic scope with variables.
-       * @param {Object} math     Math.js namespace with functions and constants.
-       * @param {Object} argNames An object with argument names as key and `true`
+       * @param math - Math.js namespace with functions and constants.
+       * @param argNames - An object with argument names as key and `true`
        *                          as value. Used in the SymbolNode to optimize
        *                          for arguments from user assigned functions
        *                          (see FunctionAssignmentNode) or special symbols
        *                          like `end` (see IndexNode).
-       * @return {function} Returns a function which can be called like:
+       * @returns Returns a function which can be called like:
        *                        evalNode(scope: Object, args: Object, context: *)
        */
       // @ts-expect-error - method overrides property from Node base class
@@ -11862,7 +11847,7 @@ var createRangeNode = /* @__PURE__ */ factory(
       }
       /**
        * Execute a callback for each of the child nodes of this node
-       * @param {function(child: Node, path: string, parent: Node)} callback
+       * @param callback
        */
       forEach(callback) {
         callback(this.start, "start", this);
@@ -11874,8 +11859,8 @@ var createRangeNode = /* @__PURE__ */ factory(
       /**
        * Create a new RangeNode whose children are the results of calling
        * the provided callback function for each child of the original node.
-       * @param {function(child: Node, path: string, parent: Node): Node} callback
-       * @returns {RangeNode} Returns a transformed copy of the node
+       * @param callback
+       * @returns Returns a transformed copy of the node
        */
       map(callback) {
         return new RangeNode(
@@ -11886,15 +11871,14 @@ var createRangeNode = /* @__PURE__ */ factory(
       }
       /**
        * Create a clone of this node, a shallow copy
-       * @return {RangeNode}
        */
       clone() {
         return new RangeNode(this.start, this.end, this.step || void 0);
       }
       /**
        * Get string representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toString(options) {
         const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
@@ -11925,7 +11909,6 @@ var createRangeNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -11937,19 +11920,18 @@ var createRangeNode = /* @__PURE__ */ factory(
       }
       /**
        * Instantiate an RangeNode from its JSON representation
-       * @param {Object} json
+       * @param json
        *     An object structured like
        *     `{"mathjs": "RangeNode", "start": ..., "end": ..., "step": ...}`,
        *     where mathjs is optional
-       * @returns {RangeNode}
        */
       static fromJSON(json) {
         return new RangeNode(json.start, json.end, json.step);
       }
       /**
        * Get HTML representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toHTML(options) {
         const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
@@ -11981,7 +11963,7 @@ var createRangeNode = /* @__PURE__ */ factory(
       /**
        * Get LaTeX representation
        * @params {Object} options
-       * @return {string} str
+       * @returns str
        */
       _toTex(options) {
         const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
@@ -12035,9 +12017,9 @@ var createRelationalNode = /* @__PURE__ */ factory(
       /**
        * A node representing a chained conditional expression, such as 'x > y > z'
        *
-       * @param {String[]} conditionals
+       * @param conditionals
        *     An array of conditional operators used to compare the parameters
-       * @param {Node[]} params
+       * @param params
        *     The parameters that will be compared
        *
        * @constructor RelationalNode
@@ -12070,13 +12052,13 @@ var createRelationalNode = /* @__PURE__ */ factory(
        * Compile a node into a JavaScript function.
        * This basically pre-calculates as much as possible and only leaves open
        * calculations which depend on a dynamic scope with variables.
-       * @param {Object} math     Math.js namespace with functions and constants.
-       * @param {Object} argNames An object with argument names as key and `true`
+       * @param math - Math.js namespace with functions and constants.
+       * @param argNames - An object with argument names as key and `true`
        *                          as value. Used in the SymbolNode to optimize
        *                          for arguments from user assigned functions
        *                          (see FunctionAssignmentNode) or special symbols
        *                          like `end` (see IndexNode).
-       * @return {function} Returns a function which can be called like:
+       * @returns Returns a function which can be called like:
        *                        evalNode(scope: Object, args: Object, context: *)
        */
       // @ts-expect-error - method overrides property from Node base class
@@ -12099,7 +12081,7 @@ var createRelationalNode = /* @__PURE__ */ factory(
       }
       /**
        * Execute a callback for each of the child nodes of this node
-       * @param {function(child: Node, path: string, parent: Node)} callback
+       * @param callback
        */
       forEach(callback) {
         this.params.forEach((n, i) => callback(n, "params[" + i + "]", this), this);
@@ -12107,8 +12089,8 @@ var createRelationalNode = /* @__PURE__ */ factory(
       /**
        * Create a new RelationalNode whose children are the results of calling
        * the provided callback function for each child of the original node.
-       * @param {function(child: Node, path: string, parent: Node): Node} callback
-       * @returns {RelationalNode} Returns a transformed copy of the node
+       * @param callback
+       * @returns Returns a transformed copy of the node
        */
       map(callback) {
         return new RelationalNode(
@@ -12121,15 +12103,14 @@ var createRelationalNode = /* @__PURE__ */ factory(
       }
       /**
        * Create a clone of this node, a shallow copy
-       * @return {RelationalNode}
        */
       clone() {
         return new RelationalNode(this.conditionals, this.params);
       }
       /**
        * Get string representation.
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toString(options) {
         const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
@@ -12157,7 +12138,6 @@ var createRelationalNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -12168,19 +12148,18 @@ var createRelationalNode = /* @__PURE__ */ factory(
       }
       /**
        * Instantiate a RelationalNode from its JSON representation
-       * @param {Object} json
+       * @param json
        *     An object structured like
        *     `{"mathjs": "RelationalNode", "conditionals": ..., "params": ...}`,
        *     where mathjs is optional
-       * @returns {RelationalNode}
        */
       static fromJSON(json) {
         return new RelationalNode(json.conditionals, json.params);
       }
       /**
        * Get HTML representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toHTML(options) {
         const parenthesis = options && options.parenthesis ? options.parenthesis : "keep";
@@ -12206,9 +12185,8 @@ var createRelationalNode = /* @__PURE__ */ factory(
         return ret;
       }
       /**
-       * Get LaTeX representation
-       * @param {Object} options
-       * @return {string} str
+       * Get the MathML representation of this node.
+       * @returns str
        */
       _toMathML() {
         const params = this.params;
@@ -12267,7 +12245,7 @@ var createSymbolNode = /* @__PURE__ */ factory(
        * @constructor SymbolNode
        * @extends {Node}
        * A symbol node can hold and resolve a symbol
-       * @param {string} name
+       * @param name
        * @extends {Node}
        */
       constructor(name47) {
@@ -12287,13 +12265,13 @@ var createSymbolNode = /* @__PURE__ */ factory(
        * Compile a node into a JavaScript function.
        * This basically pre-calculates as much as possible and only leaves open
        * calculations which depend on a dynamic scope with variables.
-       * @param {Object} math     Math.js namespace with functions and constants.
-       * @param {Object} argNames An object with argument names as key and `true`
+       * @param math - Math.js namespace with functions and constants.
+       * @param argNames - An object with argument names as key and `true`
        *                          as value. Used in the SymbolNode to optimize
        *                          for arguments from user assigned functions
        *                          (see FunctionAssignmentNode) or special symbols
        *                          like `end` (see IndexNode).
-       * @return {function} Returns a function which can be called like:
+       * @returns Returns a function which can be called like:
        *                        evalNode(scope: Object, args: Object, context: *)
        */
       _compile(math2, argNames) {
@@ -12315,29 +12293,28 @@ var createSymbolNode = /* @__PURE__ */ factory(
       }
       /**
        * Execute a callback for each of the child nodes of this node
-       * @param {function(child: Node, path: string, parent: Node)} callback
+       * @param _callback
        */
       forEach(_callback) {
       }
       /**
        * Create a new SymbolNode with children produced by the given callback.
        * Trivial since a SymbolNode has no children
-       * @param {function(child: Node, path: string, parent: Node) : Node} callback
-       * @returns {SymbolNode} Returns a clone of the node
+       * @param _callback
+       * @returns Returns a clone of the node
        */
       map(_callback) {
         return this.clone();
       }
       /**
        * Throws an error 'Undefined symbol {name}'
-       * @param {string} name
+       * @param name
        */
       static onUndefinedSymbol(name47) {
         throw new Error("Undefined symbol " + name47);
       }
       /**
        * Create a clone of this node, a shallow copy
-       * @return {SymbolNode}
        */
       // @ts-expect-error - method overrides property from Node base class
       clone() {
@@ -12345,8 +12322,8 @@ var createSymbolNode = /* @__PURE__ */ factory(
       }
       /**
        * Get string representation
-       * @param {Object} options
-       * @return {string} str
+       * @param _options
+       * @returns str
        * @override
        */
       _toString(_options) {
@@ -12354,8 +12331,8 @@ var createSymbolNode = /* @__PURE__ */ factory(
       }
       /**
        * Get HTML representation
-       * @param {Object} options
-       * @return {string} str
+       * @param _options
+       * @returns str
        * @override
        */
       _toHTML(_options) {
@@ -12377,7 +12354,6 @@ var createSymbolNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -12387,18 +12363,16 @@ var createSymbolNode = /* @__PURE__ */ factory(
       }
       /**
        * Instantiate a SymbolNode from its JSON representation
-       * @param {Object} json  An object structured like
+       * @param json - An object structured like
        *                       `{"mathjs": "SymbolNode", name: "x"}`,
        *                       where mathjs is optional
-       * @returns {SymbolNode}
        */
       static fromJSON(json) {
         return new SymbolNode(json.name);
       }
       /**
-       * Get LaTeX representation
-       * @param {Object} options
-       * @return {string} str
+       * Get the MathML representation of this node.
+       * @returns str
        * @override
        */
       _toMathML() {