@danielsimonjr/mathts-expression 0.8.0 → 0.8.1

package/dist/node/FunctionNode.d.ts

@@ -460,31 +460,30 @@ export declare const createFunctionNode: import("../utils/factory.js").FactoryFu
          * 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: Record<string, unknown>, argNames: Record<string, boolean>): (scope: Map<string, unknown>, args: Record<string, unknown>, context: unknown) => unknown;
         /**
          * 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: (child: MathNode, path: string, parent: MathNode) => void): void;
         /**
          * 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: (child: MathNode, path: string, parent: MathNode) => MathNode): /*elided*/ any;
         /**
          * Create a clone of this node, a shallow copy
-         * @return {FunctionNode}
          */
         clone(): /*elided*/ any;
         /**
@@ -495,20 +494,19 @@ export declare const createFunctionNode: import("../utils/factory.js").FactoryFu
          * otherwise it falls back to calling Node's toString
          * function.
          *
-         * @param {Object} options
-         * @return {string} str
+         * @param options
+         * @returns str
          * @override
          */
         toString(options?: StringOptions): string;
         /**
          * Get string representation
-         * @param {Object} options
-         * @return {string} str
+         * @param options
+         * @returns str
          */
         _toString(options?: StringOptions): string;
         /**
          * Get a JSON representation of the node
-         * @returns {Object}
          */
         toJSON(): {
             mathjs: string;
@@ -517,8 +515,8 @@ export declare const createFunctionNode: import("../utils/factory.js").FactoryFu
         };
         /**
          * Get HTML representation
-         * @param {Object} options
-         * @return {string} str
+         * @param options
+         * @returns str
          */
         _toHTML(options?: StringOptions): string;
         /**
@@ -529,20 +527,17 @@ export declare const createFunctionNode: import("../utils/factory.js").FactoryFu
          * otherwise it falls back to calling Node's toTex
          * function.
          *
-         * @param {Object} options
-         * @return {string}
+         * @param options
          */
         toTex(options?: StringOptions): string;
         /**
-         * Get LaTeX representation
-         * @param {Object} options
-         * @return {string} str
+         * Get the MathML representation of this node.
+         * @returns str
          */
         _toMathML(): string;
         _toTex(options?: StringOptions): string;
         /**
          * Get identifier.
-         * @return {string}
          */
         getIdentifier(): string;
         get isNode(): boolean;
@@ -552,15 +547,14 @@ export declare const createFunctionNode: import("../utils/factory.js").FactoryFu
     name: string;
     /**
      * Throws an error 'Undefined function {name}'
-     * @param {string} name
+     * @param name
      */
     onUndefinedFunction: (name: string) => never;
     /**
      * 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}
      */
     fromJSON: (json: {
         fn: MathNode;
@@ -1021,31 +1015,30 @@ export declare const createFunctionNode: import("../utils/factory.js").FactoryFu
          * 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: Record<string, unknown>, argNames: Record<string, boolean>): (scope: Map<string, unknown>, args: Record<string, unknown>, context: unknown) => unknown;
         /**
          * 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: (child: MathNode, path: string, parent: MathNode) => void): void;
         /**
          * 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: (child: MathNode, path: string, parent: MathNode) => MathNode): /*elided*/ any;
         /**
          * Create a clone of this node, a shallow copy
-         * @return {FunctionNode}
          */
         clone(): /*elided*/ any;
         /**
@@ -1056,20 +1049,19 @@ export declare const createFunctionNode: import("../utils/factory.js").FactoryFu
          * otherwise it falls back to calling Node's toString
          * function.
          *
-         * @param {Object} options
-         * @return {string} str
+         * @param options
+         * @returns str
          * @override
          */
         toString(options?: StringOptions): string;
         /**
          * Get string representation
-         * @param {Object} options
-         * @return {string} str
+         * @param options
+         * @returns str
          */
         _toString(options?: StringOptions): string;
         /**
          * Get a JSON representation of the node
-         * @returns {Object}
          */
         toJSON(): {
             mathjs: string;
@@ -1078,8 +1070,8 @@ export declare const createFunctionNode: import("../utils/factory.js").FactoryFu
         };
         /**
          * Get HTML representation
-         * @param {Object} options
-         * @return {string} str
+         * @param options
+         * @returns str
          */
         _toHTML(options?: StringOptions): string;
         /**
@@ -1090,20 +1082,17 @@ export declare const createFunctionNode: import("../utils/factory.js").FactoryFu
          * otherwise it falls back to calling Node's toTex
          * function.
          *
-         * @param {Object} options
-         * @return {string}
+         * @param options
          */
         toTex(options?: StringOptions): string;
         /**
-         * Get LaTeX representation
-         * @param {Object} options
-         * @return {string} str
+         * Get the MathML representation of this node.
+         * @returns str
          */
         _toMathML(): string;
         _toTex(options?: StringOptions): string;
         /**
          * Get identifier.
-         * @return {string}
          */
         getIdentifier(): string;
         get isNode(): boolean;

package/dist/node/FunctionNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FunctionNode.d.ts","sourceRoot":"","sources":["../../src/node/FunctionNode.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAKzD,eAAO,MAAM,kBAAkB;UAQrB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;UACvB,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,QAAQ;gBAC9B,KAAK,IAAI,EAAE,MAAM,KAAK,QAAQ;;aAmIxB,QAAQ,GAAG,MAAM,QAAQ,QAAQ,EAAE,aAAa,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAbnE,QAAQ;cACN,QAAQ,EAAE;kBACN,OAAO;oBAiCL,MAAM;oBAIN,MAAM;8BAGI,OAAO;QAI7B;;;;;;;;;;;;WAYG;uBACY,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WA9KlE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,QACrB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WACpB,OAAO,KACb,OAAO;QA+WV;;;WAGG;0BACe,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,KAAK,IAAI,GAAG,IAAI;QAQlF;;;;;WAKG;sBACW,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,KAAK,QAAQ;QAS3E;;;WAGG;;QAaH;;;;;;;;;;;WAWG;2BACgB,aAAa,GAAG,MAAM;QAoBzC;;;;WAIG;4BACiB,aAAa,GAAG,MAAM;QAa1C;;;WAGG;kBACO;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,EAAE,EAAE,QAAQ,CAAC;YAAC,IAAI,EAAE,QAAQ,EAAE,CAAA;SAAE;QAmB5D;;;;WAIG;0BACe,aAAa,GAAG,MAAM;QAexC;;;;;;;;;;WAUG;wBACa,aAAa,GAAG,MAAM;QAmBtC;;;;WAIG;qBACU,MAAM;yBAkBF,aAAa,GAAG,MAAM;QAuDvC;;;WAGG;yBACc,MAAM;;;;;;IArNvB;;;OAGG;gCAC0C,MAAM,KAAG,KAAK;IAkE3D;;;;;;OAMG;qBAC+B;QAAE,EAAE,EAAE,QAAQ,CAAC;QAAC,IAAI,EAAE,QAAQ,EAAE,CAAA;KAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YA/WhE,QAAQ;cACN,QAAQ,EAAE;kBACN,OAAO;oBAiCL,MAAM;oBAIN,MAAM;8BAGI,OAAO;QAI7B;;;;;;;;;;;;WAYG;uBACY,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WA9KlE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,QACrB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WACpB,OAAO,KACb,OAAO;QA+WV;;;WAGG;0BACe,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,KAAK,IAAI,GAAG,IAAI;QAQlF;;;;;WAKG;sBACW,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,KAAK,QAAQ;QAS3E;;;WAGG;;QAaH;;;;;;;;;;;WAWG;2BACgB,aAAa,GAAG,MAAM;QAoBzC;;;;WAIG;4BACiB,aAAa,GAAG,MAAM;QAa1C;;;WAGG;kBACO;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,EAAE,EAAE,QAAQ,CAAC;YAAC,IAAI,EAAE,QAAQ,EAAE,CAAA;SAAE;QAmB5D;;;;WAIG;0BACe,aAAa,GAAG,MAAM;QAexC;;;;;;;;;;WAUG;wBACa,aAAa,GAAG,MAAM;QAmBtC;;;;WAIG;qBACU,MAAM;yBAkBF,aAAa,GAAG,MAAM;QAuDvC;;;WAGG;yBACc,MAAM;;;;;EAQ5B,CAAC"}
+{"version":3,"file":"FunctionNode.d.ts","sourceRoot":"","sources":["../../src/node/FunctionNode.ts"],"names":[],"mappings":"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"}

package/dist/node/IndexNode.d.ts

@@ -27,65 +27,61 @@ export declare const createIndexNode: import("../utils/factory.js").FactoryFunct
          * 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: Record<string, unknown>, argNames: Record<string, boolean>): CompileFunction;
         /**
          * 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: (child: Node, path: string, parent: /*elided*/ any) => void): void;
         /**
          * 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: (child: Node, path: string, parent: /*elided*/ any) => Node): /*elided*/ any;
         /**
          * Create a clone of this node, a shallow copy
-         * @return {IndexNode}
          */
         clone(): /*elided*/ any;
         /**
          * Test whether this IndexNode contains a single property name
-         * @return {boolean}
          */
         isObjectProperty(): boolean;
         /**
          * Returns the property name if IndexNode contains a property.
          * If not, returns null.
-         * @return {string | null}
          */
         getObjectProperty(): string | null;
         /**
          * Get string representation
-         * @param {Object} options
-         * @return {string} str
+         * @param _options
+         * @returns str
          */
         _toString(_options?: StringOptions): string;
         /**
          * Get a JSON representation of the node
-         * @returns {Object}
          */
         toJSON(): Record<string, unknown>;
         /**
          * Get HTML representation
-         * @param {Object} options
-         * @return {string} str
+         * @param _options
+         * @returns str
          */
         _toHTML(_options?: StringOptions): string;
         /**
          * Get LaTeX representation
-         * @param {Object} options
-         * @return {string} str
+         * @param options
+         * @returns str
          */
         _toTex(options?: StringOptions): string;
         _ifNode: (node: unknown) => Node;
@@ -100,11 +96,10 @@ export declare const createIndexNode: import("../utils/factory.js").FactoryFunct
     name: string;
     /**
      * 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}
      */
     fromJSON(json: {
         dimensions: Node[];
@@ -118,65 +113,61 @@ export declare const createIndexNode: import("../utils/factory.js").FactoryFunct
          * 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: Record<string, unknown>, argNames: Record<string, boolean>): CompileFunction;
         /**
          * 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: (child: Node, path: string, parent: /*elided*/ any) => void): void;
         /**
          * 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: (child: Node, path: string, parent: /*elided*/ any) => Node): /*elided*/ any;
         /**
          * Create a clone of this node, a shallow copy
-         * @return {IndexNode}
          */
         clone(): /*elided*/ any;
         /**
          * Test whether this IndexNode contains a single property name
-         * @return {boolean}
          */
         isObjectProperty(): boolean;
         /**
          * Returns the property name if IndexNode contains a property.
          * If not, returns null.
-         * @return {string | null}
          */
         getObjectProperty(): string | null;
         /**
          * Get string representation
-         * @param {Object} options
-         * @return {string} str
+         * @param _options
+         * @returns str
          */
         _toString(_options?: StringOptions): string;
         /**
          * Get a JSON representation of the node
-         * @returns {Object}
          */
         toJSON(): Record<string, unknown>;
         /**
          * Get HTML representation
-         * @param {Object} options
-         * @return {string} str
+         * @param _options
+         * @returns str
          */
         _toHTML(_options?: StringOptions): string;
         /**
          * Get LaTeX representation
-         * @param {Object} options
-         * @return {string} str
+         * @param options
+         * @returns str
          */
         _toTex(options?: StringOptions): string;
         _ifNode: (node: unknown) => Node;

package/dist/node/IndexNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IndexNode.d.ts","sourceRoot":"","sources":["../../src/node/IndexNode.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"IndexNode.d.ts","sourceRoot":"","sources":["../../src/node/IndexNode.ts"],"names":[],"mappings":"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"}

package/dist/node/Node.d.ts

@@ -1,8 +1,18 @@
 type Scope = Map<string, unknown>;
+/**
+ * The object that `Node.compile` returns.
+ * Call `evaluate` to get the value of the compiled node.
+ */
 export interface CompiledExpression {
     evaluate: (scope?: Record<string, unknown>) => unknown;
 }
 type CompileFunction = (scope: Scope, args: Record<string, unknown>, context: unknown) => unknown;
+/**
+ * Options for `toString`, `toTex` and `toHTML` of a node.
+ * `handler` is a custom function, or a map from node type to a custom function.
+ * `parenthesis` sets the parenthesis rule. `implicit` sets how implicit multiplication shows.
+ * The index signature allows other keys.
+ */
 export interface StringOptions {
     handler?: ((node: MathNode, options?: StringOptions) => string) | Record<string, (node: MathNode, options?: StringOptions) => string>;
     parenthesis?: 'keep' | 'auto' | 'all';
@@ -18,13 +28,13 @@ export declare const createNode: import("../utils/factory.js").FactoryFunction<D
         get isNode(): boolean;
         /**
          * 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?: Record<string, unknown>): unknown;
         /**
          * 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
@@ -35,39 +45,39 @@ export declare const createNode: import("../utils/factory.js").FactoryFunction<D
          * 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: Record<string, unknown>, _argNames: Record<string, boolean>): CompileFunction;
         /**
          * 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: (child: /*elided*/ any, path: string, parent: /*elided*/ any) => void): void;
         /**
          * 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: (child: /*elided*/ any, path: string, parent: /*elided*/ any) => /*elided*/ any): /*elided*/ any;
         /**
          * 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: unknown): /*elided*/ any;
         /**
          * 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: (node: /*elided*/ any, path: string | null, parent: /*elided*/ any | null) => void): void;
@@ -86,12 +96,12 @@ export declare const createNode: import("../utils/factory.js").FactoryFunction<D
          *       }
          *     })
          *
-         * @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: (node: /*elided*/ any, path: string | null, parent: /*elided*/ any | null) => /*elided*/ any): /*elided*/ any;
         /**
@@ -102,28 +112,26 @@ export declare const createNode: import("../utils/factory.js").FactoryFunction<D
          *       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: (node: /*elided*/ any, path: string | null, parent: /*elided*/ any | null) => boolean): /*elided*/ any[];
         /**
          * Create a shallow clone of this node
-         * @return {Node}
          */
         clone(): /*elided*/ any;
         /**
          * Create a deep clone of this node
-         * @return {Node}
          */
         cloneDeep(): /*elided*/ any;
         /**
          * 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: /*elided*/ any | null | undefined): boolean;
@@ -139,22 +147,20 @@ export declare const createNode: import("../utils/factory.js").FactoryFunction<D
          *    parenthesis: "keep" //the parenthesis option (This is optional)
          * }
          *
-         * @param {Object} [options]
-         * @return {string}
+         * @param options - Optional.
          */
         toString(options?: StringOptions): string;
         /**
          * Internal function to generate the string output.
          * This has to be implemented by every Node
          *
-         * @throws {Error}
+         * @throws Error
          */
         _toString(_options?: StringOptions): string;
         /**
          * 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(): Record<string, unknown>;
         /**
@@ -169,15 +175,14 @@ export declare const createNode: import("../utils/factory.js").FactoryFunction<D
          *    parenthesis: "keep" //the parenthesis option (This is optional)
          * }
          *
-         * @param {Object} [options]
-         * @return {string}
+         * @param options - Optional.
          */
         toHTML(options?: StringOptions): string;
         /**
          * Internal function to generate the HTML output.
          * This has to be implemented by every Node
          *
-         * @throws {Error}
+         * @throws Error
          */
         _toHTML(_options?: StringOptions): string;
         /**
@@ -192,16 +197,14 @@ export declare const createNode: import("../utils/factory.js").FactoryFunction<D
          *    parenthesis: "keep" //the parenthesis option (This is optional)
          * }
          *
-         * @param {Object} [options]
-         * @return {string}
+         * @param options - Optional.
          */
         toTex(options?: StringOptions): string;
         /**
          * 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?: {
             inline?: boolean;
@@ -210,8 +213,7 @@ export declare const createNode: import("../utils/factory.js").FactoryFunction<D
          * 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?: {
             name?: string;
@@ -221,7 +223,6 @@ export declare const createNode: import("../utils/factory.js").FactoryFunction<D
          * 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(): string;
         /**
@@ -234,8 +235,8 @@ export declare const createNode: import("../utils/factory.js").FactoryFunction<D
          * 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?: StringOptions): string;
         /**
@@ -244,16 +245,18 @@ export declare const createNode: import("../utils/factory.js").FactoryFunction<D
         _getCustomString(options?: StringOptions): string | undefined;
         /**
          * Get identifier.
-         * @return {string}
          */
         getIdentifier(): string;
         /**
          * Get the content of the current Node.
-         * @return {Node} node
+         * @returns node
          **/
         getContent(): /*elided*/ any;
     };
 }>;
+/**
+ * The instance type of the `Node` class that `createNode` makes.
+ */
 export type MathNode = InstanceType<ReturnType<typeof createNode>>;
 export {};
 //# sourceMappingURL=Node.d.ts.map