@danielsimonjr/mathts-expression 0.7.0 → 0.8.0

package/dist/node/RelationalNode.d.ts

@@ -0,0 +1,165 @@
+interface Node {
+    _compile: (math: Record<string, unknown>, argNames: Record<string, boolean>) => CompileFunction;
+    _ifNode: (node: unknown) => Node;
+    toString: (options?: StringOptions) => string;
+    toHTML: (options?: StringOptions) => string;
+    toTex: (options?: StringOptions) => string;
+    toMathML: () => string;
+}
+type CompileFunction = (scope: Map<string, unknown>, args: Record<string, unknown>, context: unknown) => unknown;
+interface StringOptions {
+    parenthesis?: 'keep' | 'auto' | 'all';
+    implicit?: 'hide' | 'show';
+    [key: string]: unknown;
+}
+interface Dependencies {
+    Node: new (...args: unknown[]) => Node;
+}
+export declare const createRelationalNode: import("../utils/factory.js").FactoryFunction<Dependencies, {
+    new (conditionals: string[], params: Node[]): {
+        conditionals: string[];
+        params: Node[];
+        get type(): string;
+        get isRelationalNode(): boolean;
+        /**
+         * 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`
+         *                          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:
+         *                        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
+         */
+        forEach(callback: (child: Node, path: string, parent: /*elided*/ any) => void): void;
+        /**
+         * 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
+         */
+        map(callback: (child: Node, path: string, parent: /*elided*/ any) => Node): /*elided*/ any;
+        /**
+         * Create a clone of this node, a shallow copy
+         * @return {RelationalNode}
+         */
+        clone(): /*elided*/ any;
+        /**
+         * Get string representation.
+         * @param {Object} options
+         * @return {string} 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
+         */
+        _toHTML(options?: StringOptions): string;
+        /**
+         * Get LaTeX representation
+         * @param {Object} options
+         * @return {string} str
+         */
+        _toMathML(): string;
+        _toTex(options?: StringOptions): string;
+        _ifNode: (node: unknown) => Node;
+        toString: (options?: StringOptions) => string;
+        toHTML: (options?: StringOptions) => string;
+        toTex: (options?: StringOptions) => string;
+        toMathML: () => string;
+    };
+    name: string;
+    /**
+     * Instantiate a RelationalNode from its JSON representation
+     * @param {Object} json
+     *     An object structured like
+     *     `{"mathjs": "RelationalNode", "conditionals": ..., "params": ...}`,
+     *     where mathjs is optional
+     * @returns {RelationalNode}
+     */
+    fromJSON(json: {
+        conditionals: string[];
+        params: Node[];
+    }): {
+        conditionals: string[];
+        params: Node[];
+        get type(): string;
+        get isRelationalNode(): boolean;
+        /**
+         * 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`
+         *                          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:
+         *                        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
+         */
+        forEach(callback: (child: Node, path: string, parent: /*elided*/ any) => void): void;
+        /**
+         * 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
+         */
+        map(callback: (child: Node, path: string, parent: /*elided*/ any) => Node): /*elided*/ any;
+        /**
+         * Create a clone of this node, a shallow copy
+         * @return {RelationalNode}
+         */
+        clone(): /*elided*/ any;
+        /**
+         * Get string representation.
+         * @param {Object} options
+         * @return {string} 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
+         */
+        _toHTML(options?: StringOptions): string;
+        /**
+         * Get LaTeX representation
+         * @param {Object} options
+         * @return {string} str
+         */
+        _toMathML(): string;
+        _toTex(options?: StringOptions): string;
+        _ifNode: (node: unknown) => Node;
+        toString: (options?: StringOptions) => string;
+        toHTML: (options?: StringOptions) => string;
+        toTex: (options?: StringOptions) => string;
+        toMathML: () => string;
+    };
+}>;
+export {};
+//# sourceMappingURL=RelationalNode.d.ts.map

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

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

package/dist/node/SymbolNode.d.ts

@@ -0,0 +1,160 @@
+interface Node {
+    clone: () => Node;
+}
+type CompileFunction = (scope: Map<string, unknown>, args: Record<string, unknown>, context: unknown) => unknown;
+interface StringOptions {
+    [key: string]: unknown;
+}
+interface UnitConstructor {
+    new (value: unknown, name: string): unknown;
+    isValuelessUnit: (name: string) => boolean;
+}
+interface Dependencies {
+    math: Record<string, unknown>;
+    Unit?: UnitConstructor;
+    Node: new (...args: unknown[]) => Node;
+}
+export declare const createSymbolNode: import("../utils/factory.js").FactoryFunction<Dependencies, {
+    new (name: string): {
+        name: string;
+        get type(): string;
+        get isSymbolNode(): boolean;
+        /**
+         * 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`
+         *                          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:
+         *                        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
+         */
+        forEach(_callback: (child: Node, path: string, parent: /*elided*/ any) => void): void;
+        /**
+         * 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
+         */
+        map(_callback: (child: Node, path: string, parent: /*elided*/ any) => Node): /*elided*/ any;
+        /**
+         * Create a clone of this node, a shallow copy
+         * @return {SymbolNode}
+         */
+        clone(): /*elided*/ any;
+        /**
+         * Get string representation
+         * @param {Object} options
+         * @return {string} str
+         * @override
+         */
+        _toString(_options?: StringOptions): string;
+        /**
+         * Get HTML representation
+         * @param {Object} options
+         * @return {string} str
+         * @override
+         */
+        _toHTML(_options?: StringOptions): string;
+        /**
+         * Get a JSON representation of the node
+         * @returns {Object}
+         */
+        toJSON(): Record<string, unknown>;
+        /**
+         * Get LaTeX representation
+         * @param {Object} options
+         * @return {string} str
+         * @override
+         */
+        _toMathML(): string;
+        _toTex(_options?: StringOptions): string;
+    };
+    /**
+     * Throws an error 'Undefined symbol {name}'
+     * @param {string} name
+     */
+    onUndefinedSymbol(name: string): never;
+    /**
+     * Instantiate a SymbolNode from its JSON representation
+     * @param {Object} json  An object structured like
+     *                       `{"mathjs": "SymbolNode", name: "x"}`,
+     *                       where mathjs is optional
+     * @returns {SymbolNode}
+     */
+    fromJSON(json: {
+        name: string;
+    }): {
+        name: string;
+        get type(): string;
+        get isSymbolNode(): boolean;
+        /**
+         * 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`
+         *                          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:
+         *                        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
+         */
+        forEach(_callback: (child: Node, path: string, parent: /*elided*/ any) => void): void;
+        /**
+         * 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
+         */
+        map(_callback: (child: Node, path: string, parent: /*elided*/ any) => Node): /*elided*/ any;
+        /**
+         * Create a clone of this node, a shallow copy
+         * @return {SymbolNode}
+         */
+        clone(): /*elided*/ any;
+        /**
+         * Get string representation
+         * @param {Object} options
+         * @return {string} str
+         * @override
+         */
+        _toString(_options?: StringOptions): string;
+        /**
+         * Get HTML representation
+         * @param {Object} options
+         * @return {string} str
+         * @override
+         */
+        _toHTML(_options?: StringOptions): string;
+        /**
+         * Get a JSON representation of the node
+         * @returns {Object}
+         */
+        toJSON(): Record<string, unknown>;
+        /**
+         * Get LaTeX representation
+         * @param {Object} options
+         * @return {string} str
+         * @override
+         */
+        _toMathML(): string;
+        _toTex(_options?: StringOptions): string;
+    };
+}>;
+export {};
+//# sourceMappingURL=SymbolNode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SymbolNode.d.ts","sourceRoot":"","sources":["../../src/node/SymbolNode.ts"],"names":[],"mappings":"AAOA,UAAU,IAAI;IACZ,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED,KAAK,eAAe,GAAG,CACrB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,EAC3B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE,OAAO,KACb,OAAO,CAAC;AAEb,UAAU,aAAa;IACrB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,UAAU,eAAe;IACvB,KAAK,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC5C,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;CAC5C;AAED,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,IAAI,EAAE,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;CACxC;AAKD,eAAO,MAAM,gBAAgB;eAuBL,MAAM;cATlB,MAAM;oBAmBA,MAAM;4BAGE,OAAO;QAI3B;;;;;;;;;;;;WAYG;uBACY,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe;QAuC3F;;;WAGG;2BACgB,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,gBAAY,KAAK,IAAI,GAAG,IAAI;QAIjF;;;;;WAKG;uBACY,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,gBAAY,KAAK,IAAI;QAYtE;;;WAGG;;QAMH;;;;;WAKG;6BACkB,aAAa,GAAG,MAAM;QAI3C;;;;;WAKG;2BACgB,aAAa,GAAG,MAAM;QAoBzC;;;WAGG;kBACO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QAkBjC;;;;;WAKG;qBACU,MAAM;0BAID,aAAa,GAAG,MAAM;;IArFxC;;;OAGG;4BAC4B,MAAM,GAAG,KAAK;IA4D7C;;;;;;OAMG;mBACmB;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE;cAvKhC,MAAM;oBAmBA,MAAM;4BAGE,OAAO;QAI3B;;;;;;;;;;;;WAYG;uBACY,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe;QAuC3F;;;WAGG;2BACgB,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,gBAAY,KAAK,IAAI,GAAG,IAAI;QAIjF;;;;;WAKG;uBACY,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,gBAAY,KAAK,IAAI;QAYtE;;;WAGG;;QAMH;;;;;WAKG;6BACkB,aAAa,GAAG,MAAM;QAI3C;;;;;WAKG;2BACgB,aAAa,GAAG,MAAM;QAoBzC;;;WAGG;kBACO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QAkBjC;;;;;WAKG;qBACU,MAAM;0BAID,aAAa,GAAG,MAAM;;EAmB7C,CAAC"}

package/dist/node/utils/access.d.ts

@@ -0,0 +1,7 @@
+export declare function accessFactory({ subset }: {
+    subset: (...args: unknown[]) => unknown;
+}): (object: unknown, index: {
+    isObjectProperty: () => boolean;
+    getObjectProperty: () => string;
+}) => unknown;
+//# sourceMappingURL=access.d.ts.map

package/dist/node/utils/access.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"access.d.ts","sourceRoot":"","sources":["../../../src/node/utils/access.ts"],"names":[],"mappings":"AAIA,wBAAgB,aAAa,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAA;CAAE,YAazE,OAAO,SACR;IAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;IAAC,iBAAiB,EAAE,MAAM,MAAM,CAAA;CAAE,aAwB9E"}

package/dist/node/utils/assign.d.ts

@@ -0,0 +1,9 @@
+import type { IndexLike } from './stringSubset.js';
+export declare function assignFactory({ subset }: {
+    subset: (...args: unknown[]) => unknown;
+}): (object: unknown, index: {
+    isObjectProperty: () => boolean;
+    getObjectProperty: () => string;
+    isIndex?: boolean;
+} & IndexLike, value: unknown) => unknown;
+//# sourceMappingURL=assign.d.ts.map

package/dist/node/utils/assign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assign.d.ts","sourceRoot":"","sources":["../../../src/node/utils/assign.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,wBAAgB,aAAa,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAA;CAAE,YAgBzE,OAAO,SACR;IAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;IAAC,iBAAiB,EAAE,MAAM,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,SAAS,SACnG,OAAO,aA8BjB"}

package/dist/node/utils/stringSubset.d.ts

@@ -0,0 +1,33 @@
+/** A Range-like dimension within an Index */
+interface DimensionRange {
+    forEach(callback: (value: number, index: number[]) => void): void;
+    size(): number[];
+}
+/** The runtime Index surface used by subset */
+export interface IndexLike {
+    isIndex?: boolean;
+    isScalar(): boolean;
+    size(): number[];
+    min(): number[];
+    max(): number[];
+    dimension(dim: number): number | string | DimensionRange;
+}
+/**
+ * Retrieve a subset of a string
+ * @param {string} str            string from which to get a substring
+ * @param {IndexLike} index       An index or list of indices (character positions)
+ * @returns {string} substring
+ */
+export declare function getStringSubset(str: string, index: IndexLike): string;
+/**
+ * Replace a substring in a string
+ * @param {string} str            string to be replaced
+ * @param {IndexLike} index       An index or list of indices (character positions)
+ * @param {string} replacement    Replacement string
+ * @param {string} [defaultValue] Default value to be used when resizing
+ *                                the string. is ' ' by default
+ * @returns {string} result
+ */
+export declare function setStringSubset(str: string, index: IndexLike, replacement: string, defaultValue?: string): string;
+export {};
+//# sourceMappingURL=stringSubset.d.ts.map

package/dist/node/utils/stringSubset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stringSubset.d.ts","sourceRoot":"","sources":["../../../src/node/utils/stringSubset.ts"],"names":[],"mappings":"AAIA,6CAA6C;AAC7C,UAAU,cAAc;IACtB,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IAClE,IAAI,IAAI,MAAM,EAAE,CAAC;CAClB;AAED,+CAA+C;AAC/C,MAAM,WAAW,SAAS;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,IAAI,OAAO,CAAC;IACpB,IAAI,IAAI,MAAM,EAAE,CAAC;IACjB,GAAG,IAAI,MAAM,EAAE,CAAC;IAChB,GAAG,IAAI,MAAM,EAAE,CAAC;IAChB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,cAAc,CAAC;CAC1D;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAiCrE;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,SAAS,EAChB,WAAW,EAAE,MAAM,EACnB,YAAY,CAAC,EAAE,MAAM,GACpB,MAAM,CA0ER"}

package/dist/operators.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Metadata for a single operator/node identifier in the precedence table.
+ * All fields are optional because different entries carry different subsets.
+ */
+export interface OperatorProperty {
+    op?: string;
+    associativity?: 'left' | 'right';
+    associativeWith?: string[];
+    latexParens?: boolean;
+    latexLeftParens?: boolean;
+    latexRightParens?: boolean;
+}
+/** One precedence group: a map from node identifier to its metadata. */
+export type OperatorGroup = Record<string, OperatorProperty>;
+export declare const properties: OperatorGroup[];
+/**
+ * Get the precedence of a Node.
+ * Higher number for higher precedence, starting with 0.
+ * Returns null if the precedence is undefined.
+ *
+ * @param {Node} _node
+ * @param {string} parenthesis
+ * @param {string} implicit
+ * @param {Node} parent (for determining context for implicit multiplication)
+ * @return {number | null}
+ */
+export declare function getPrecedence(_node: unknown, parenthesis: string | undefined, implicit: string | undefined, parent: unknown): number | null;
+/**
+ * Get the associativity of an operator (left or right).
+ * Returns a string containing 'left' or 'right' or null if
+ * the associativity is not defined.
+ *
+ * @param {Node} _node
+ * @param {string} parenthesis
+ * @return {string|null}
+ * @throws {Error}
+ */
+export declare function getAssociativity(_node: unknown, parenthesis: string | undefined): 'left' | 'right' | null;
+/**
+ * Check if an operator is associative with another operator.
+ * Returns either true or false or null if not defined.
+ *
+ * @param {Node} nodeA
+ * @param {Node} nodeB
+ * @param {string} parenthesis
+ * @return {boolean | null}
+ */
+export declare function isAssociativeWith(nodeA: unknown, nodeB: unknown, parenthesis: string | undefined): boolean | null;
+/**
+ * Get the operator associated with a function name.
+ * Returns a string with the operator symbol, or null if the
+ * input is not the name of a function associated with an
+ * operator.
+ *
+ * @param {string} Function name
+ * @return {string | null} Associated operator symbol, if any
+ */
+export declare function getOperator(fn: string): string | null;
+//# sourceMappingURL=operators.d.ts.map

package/dist/operators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.d.ts","sourceRoot":"","sources":["../src/operators.ts"],"names":[],"mappings":"AAqBA;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACjC,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,wEAAwE;AACxE,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;AAgB7D,eAAO,MAAM,UAAU,EAAE,aAAa,EAkQrC,CAAC;AAkBF;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,OAAO,EACd,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,MAAM,EAAE,OAAO,GACd,MAAM,GAAG,IAAI,CAwCf;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,OAAO,EACd,WAAW,EAAE,MAAM,GAAG,SAAS,GAC9B,MAAM,GAAG,OAAO,GAAG,IAAI,CA6BzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,OAAO,EACd,WAAW,EAAE,MAAM,GAAG,SAAS,GAC9B,OAAO,GAAG,IAAI,CA0BhB;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQrD"}

package/dist/parse.d.ts

@@ -0,0 +1,54 @@
+import type { NumberTypeConfig } from './utils/number.js';
+import type { MathNode } from './node/Node.js';
+/** An AST node constructor injected as a factory dependency. The mathjs node
+ *  constructors accept heterogeneous positional args and all yield a MathNode. */
+type NodeConstructor = new (...args: unknown[]) => MathNode;
+/** The typed-dispatch `parse` function plus the character-class helpers the
+ *  tokenizer hangs off it. */
+interface ParseFunction {
+    (expr: string | string[], options?: ParseOptions): MathNode | MathNode[];
+    isAlpha(c: string, cPrev: string, cNext: string): boolean;
+    isValidLatinOrGreek(c: string): boolean;
+    isValidMathSymbol(high: string, low: string): boolean;
+    isWhitespace(c: string, nestingLevel: number): boolean;
+    isDecimalMark(c: string, cNext: string): boolean;
+    isDigitDot(c: string): boolean;
+    isDigit(c: string): boolean;
+}
+/** The injected typed-function builder used to assemble `parse`. */
+interface TypedFunction {
+    (name: string, signatures: Record<string, unknown>): ParseFunction;
+    addConversion(conversion: {
+        from: string;
+        to: string;
+        convert: unknown;
+    }): void;
+}
+/** Factory dependencies for createParse (typed builder, numeric parser,
+ *  config, and the AST node constructors). */
+interface ParseDependencies {
+    typed: TypedFunction;
+    numeric: (value: string, type: string) => unknown;
+    config: NumberTypeConfig;
+    AccessorNode: NodeConstructor;
+    ArrayNode: NodeConstructor;
+    AssignmentNode: NodeConstructor;
+    BlockNode: NodeConstructor;
+    ConditionalNode: NodeConstructor;
+    ConstantNode: NodeConstructor;
+    FunctionAssignmentNode: NodeConstructor;
+    FunctionNode: NodeConstructor;
+    IndexNode: NodeConstructor;
+    ObjectNode: NodeConstructor;
+    OperatorNode: NodeConstructor;
+    ParenthesisNode: NodeConstructor;
+    RangeNode: NodeConstructor;
+    RelationalNode: NodeConstructor;
+    SymbolNode: NodeConstructor;
+}
+interface ParseOptions {
+    nodes?: Record<string, NodeConstructor>;
+}
+export declare const createParse: import("./utils/factory.js").FactoryFunction<ParseDependencies, ParseFunction>;
+export {};
+//# sourceMappingURL=parse.d.ts.map

package/dist/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAG1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C;kFACkF;AAClF,KAAK,eAAe,GAAG,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,QAAQ,CAAC;AAK5D;8BAC8B;AAC9B,UAAU,aAAa;IACrB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,QAAQ,GAAG,QAAQ,EAAE,CAAC;IACzE,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1D,mBAAmB,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACxC,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACtD,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC;IACvD,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IACjD,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;CAC7B;AAED,oEAAoE;AACpE,UAAU,aAAa;IACrB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,aAAa,CAAC;IACnE,aAAa,CAAC,UAAU,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;CACjF;AAED;8CAC8C;AAC9C,UAAU,iBAAiB;IACzB,KAAK,EAAE,aAAa,CAAC;IACrB,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAClD,MAAM,EAAE,gBAAgB,CAAC;IACzB,YAAY,EAAE,eAAe,CAAC;IAC9B,SAAS,EAAE,eAAe,CAAC;IAC3B,cAAc,EAAE,eAAe,CAAC;IAChC,SAAS,EAAE,eAAe,CAAC;IAC3B,eAAe,EAAE,eAAe,CAAC;IACjC,YAAY,EAAE,eAAe,CAAC;IAC9B,sBAAsB,EAAE,eAAe,CAAC;IACxC,YAAY,EAAE,eAAe,CAAC;IAC9B,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,eAAe,CAAC;IAC5B,YAAY,EAAE,eAAe,CAAC;IAC9B,eAAe,EAAE,eAAe,CAAC;IACjC,SAAS,EAAE,eAAe,CAAC;IAC3B,cAAc,EAAE,eAAe,CAAC;IAChC,UAAU,EAAE,eAAe,CAAC;CAC7B;AA2CD,UAAU,YAAY;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CACzC;AAED,eAAO,MAAM,WAAW,gFA62DvB,CAAC"}

package/dist/transform/and.transform.d.ts

@@ -0,0 +1,16 @@
+interface Node {
+    compile(): CompiledExpression;
+}
+interface CompiledExpression {
+    evaluate(scope: unknown): unknown;
+}
+interface TransformFunction {
+    (args: Node[], math: unknown, scope: unknown): unknown;
+    rawArgs?: boolean;
+}
+interface Dependencies {
+    and: (...args: unknown[]) => unknown;
+}
+export declare const createAndTransform: import("../utils/factory.js").FactoryFunction<Dependencies, TransformFunction>;
+export {};
+//# sourceMappingURL=and.transform.d.ts.map

package/dist/transform/and.transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"and.transform.d.ts","sourceRoot":"","sources":["../../src/transform/and.transform.ts"],"names":[],"mappings":"AAGA,UAAU,IAAI;IACZ,OAAO,IAAI,kBAAkB,CAAC;CAC/B;AAED,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;CACnC;AAED,UAAU,iBAAiB;IACzB,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IACvD,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,UAAU,YAAY;IACpB,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;CACtC;AAKD,eAAO,MAAM,kBAAkB,gFAkB9B,CAAC"}

package/dist/transform/bitAnd.transform.d.ts

@@ -0,0 +1,16 @@
+interface Node {
+    compile(): CompiledExpression;
+}
+interface CompiledExpression {
+    evaluate(scope: unknown): unknown;
+}
+interface TransformFunction {
+    (args: Node[], math: unknown, scope: unknown): unknown;
+    rawArgs?: boolean;
+}
+interface Dependencies {
+    bitAnd: (...args: unknown[]) => unknown;
+}
+export declare const createBitAndTransform: import("../utils/factory.js").FactoryFunction<Dependencies, TransformFunction>;
+export {};
+//# sourceMappingURL=bitAnd.transform.d.ts.map

package/dist/transform/bitAnd.transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitAnd.transform.d.ts","sourceRoot":"","sources":["../../src/transform/bitAnd.transform.ts"],"names":[],"mappings":"AAGA,UAAU,IAAI;IACZ,OAAO,IAAI,kBAAkB,CAAC;CAC/B;AAED,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;CACnC;AAED,UAAU,iBAAiB;IACzB,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IACvD,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,UAAU,YAAY;IACpB,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;CACzC;AAKD,eAAO,MAAM,qBAAqB,gFAuBjC,CAAC"}

package/dist/transform/bitOr.transform.d.ts

@@ -0,0 +1,16 @@
+interface Node {
+    compile(): CompiledExpression;
+}
+interface CompiledExpression {
+    evaluate(scope: unknown): unknown;
+}
+interface TransformFunction {
+    (args: Node[], math: unknown, scope: unknown): unknown;
+    rawArgs?: boolean;
+}
+interface Dependencies {
+    bitOr: (...args: unknown[]) => unknown;
+}
+export declare const createBitOrTransform: import("../utils/factory.js").FactoryFunction<Dependencies, TransformFunction>;
+export {};
+//# sourceMappingURL=bitOr.transform.d.ts.map

package/dist/transform/bitOr.transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitOr.transform.d.ts","sourceRoot":"","sources":["../../src/transform/bitOr.transform.ts"],"names":[],"mappings":"AAGA,UAAU,IAAI;IACZ,OAAO,IAAI,kBAAkB,CAAC;CAC/B;AAED,UAAU,kBAAkB;IAC1B,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;CACnC;AAED,UAAU,iBAAiB;IACzB,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;IACvD,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,UAAU,YAAY;IACpB,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;CACxC;AAKD,eAAO,MAAM,oBAAoB,gFA0BhC,CAAC"}

package/dist/transform/column.transform.d.ts

@@ -0,0 +1,17 @@
+interface TypedFunction<T = unknown> {
+    (...args: unknown[]): T;
+}
+interface Dependencies {
+    column: (...args: unknown[]) => unknown;
+    typed: TypedFunction;
+}
+/**
+ * Attach a transform function to matrix.column
+ * Adds a property transform containing the transform function.
+ *
+ * This transform changed the last `index` parameter of function column
+ * from zero-based to one-based
+ */
+export declare const createColumnTransform: import("../utils/factory.js").FactoryFunction<Dependencies, unknown>;
+export {};
+//# sourceMappingURL=column.transform.d.ts.map

package/dist/transform/column.transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"column.transform.d.ts","sourceRoot":"","sources":["../../src/transform/column.transform.ts"],"names":[],"mappings":"AAIA,UAAU,aAAa,CAAC,CAAC,GAAG,OAAO;IACjC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;CACzB;AAED,UAAU,YAAY;IACpB,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IACxC,KAAK,EAAE,aAAa,CAAC;CACtB;AAKD;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,sEAuBjC,CAAC"}

package/dist/transform/concat.transform.d.ts

@@ -0,0 +1,11 @@
+interface TypedFunction<T = unknown> {
+    (...args: unknown[]): T;
+    find(func: unknown, signature: string[]): TypedFunction<T>;
+}
+interface Dependencies {
+    concat: (...args: unknown[]) => unknown;
+    typed: TypedFunction;
+}
+export declare const createConcatTransform: import("../utils/factory.js").FactoryFunction<Dependencies, unknown>;
+export {};
+//# sourceMappingURL=concat.transform.d.ts.map

package/dist/transform/concat.transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat.transform.d.ts","sourceRoot":"","sources":["../../src/transform/concat.transform.ts"],"names":[],"mappings":"AAIA,UAAU,aAAa,CAAC,CAAC,GAAG,OAAO;IACjC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;IACxB,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;CAC5D;AAED,UAAU,YAAY;IACpB,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IACxC,KAAK,EAAE,aAAa,CAAC;CACtB;AAKD,eAAO,MAAM,qBAAqB,sEA+BjC,CAAC"}

package/dist/transform/cumsum.transform.d.ts

@@ -0,0 +1,10 @@
+interface TypedFunction<T = unknown> {
+    (...args: unknown[]): T;
+}
+interface Dependencies {
+    cumsum: (...args: unknown[]) => unknown;
+    typed: TypedFunction;
+}
+export declare const createCumSumTransform: import("../utils/factory.js").FactoryFunction<Dependencies, unknown>;
+export {};
+//# sourceMappingURL=cumsum.transform.d.ts.map

package/dist/transform/cumsum.transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cumsum.transform.d.ts","sourceRoot":"","sources":["../../src/transform/cumsum.transform.ts"],"names":[],"mappings":"AAIA,UAAU,aAAa,CAAC,CAAC,GAAG,OAAO;IACjC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;CACzB;AAED,UAAU,YAAY;IACpB,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC;IACxC,KAAK,EAAE,aAAa,CAAC;CACtB;AAYD,eAAO,MAAM,qBAAqB,sEAyBjC,CAAC"}