@danielsimonjr/mathts-expression 0.8.0 → 0.8.2

package/dist/index.js

@@ -7956,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
@@ -7987,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) {
@@ -8001,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");
@@ -8009,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) {
@@ -8030,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) {
@@ -8058,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) {
@@ -8083,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) {
@@ -8101,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) {
@@ -8117,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) {
@@ -8136,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);
@@ -8150,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);
@@ -8159,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);
@@ -8176,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);
@@ -8190,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);
@@ -8207,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);
@@ -8221,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);
@@ -8232,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();
@@ -8259,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 {
@@ -8280,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);
@@ -8305,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;
@@ -8497,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.
@@ -8536,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) {
@@ -8582,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);
@@ -8591,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(
@@ -8603,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);
@@ -8623,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);
@@ -8635,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);
@@ -8647,7 +8633,6 @@ var createAccessorNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -8659,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);
@@ -8687,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();
@@ -8707,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) {
@@ -8740,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++) {
@@ -8751,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 = [];
@@ -8763,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) {
@@ -8782,7 +8765,6 @@ var createArrayNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -8792,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) {
@@ -8814,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) {
@@ -8916,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) {
@@ -8963,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) {
@@ -9031,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);
@@ -9043,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));
@@ -9054,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);
@@ -9075,7 +9054,6 @@ var createAssignmentNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -9087,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);
@@ -9111,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;
@@ -9154,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
@@ -9184,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) {
@@ -9213,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++) {
@@ -9223,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 = [];
@@ -9240,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) {
@@ -9253,8 +9226,8 @@ var createBlockNode = /* @__PURE__ */ factory(
       }
       /**
        * Get string representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        * @override
        */
       _toString(options) {
@@ -9264,7 +9237,6 @@ var createBlockNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -9274,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) {
@@ -9296,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) {
@@ -9344,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}
@@ -9377,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) {
@@ -9396,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);
@@ -9406,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(
@@ -9418,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";
@@ -9470,7 +9440,6 @@ var createConditionalNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -9482,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",
@@ -9491,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";
@@ -9543,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}";
@@ -9910,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}
        */
@@ -9929,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) {
@@ -9946,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);
@@ -10001,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);
@@ -10081,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();
@@ -10133,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) {
@@ -10171,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);
@@ -10180,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));
@@ -10189,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";
@@ -10209,7 +10172,6 @@ var createFunctionAssignmentNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         const types = this.types;
@@ -10227,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";
@@ -10260,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";
@@ -10365,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();
@@ -10402,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) {
@@ -10536,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);
@@ -10547,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));
@@ -10560,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);
@@ -10580,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) {
@@ -10597,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) {
@@ -10609,7 +10569,6 @@ var createFunctionNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -10620,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) {
@@ -10647,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;
@@ -10661,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;
@@ -10722,7 +10678,6 @@ var createFunctionNode = /* @__PURE__ */ factory(
       }
       /**
        * Get identifier.
-       * @return {string}
        */
       getIdentifier() {
         return this.type + ":" + this.name;
@@ -10751,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.
@@ -10779,21 +10734,20 @@ 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
       _compile(math, argNames) {
         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) => isSymbolNode(node) && node.name === "end").length > 0;
             if (needsEnd) {
               const childArgNames = Object.create(argNames);
               childArgNames.end = true;
@@ -10827,7 +10781,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++) {
@@ -10837,8 +10791,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 = [];
@@ -10849,14 +10803,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";
@@ -10864,22 +10816,21 @@ 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;
+        const first = this.dimensions[0];
+        return this.isObjectProperty() && isConstantNode(first) ? first.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 {
@@ -10890,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 = [];
@@ -10917,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) {
@@ -10945,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();
@@ -10969,16 +10919,15 @@ 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
       _compile(math, argNames) {
         const evalEntries = {};
         for (const key in this.properties) {
@@ -11001,7 +10950,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) {
@@ -11013,8 +10962,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 = {};
@@ -11029,7 +10978,6 @@ var createObjectNode = /* @__PURE__ */ factory(
       }
       /**
        * Create a clone of this node, a shallow copy
-       * @return {ObjectNode}
        */
       clone() {
         const properties2 = {};
@@ -11042,8 +10990,8 @@ var createObjectNode = /* @__PURE__ */ factory(
       }
       /**
        * Get string representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        * @override
        */
       _toString(options) {
@@ -11057,7 +11005,6 @@ var createObjectNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -11067,18 +11014,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) {
@@ -11094,8 +11040,8 @@ var createObjectNode = /* @__PURE__ */ factory(
       }
       /**
        * Get LaTeX representation
-       * @param {Object} options
-       * @return {string} str
+       * @param options
+       * @returns str
        */
       _toTex(options) {
         const entries = [];
@@ -11130,7 +11076,10 @@ var createOperatorNode = /* @__PURE__ */ factory(
       }
       if (isConstantNode(curNode)) return true;
       if (isOperatorNode(curNode)) {
-        return startsWithConstant(curNode.args[0], parenthesis);
+        return startsWithConstant(
+          curNode.args[0],
+          parenthesis
+        );
       }
       return false;
     }
@@ -11285,11 +11234,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();
@@ -11319,16 +11268,15 @@ 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
       _compile(math, argNames) {
         if (typeof this.fn !== "string" || !isSafeMethod(math, this.fn)) {
           if (!math[this.fn]) {
@@ -11369,7 +11317,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++) {
@@ -11379,8 +11327,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 = [];
@@ -11391,7 +11339,6 @@ var createOperatorNode = /* @__PURE__ */ factory(
       }
       /**
        * Create a clone of this node, a shallow copy
-       * @return {OperatorNode}
        */
       clone() {
         return new OperatorNode(
@@ -11405,8 +11352,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;
@@ -11414,16 +11360,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";
@@ -11474,7 +11419,6 @@ var createOperatorNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -11488,7 +11432,7 @@ var createOperatorNode = /* @__PURE__ */ factory(
       }
       /**
        * Instantiate an OperatorNode from its JSON representation
-       * @param {Object} json
+       * @param json
        *     An object structured like
        *     ```
        *     {"mathjs": "OperatorNode",
@@ -11497,15 +11441,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";
@@ -11559,9 +11502,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;
@@ -11572,7 +11514,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]);
@@ -11659,9 +11605,7 @@ var createOperatorNode = /* @__PURE__ */ factory(
       }
       /**
        * Get identifier.
-       * @return {string}
        */
-      // @ts-expect-error - method overrides property from Node base class
       getIdentifier() {
         return this.type + ":" + this.fn;
       }
@@ -11684,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) {
@@ -11705,31 +11649,29 @@ 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
       _compile(math, argNames) {
         return this.content._compile(math, argNames);
       }
       /**
        * Get the content of the current Node.
-       * @return {Node} content
+       * @returns content
        * @override
        **/
-      // @ts-expect-error - method overrides property from Node base class
       getContent() {
         return this.content.getContent();
       }
       /**
        * 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);
@@ -11737,8 +11679,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);
@@ -11746,15 +11688,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) {
@@ -11765,25 +11706,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) {
@@ -11793,9 +11732,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() {
@@ -11841,10 +11779,11 @@ 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
        */
+      // `step` may be null: toJSON() emits `step: null` for a range without one.
       constructor(start, end, step) {
         super();
         if (!isNode(start)) throw new TypeError("Node expected");
@@ -11865,7 +11804,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) {
@@ -11877,16 +11815,15 @@ 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
       _compile(math, argNames) {
         const range = math.range;
         const evalStart = this.start._compile(math, argNames);
@@ -11908,7 +11845,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);
@@ -11920,8 +11857,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(
@@ -11932,15 +11869,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";
@@ -11971,7 +11907,6 @@ var createRangeNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -11983,19 +11918,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";
@@ -12027,7 +11961,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";
@@ -12081,9 +12015,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
@@ -12116,19 +12050,20 @@ 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
       _compile(math, argNames) {
         const conditionals = this.conditionals;
-        const compiled = this.params.map((p) => p._compile(math, argNames));
+        const compiled = this.params.map(
+          (p) => p._compile(math, argNames)
+        );
         return function evalRelationalNode(scope, args, context) {
           let evalLhs;
           let evalRhs = compiled[0](scope, args, context);
@@ -12145,16 +12080,19 @@ 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);
+        this.params.forEach(
+          (n, i) => callback(n, "params[" + i + "]", this),
+          this
+        );
       }
       /**
        * 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(
@@ -12167,15 +12105,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";
@@ -12203,7 +12140,6 @@ var createRelationalNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -12214,19 +12150,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";
@@ -12252,9 +12187,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;
@@ -12313,7 +12247,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) {
@@ -12333,13 +12267,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) {
@@ -12361,38 +12295,36 @@ 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() {
         return new SymbolNode(this.name);
       }
       /**
        * Get string representation
-       * @param {Object} options
-       * @return {string} str
+       * @param _options
+       * @returns str
        * @override
        */
       _toString(_options) {
@@ -12400,8 +12332,8 @@ var createSymbolNode = /* @__PURE__ */ factory(
       }
       /**
        * Get HTML representation
-       * @param {Object} options
-       * @return {string} str
+       * @param _options
+       * @returns str
        * @override
        */
       _toHTML(_options) {
@@ -12423,7 +12355,6 @@ var createSymbolNode = /* @__PURE__ */ factory(
       }
       /**
        * Get a JSON representation of the node
-       * @returns {Object}
        */
       toJSON() {
         return {
@@ -12433,18 +12364,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() {