@danielsimonjr/mathts-functions 0.2.3 → 0.2.5

package/README.md

@@ -0,0 +1,21 @@
+# @danielsimonjr/mathts-functions
+
+Math functions for [MathTS](https://github.com/danielsimonjr/mathts).
+
+The mathematical function library for MathTS — arithmetic, trigonometry, algebra, statistics, signal processing, and more — dispatched polymorphically via typed-function across number / Complex / Fraction / BigNumber / Matrix.
+
+## Install
+
+```sh
+npm install @danielsimonjr/mathts-functions
+```
+
+## What it provides
+
+- Hundreds of typed functions (`add`, `sin`, `svd`-aware ops, `parallelFFT`, …).
+- A wired `parse` / `evaluate` against the full activated math scope.
+- Per-domain focused entry points are also published: `@danielsimonjr/mathts-{arithmetic,trigonometry,statistics,signal}`.
+
+## License
+
+MIT (c) Daniel Simon Jr.

package/dist/algebra/decomposition/lup.d.ts

@@ -0,0 +1,78 @@
+interface TypedFunction<T = any> {
+    (...args: any[]): T;
+    find(func: any, signature: string[]): TypedFunction<T>;
+}
+interface MatrixConstructor {
+    (data: any[] | any[][], storage?: 'dense' | 'sparse'): DenseMatrix | SparseMatrix;
+}
+interface DenseMatrix {
+    type: 'DenseMatrix';
+    isDenseMatrix: true;
+    _data: any[][];
+    _size: number[];
+    _datatype?: string;
+    storage(): 'dense';
+    size(): number[];
+    valueOf(): any[][];
+}
+interface SparseMatrix {
+    type: 'SparseMatrix';
+    isSparseMatrix: true;
+    _values?: any[];
+    _index?: number[];
+    _ptr?: number[];
+    _size: number[];
+    _datatype?: string;
+    _data?: any;
+    storage(): 'sparse';
+    size(): number[];
+    valueOf(): any[][];
+}
+interface DenseMatrixConstructor {
+    new (data: {
+        data: any[][];
+        size: number[];
+        datatype?: string;
+    }): DenseMatrix;
+    _swapRows(i: number, j: number, data: any[][]): void;
+}
+interface SparseMatrixConstructor {
+    new (data: {
+        values?: any[];
+        index?: number[];
+        ptr?: number[];
+        size: number[];
+        datatype?: string;
+    }): SparseMatrix;
+    _swapRows(j: number, pi: number, n: number, values: any[], index: number[], ptr: number[]): void;
+    _forEachRow(j: number, values: any[], index: number[], ptr: number[], callback: (i: number, value: any) => void): void;
+}
+interface Spa {
+    new (): Spa;
+    set(i: number, value: any): void;
+    get(i: number): any;
+    accumulate(i: number, value: any): void;
+    forEach(start: number, end: number, callback: (i: number, value: any) => void): void;
+    swap(i: number, j: number): void;
+}
+interface SpaConstructor {
+    new (): Spa;
+}
+interface Dependencies {
+    typed: TypedFunction;
+    matrix: MatrixConstructor;
+    abs: TypedFunction;
+    addScalar: TypedFunction;
+    divideScalar: TypedFunction;
+    multiplyScalar: TypedFunction;
+    subtractScalar: TypedFunction;
+    larger: TypedFunction<boolean>;
+    equalScalar: TypedFunction<boolean>;
+    unaryMinus: TypedFunction;
+    DenseMatrix: DenseMatrixConstructor;
+    SparseMatrix: SparseMatrixConstructor;
+    Spa: SpaConstructor;
+}
+export declare const createLup: import("../../utils/factory.js").FactoryFunction<Dependencies, any>;
+export {};
+//# sourceMappingURL=lup.d.ts.map

package/dist/algebra/decomposition/lup.d.ts.map

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

package/dist/algebra/decomposition/qr.d.ts

@@ -0,0 +1,60 @@
+interface TypedFunction<T = any> {
+    (...args: any[]): T;
+    find(func: any, signature: string[]): TypedFunction<T>;
+}
+interface MatrixConstructor {
+    (data: any[] | any[][], storage?: 'dense' | 'sparse'): DenseMatrix | SparseMatrix;
+}
+interface DenseMatrix {
+    type: 'DenseMatrix';
+    isDenseMatrix: true;
+    _data: any[][] | any[];
+    _size: number[];
+    _datatype?: string;
+    storage(): 'dense';
+    size(): number[];
+    valueOf(): any[][] | any[];
+    clone(): DenseMatrix;
+}
+interface SparseMatrix {
+    type: 'SparseMatrix';
+    isSparseMatrix: true;
+    _values?: any[];
+    _index?: number[];
+    _ptr?: number[];
+    _size: number[];
+    _datatype?: string;
+    _data?: any;
+    storage(): 'sparse';
+    size(): number[];
+    valueOf(): any[][];
+}
+interface ZerosFunction {
+    (size: number[], format?: string): DenseMatrix;
+}
+interface IdentityFunction {
+    (size: number[], format?: string): DenseMatrix;
+}
+interface ComplexFunction {
+    (re: number, im?: number): any;
+}
+interface Dependencies {
+    typed: TypedFunction;
+    matrix: MatrixConstructor;
+    zeros: ZerosFunction;
+    identity: IdentityFunction;
+    isZero: TypedFunction<boolean>;
+    equal: TypedFunction<boolean>;
+    sign: TypedFunction;
+    sqrt: TypedFunction;
+    conj: TypedFunction;
+    unaryMinus: TypedFunction;
+    addScalar: TypedFunction;
+    divideScalar: TypedFunction;
+    multiplyScalar: TypedFunction;
+    subtractScalar: TypedFunction;
+    complex: ComplexFunction;
+}
+export declare const createQr: import("../../utils/factory.js").FactoryFunction<Dependencies, any>;
+export {};
+//# sourceMappingURL=qr.d.ts.map

package/dist/algebra/decomposition/qr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qr.d.ts","sourceRoot":"","sources":["../../../src/algebra/decomposition/qr.ts"],"names":[],"mappings":"AAsCA,UAAU,aAAa,CAAC,CAAC,GAAG,GAAG;IAC7B,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IACpB,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;CACxD;AAED,UAAU,iBAAiB;IACzB,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,WAAW,GAAG,YAAY,CAAC;CACnF;AAED,UAAU,WAAW;IACnB,IAAI,EAAE,aAAa,CAAC;IACpB,aAAa,EAAE,IAAI,CAAC;IACpB,KAAK,EAAE,GAAG,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC;IACvB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,IAAI,OAAO,CAAC;IACnB,IAAI,IAAI,MAAM,EAAE,CAAC;IACjB,OAAO,IAAI,GAAG,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC;IAC3B,KAAK,IAAI,WAAW,CAAC;CACtB;AAED,UAAU,YAAY;IACpB,IAAI,EAAE,cAAc,CAAC;IACrB,cAAc,EAAE,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,GAAG,CAAC;IACZ,OAAO,IAAI,QAAQ,CAAC;IACpB,IAAI,IAAI,MAAM,EAAE,CAAC;IACjB,OAAO,IAAI,GAAG,EAAE,EAAE,CAAC;CACpB;AAED,UAAU,aAAa;IACrB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;CAChD;AAED,UAAU,gBAAgB;IACxB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC;CAChD;AAED,UAAU,eAAe;IACvB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,GAAG,CAAC;CAChC;AAaD,UAAU,YAAY;IACpB,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,KAAK,EAAE,aAAa,CAAC;IACrB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAC/B,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAC9B,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,aAAa,CAAC;IACpB,UAAU,EAAE,aAAa,CAAC;IAC1B,SAAS,EAAE,aAAa,CAAC;IACzB,YAAY,EAAE,aAAa,CAAC;IAC5B,cAAc,EAAE,aAAa,CAAC;IAC9B,cAAc,EAAE,aAAa,CAAC;IAC9B,OAAO,EAAE,eAAe,CAAC;CAC1B;AAqBD,eAAO,MAAM,QAAQ,qEA0SpB,CAAC"}

package/dist/algebra/decomposition/schur.d.ts

@@ -0,0 +1,40 @@
+type NestedArray<T = any> = T | NestedArray<T>[];
+type MatrixData = NestedArray<any>;
+interface TypedFunction<T = any> {
+    (...args: any[]): T;
+    find(func: any, signature: string[]): TypedFunction<T>;
+}
+interface Matrix {
+    type: string;
+    storage(): string;
+    datatype(): string | undefined;
+    size(): number[];
+    clone(): Matrix;
+    toArray(): MatrixData;
+    valueOf(): MatrixData;
+    _data?: MatrixData;
+    _size?: number[];
+    _datatype?: string;
+}
+interface MatrixConstructor {
+    (data: any[] | any[][], storage?: 'dense' | 'sparse'): Matrix;
+}
+interface IdentityFunction {
+    (size: number | number[]): Matrix;
+}
+interface QRResult {
+    Q: Matrix;
+    R: Matrix;
+}
+interface Dependencies {
+    typed: TypedFunction;
+    matrix: MatrixConstructor;
+    identity: IdentityFunction;
+    multiply: TypedFunction;
+    qr: TypedFunction<QRResult>;
+    norm: TypedFunction<number>;
+    subtract: TypedFunction;
+}
+export declare const createSchur: import("../../utils/factory.js").FactoryFunction<Dependencies, any>;
+export {};
+//# sourceMappingURL=schur.d.ts.map

package/dist/algebra/decomposition/schur.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schur.d.ts","sourceRoot":"","sources":["../../../src/algebra/decomposition/schur.ts"],"names":[],"mappings":"AAmCA,KAAK,WAAW,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;AACjD,KAAK,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;AAEnC,UAAU,aAAa,CAAC,CAAC,GAAG,GAAG;IAC7B,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IACpB,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;CACxD;AAED,UAAU,MAAM;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,IAAI,MAAM,CAAC;IAClB,QAAQ,IAAI,MAAM,GAAG,SAAS,CAAC;IAC/B,IAAI,IAAI,MAAM,EAAE,CAAC;IACjB,KAAK,IAAI,MAAM,CAAC;IAChB,OAAO,IAAI,UAAU,CAAC;IACtB,OAAO,IAAI,UAAU,CAAC;IACtB,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,iBAAiB;IACzB,CAAC,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;CAC/D;AAED,UAAU,gBAAgB;IACxB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC;CACnC;AAED,UAAU,QAAQ;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAaD,UAAU,YAAY;IACpB,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,QAAQ,EAAE,aAAa,CAAC;IACxB,EAAE,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;IAC5B,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5B,QAAQ,EAAE,aAAa,CAAC;CACzB;AAKD,eAAO,MAAM,WAAW,qEA0IvB,CAAC"}

package/dist/algebra/decomposition/slu.d.ts

@@ -0,0 +1,37 @@
+interface TypedFunction<T = any> {
+    (...args: any[]): T;
+}
+interface SparseMatrix {
+    type: 'SparseMatrix';
+    isSparseMatrix: true;
+    _values?: any[];
+    _index: number[];
+    _ptr: number[];
+    _size: number[];
+    _datatype?: string;
+    toString(): string;
+}
+interface SparseMatrixConstructor {
+    new (data: {
+        values?: any[];
+        index: number[];
+        ptr: number[];
+        size: number[];
+        datatype?: string;
+    }): SparseMatrix;
+}
+interface Dependencies {
+    typed: TypedFunction;
+    abs: TypedFunction;
+    add: TypedFunction;
+    multiply: TypedFunction;
+    transpose: TypedFunction;
+    divideScalar: TypedFunction;
+    subtract: TypedFunction;
+    larger: TypedFunction<boolean>;
+    largerEq: TypedFunction<boolean>;
+    SparseMatrix: SparseMatrixConstructor;
+}
+export declare const createSlu: import("../../utils/factory.js").FactoryFunction<Dependencies, any>;
+export {};
+//# sourceMappingURL=slu.d.ts.map

package/dist/algebra/decomposition/slu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slu.d.ts","sourceRoot":"","sources":["../../../src/algebra/decomposition/slu.ts"],"names":[],"mappings":"AAMA,UAAU,aAAa,CAAC,CAAC,GAAG,GAAG;IAC7B,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;CACrB;AAED,UAAU,YAAY;IACpB,IAAI,EAAE,cAAc,CAAC;IACrB,cAAc,EAAE,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,IAAI,MAAM,CAAC;CACpB;AAED,UAAU,uBAAuB;IAC/B,KAAK,IAAI,EAAE;QACT,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC;QACf,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,GAAG,EAAE,MAAM,EAAE,CAAC;QACd,IAAI,EAAE,MAAM,EAAE,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GAAG,YAAY,CAAC;CAClB;AAmCD,UAAU,YAAY;IACpB,KAAK,EAAE,aAAa,CAAC;IACrB,GAAG,EAAE,aAAa,CAAC;IACnB,GAAG,EAAE,aAAa,CAAC;IACnB,QAAQ,EAAE,aAAa,CAAC;IACxB,SAAS,EAAE,aAAa,CAAC;IACzB,YAAY,EAAE,aAAa,CAAC;IAC5B,QAAQ,EAAE,aAAa,CAAC;IACxB,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IAC/B,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,CAAC;IACjC,YAAY,EAAE,uBAAuB,CAAC;CACvC;AAgBD,eAAO,MAAM,SAAS,qEA4GrB,CAAC"}

package/dist/algebra/derivative.d.ts

@@ -0,0 +1,35 @@
+import type { MathNode, ConstantNode, SymbolNode, ParenthesisNode, FunctionNode, OperatorNode } from '../utils/node.js';
+import type { TypedFunction } from '../core/function/typed.js';
+import type { ConfigOptions } from '../core/config.js';
+interface ConstantNodeConstructor {
+    new (value: unknown): ConstantNode;
+}
+interface FunctionNodeConstructor {
+    new (name: string | SymbolNode, args: MathNode[]): FunctionNode;
+}
+interface OperatorNodeConstructor {
+    new (op: string, fn: string, args: MathNode[]): OperatorNode;
+}
+interface ParenthesisNodeConstructor {
+    new (content: MathNode): ParenthesisNode;
+}
+interface SymbolNodeConstructor {
+    new (name: string): SymbolNode;
+}
+interface DerivativeDependencies {
+    typed: TypedFunction;
+    config: ConfigOptions;
+    parse: (expr: string) => MathNode;
+    simplify: (node: MathNode) => MathNode;
+    equal: (a: unknown, b: unknown) => boolean;
+    isZero: (x: unknown) => boolean;
+    numeric: (value: number, type: string) => unknown;
+    ConstantNode: ConstantNodeConstructor;
+    FunctionNode: FunctionNodeConstructor;
+    OperatorNode: OperatorNodeConstructor;
+    ParenthesisNode: ParenthesisNodeConstructor;
+    SymbolNode: SymbolNodeConstructor;
+}
+export declare const createDerivative: import("../utils/factory.js").FactoryFunction<DerivativeDependencies, any>;
+export {};
+//# sourceMappingURL=derivative.d.ts.map

package/dist/algebra/derivative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivative.d.ts","sourceRoot":"","sources":["../../src/algebra/derivative.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,QAAQ,EACR,YAAY,EACZ,UAAU,EACV,eAAe,EACf,YAAY,EACZ,YAAY,EAEb,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGvD,UAAU,uBAAuB;IAC/B,KAAK,KAAK,EAAE,OAAO,GAAG,YAAY,CAAC;CACpC;AAED,UAAU,uBAAuB;IAC/B,KAAK,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,YAAY,CAAC;CACjE;AAED,UAAU,uBAAuB;IAC/B,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,YAAY,CAAC;CAC9D;AAED,UAAU,0BAA0B;IAClC,KAAK,OAAO,EAAE,QAAQ,GAAG,eAAe,CAAC;CAC1C;AAED,UAAU,qBAAqB;IAC7B,KAAK,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;CAChC;AAED,UAAU,sBAAsB;IAC9B,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,aAAa,CAAC;IACtB,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ,CAAC;IAClC,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,QAAQ,CAAC;IACvC,KAAK,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;IAC3C,MAAM,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;IAChC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAClD,YAAY,EAAE,uBAAuB,CAAC;IACtC,YAAY,EAAE,uBAAuB,CAAC;IACtC,YAAY,EAAE,uBAAuB,CAAC;IACtC,eAAe,EAAE,0BAA0B,CAAC;IAC5C,UAAU,EAAE,qBAAqB,CAAC;CACnC;AAkBD,eAAO,MAAM,gBAAgB,4EAwvB5B,CAAC"}

package/dist/algebra/leafCount.d.ts

@@ -0,0 +1,9 @@
+import type { MathNode } from '../utils/node.js';
+import type { TypedFunction } from '../core/function/typed.js';
+interface LeafCountDependencies {
+    parse: (expr: string) => MathNode;
+    typed: TypedFunction;
+}
+export declare const createLeafCount: import("../utils/factory.js").FactoryFunction<LeafCountDependencies, unknown>;
+export {};
+//# sourceMappingURL=leafCount.d.ts.map

package/dist/algebra/leafCount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leafCount.d.ts","sourceRoot":"","sources":["../../src/algebra/leafCount.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D,UAAU,qBAAqB;IAC7B,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ,CAAC;IAClC,KAAK,EAAE,aAAa,CAAC;CACtB;AAKD,eAAO,MAAM,eAAe,+EAkD3B,CAAC"}

package/dist/algebra/lyap.d.ts

@@ -0,0 +1,14 @@
+import type { TypedFunction } from '../core/function/typed.js';
+interface MatrixType {
+    toArray(): unknown[][];
+}
+interface LyapDependencies {
+    typed: TypedFunction;
+    matrix: (arr: unknown[][]) => MatrixType;
+    sylvester: TypedFunction;
+    multiply: TypedFunction;
+    transpose: TypedFunction;
+}
+export declare const createLyap: import("../utils/factory.js").FactoryFunction<LyapDependencies, unknown>;
+export {};
+//# sourceMappingURL=lyap.d.ts.map

package/dist/algebra/lyap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lyap.d.ts","sourceRoot":"","sources":["../../src/algebra/lyap.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D,UAAU,UAAU;IAClB,OAAO,IAAI,OAAO,EAAE,EAAE,CAAC;CACxB;AAED,UAAU,gBAAgB;IACxB,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE,KAAK,UAAU,CAAC;IACzC,SAAS,EAAE,aAAa,CAAC;IACzB,QAAQ,EAAE,aAAa,CAAC;IACxB,SAAS,EAAE,aAAa,CAAC;CAC1B;AAKD,eAAO,MAAM,UAAU,0EAmDtB,CAAC"}

package/dist/algebra/polynomialRoot.d.ts

@@ -0,0 +1,22 @@
+import type { TypedFunction } from '../core/function/typed.js';
+interface MatrixType {
+    toArray(): unknown[];
+}
+interface PolynomialRootDependencies {
+    typed: TypedFunction;
+    isZero: (x: unknown) => boolean;
+    equalScalar: (a: unknown, b: unknown) => boolean;
+    add: TypedFunction;
+    subtract: TypedFunction;
+    multiply: TypedFunction;
+    divide: TypedFunction;
+    sqrt: TypedFunction;
+    unaryMinus: TypedFunction;
+    cbrt: (x: unknown, allRoots?: boolean) => MatrixType;
+    typeOf: (x: unknown) => string;
+    im: (x: unknown) => number;
+    re: (x: unknown) => number;
+}
+export declare const createPolynomialRoot: import("../utils/factory.js").FactoryFunction<PolynomialRootDependencies, unknown>;
+export {};
+//# sourceMappingURL=polynomialRoot.d.ts.map

package/dist/algebra/polynomialRoot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polynomialRoot.d.ts","sourceRoot":"","sources":["../../src/algebra/polynomialRoot.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D,UAAU,UAAU;IAClB,OAAO,IAAI,OAAO,EAAE,CAAC;CACtB;AAED,UAAU,0BAA0B;IAClC,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;IAChC,WAAW,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;IACjD,GAAG,EAAE,aAAa,CAAC;IACnB,QAAQ,EAAE,aAAa,CAAC;IACxB,QAAQ,EAAE,aAAa,CAAC;IACxB,MAAM,EAAE,aAAa,CAAC;IACtB,IAAI,EAAE,aAAa,CAAC;IACpB,UAAU,EAAE,aAAa,CAAC;IAC1B,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,OAAO,KAAK,UAAU,CAAC;IACrD,MAAM,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,MAAM,CAAC;IAC/B,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,MAAM,CAAC;IAC3B,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,MAAM,CAAC;CAC5B;AAmBD,eAAO,MAAM,oBAAoB,oFA+IhC,CAAC"}

package/dist/algebra/rationalize.d.ts

@@ -0,0 +1,43 @@
+import type { MathNode, ConstantNode, SymbolNode, OperatorNode } from '../utils/node.js';
+import type { TypedFunction } from '../core/function/typed.js';
+import type { ConfigOptions } from '../core/config.js';
+interface ConstantNodeConstructor {
+    new (value: unknown): ConstantNode;
+}
+interface OperatorNodeConstructor {
+    new (op: string, fn: string, args: MathNode[]): OperatorNode;
+}
+interface SymbolNodeConstructor {
+    new (name: string): SymbolNode;
+}
+interface RationalizeDependencies {
+    config: ConfigOptions;
+    typed: TypedFunction;
+    equal: TypedFunction;
+    isZero: (x: unknown) => boolean;
+    add: TypedFunction;
+    subtract: TypedFunction;
+    multiply: TypedFunction;
+    divide: TypedFunction;
+    pow: TypedFunction;
+    parse: (expr: string) => MathNode;
+    simplifyConstant: TypedFunction;
+    simplifyCore: TypedFunction;
+    simplify: TypedFunction;
+    fraction?: TypedFunction;
+    bignumber?: TypedFunction;
+    mathWithTransform: Record<string, TypedFunction>;
+    matrix: TypedFunction;
+    AccessorNode: unknown;
+    ArrayNode: unknown;
+    ConstantNode: ConstantNodeConstructor;
+    FunctionNode: unknown;
+    IndexNode: unknown;
+    ObjectNode: unknown;
+    OperatorNode: OperatorNodeConstructor;
+    SymbolNode: SymbolNodeConstructor;
+    ParenthesisNode: unknown;
+}
+export declare const createRationalize: import("../utils/factory.js").FactoryFunction<RationalizeDependencies, unknown>;
+export {};
+//# sourceMappingURL=rationalize.d.ts.map

package/dist/algebra/rationalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rationalize.d.ts","sourceRoot":"","sources":["../../src/algebra/rationalize.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,QAAQ,EACR,YAAY,EACZ,UAAU,EACV,YAAY,EAEb,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGvD,UAAU,uBAAuB;IAC/B,KAAK,KAAK,EAAE,OAAO,GAAG,YAAY,CAAC;CACpC;AAED,UAAU,uBAAuB;IAC/B,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,YAAY,CAAC;CAC9D;AAED,UAAU,qBAAqB;IAC7B,KAAK,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;CAChC;AAED,UAAU,uBAAuB;IAC/B,MAAM,EAAE,aAAa,CAAC;IACtB,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;IAChC,GAAG,EAAE,aAAa,CAAC;IACnB,QAAQ,EAAE,aAAa,CAAC;IACxB,QAAQ,EAAE,aAAa,CAAC;IACxB,MAAM,EAAE,aAAa,CAAC;IACtB,GAAG,EAAE,aAAa,CAAC;IACnB,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ,CAAC;IAClC,gBAAgB,EAAE,aAAa,CAAC;IAChC,YAAY,EAAE,aAAa,CAAC;IAC5B,QAAQ,EAAE,aAAa,CAAC;IACxB,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACjD,MAAM,EAAE,aAAa,CAAC;IACtB,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,uBAAuB,CAAC;IACtC,YAAY,EAAE,OAAO,CAAC;IACtB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;IACpB,YAAY,EAAE,uBAAuB,CAAC;IACtC,UAAU,EAAE,qBAAqB,CAAC;IAClC,eAAe,EAAE,OAAO,CAAC;CAC1B;AAgCD,eAAO,MAAM,iBAAiB,iFAwqB7B,CAAC"}

package/dist/algebra/resolve.d.ts

@@ -0,0 +1,25 @@
+import type { MathNode } from '../utils/node.js';
+import type { TypedFunction } from '../core/function/typed.js';
+interface ConstantNodeConstructor {
+    new (value: unknown): MathNode;
+}
+interface FunctionNodeConstructor {
+    new (name: string, args: MathNode[]): MathNode;
+}
+interface OperatorNodeConstructor {
+    new (op: string, fn: string, args: MathNode[], implicit: boolean): MathNode;
+}
+interface ParenthesisNodeConstructor {
+    new (content: MathNode): MathNode;
+}
+interface ResolveDependencies {
+    typed: TypedFunction;
+    parse: (expr: string) => MathNode;
+    ConstantNode: ConstantNodeConstructor;
+    FunctionNode: FunctionNodeConstructor;
+    OperatorNode: OperatorNodeConstructor;
+    ParenthesisNode: ParenthesisNodeConstructor;
+}
+export declare const createResolve: import("../utils/factory.js").FactoryFunction<ResolveDependencies, unknown>;
+export {};
+//# sourceMappingURL=resolve.d.ts.map

package/dist/algebra/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/algebra/resolve.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAuB/D,UAAU,uBAAuB;IAC/B,KAAK,KAAK,EAAE,OAAO,GAAG,QAAQ,CAAC;CAChC;AAED,UAAU,uBAAuB;IAC/B,KAAK,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,QAAQ,CAAC;CAChD;AAED,UAAU,uBAAuB;IAC/B,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE,QAAQ,EAAE,OAAO,GAAG,QAAQ,CAAC;CAC7E;AAED,UAAU,0BAA0B;IAClC,KAAK,OAAO,EAAE,QAAQ,GAAG,QAAQ,CAAC;CACnC;AAED,UAAU,mBAAmB;IAC3B,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ,CAAC;IAClC,YAAY,EAAE,uBAAuB,CAAC;IACtC,YAAY,EAAE,uBAAuB,CAAC;IACtC,YAAY,EAAE,uBAAuB,CAAC;IACtC,eAAe,EAAE,0BAA0B,CAAC;CAC7C;AAYD,eAAO,MAAM,aAAa,6EA6HzB,CAAC"}

package/dist/algebra/simplify/util.d.ts

@@ -0,0 +1,35 @@
+import type { MathNode, FunctionNode, OperatorNode } from '../../utils/node.js';
+type OperatorContext = Record<string, Record<string, boolean>>;
+export declare const createUtil: import("../../utils/factory.js").FactoryFunction<{
+    FunctionNode: any;
+    OperatorNode: any;
+    SymbolNode: any;
+}, {
+    createMakeNodeFunction: (node: (OperatorNode & {
+        implicit?: boolean;
+    }) | (FunctionNode & {
+        name: string;
+    })) => (args: MathNode[]) => MathNode;
+    hasProperty: (nodeOrName: string | MathNode, property: string, context?: OperatorContext) => boolean;
+    isCommutative: (node: string | MathNode, context?: OperatorContext) => boolean;
+    isAssociative: (node: string | MathNode, context?: OperatorContext) => boolean;
+    mergeContext: (primary: OperatorContext | undefined, secondary: OperatorContext | undefined) => OperatorContext;
+    flatten: (node: MathNode & {
+        args?: MathNode[];
+    }, context: OperatorContext) => void;
+    allChildren: (node: MathNode & {
+        args?: MathNode[];
+        op?: string;
+    }, context: OperatorContext) => MathNode[];
+    unflattenr: (node: MathNode & {
+        args?: MathNode[];
+    }, context: OperatorContext) => void;
+    unflattenl: (node: MathNode & {
+        args?: MathNode[];
+    }, context: OperatorContext) => void;
+    defaultContext: OperatorContext;
+    realContext: OperatorContext;
+    positiveContext: OperatorContext;
+}>;
+export {};
+//# sourceMappingURL=util.d.ts.map

package/dist/algebra/simplify/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/algebra/simplify/util.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAKhF,KAAK,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAE/D,eAAO,MAAM,UAAU;kBAQL,GAAG;kBACH,GAAG;gBACL,GAAG;;mCAiMP,CAAC,YAAY,GAAG;QAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC,GAAG,CAAC,YAAY,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,KAChF,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,QAAQ;8BAlKnB,MAAM,GAAG,QAAQ,YACnB,MAAM,YACP,eAAe,KACvB,OAAO;0BAuCF,MAAM,GAAG,QAAQ,YACd,eAAe,KACvB,OAAO;0BAKF,MAAM,GAAG,QAAQ,YACd,eAAe,KACvB,OAAO;4BASC,eAAe,GAAG,SAAS,aACzB,eAAe,GAAG,SAAS,KACrC,eAAe;oBAgBK,QAAQ,GAAG;QAAE,IAAI,CAAC,EAAE,QAAQ,EAAE,CAAA;KAAE,WAAW,eAAe,KAAG,IAAI;wBAehF,QAAQ,GAAG;QAAE,IAAI,CAAC,EAAE,QAAQ,EAAE,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,WAC1C,eAAe,KACvB,QAAQ,EAAE;uBA0Ba,QAAQ,GAAG;QAAE,IAAI,CAAC,EAAE,QAAQ,EAAE,CAAA;KAAE,WAAW,eAAe,KAAG,IAAI;uBAqBjE,QAAQ,GAAG;QAAE,IAAI,CAAC,EAAE,QAAQ,EAAE,CAAA;KAAE,WAAW,eAAe,KAAG,IAAI;;;;EAoD9F,CAAC"}

package/dist/algebra/simplify/wildcards.d.ts

@@ -0,0 +1,5 @@
+export { isConstantNode, isSymbolNode as isVariableNode } from '../../utils/is.js';
+import type { MathNode } from '../../utils/node.js';
+export declare function isNumericNode(x: MathNode): boolean;
+export declare function isConstantExpression(x: MathNode): boolean;
+//# sourceMappingURL=wildcards.d.ts.map

package/dist/algebra/simplify/wildcards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wildcards.d.ts","sourceRoot":"","sources":["../../../src/algebra/simplify/wildcards.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,cAAc,EAAE,YAAY,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAEpD,wBAAgB,aAAa,CAAC,CAAC,EAAE,QAAQ,GAAG,OAAO,CAKlD;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,QAAQ,GAAG,OAAO,CAczD"}

package/dist/algebra/simplify.d.ts

@@ -0,0 +1,57 @@
+import type { MathNode, SymbolNode, IndexNode } from '../utils/node.js';
+import type { TypedFunction } from '../core/function/typed.js';
+interface AccessorNodeConstructor {
+    new (object: MathNode, index: IndexNode): MathNode;
+}
+interface ArrayNodeConstructor {
+    new (items: MathNode[]): MathNode;
+}
+interface ConstantNodeConstructor {
+    new (value: unknown): MathNode;
+}
+interface FunctionNodeConstructor {
+    new (name: string, args: MathNode[]): MathNode;
+}
+interface IndexNodeConstructor {
+    new (dimensions: MathNode[]): MathNode;
+}
+interface ObjectNodeConstructor {
+    new (properties: Record<string, MathNode>): MathNode;
+}
+interface OperatorNodeConstructor {
+    new (op: string, fn: string, args: MathNode[]): MathNode;
+}
+interface ParenthesisNodeConstructor {
+    new (content: MathNode): MathNode;
+}
+interface SymbolNodeConstructor {
+    new (name: string): SymbolNode;
+}
+interface SimplifyDependencies {
+    typed: TypedFunction;
+    parse: (expr: string) => MathNode;
+    equal: (a: unknown, b: unknown) => boolean;
+    resolve: (node: MathNode, scope?: Map<string, unknown> | null) => MathNode;
+    simplifyConstant: (node: MathNode, options?: SimplifyOptions) => MathNode;
+    simplifyCore: (node: MathNode, options?: SimplifyOptions) => MathNode;
+    AccessorNode: AccessorNodeConstructor;
+    ArrayNode: ArrayNodeConstructor;
+    ConstantNode: ConstantNodeConstructor;
+    FunctionNode: FunctionNodeConstructor;
+    IndexNode: IndexNodeConstructor;
+    ObjectNode: ObjectNodeConstructor;
+    OperatorNode: OperatorNodeConstructor;
+    ParenthesisNode: ParenthesisNodeConstructor;
+    SymbolNode: SymbolNodeConstructor;
+    replacer: (key: string, value: unknown) => unknown;
+}
+type SimplifyOptions = {
+    consoleDebug?: boolean;
+    context?: SimplifyContext;
+    exactFractions?: boolean;
+    fractionsLimit?: number;
+};
+type SimplifyContext = Record<string, Record<string, boolean>>;
+export declare const createSimplify: import("../utils/factory.js").FactoryFunction<SimplifyDependencies, any>;
+export {};
+//# sourceMappingURL=simplify.d.ts.map

package/dist/algebra/simplify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simplify.d.ts","sourceRoot":"","sources":["../../src/algebra/simplify.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EACV,QAAQ,EACR,UAAU,EAMV,SAAS,EAEV,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D,UAAU,uBAAuB;IAC/B,KAAK,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,GAAG,QAAQ,CAAC;CACpD;AAED,UAAU,oBAAoB;IAC5B,KAAK,KAAK,EAAE,QAAQ,EAAE,GAAG,QAAQ,CAAC;CACnC;AAED,UAAU,uBAAuB;IAC/B,KAAK,KAAK,EAAE,OAAO,GAAG,QAAQ,CAAC;CAChC;AAED,UAAU,uBAAuB;IAC/B,KAAK,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,QAAQ,CAAC;CAChD;AAED,UAAU,oBAAoB;IAC5B,KAAK,UAAU,EAAE,QAAQ,EAAE,GAAG,QAAQ,CAAC;CACxC;AAED,UAAU,qBAAqB;IAC7B,KAAK,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAC;CACtD;AAED,UAAU,uBAAuB;IAC/B,KAAK,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,QAAQ,CAAC;CAC1D;AAED,UAAU,0BAA0B;IAClC,KAAK,OAAO,EAAE,QAAQ,GAAG,QAAQ,CAAC;CACnC;AAED,UAAU,qBAAqB;IAC7B,KAAK,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;CAChC;AAED,UAAU,oBAAoB;IAC5B,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ,CAAC;IAClC,KAAK,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;IAC3C,OAAO,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,KAAK,QAAQ,CAAC;IAC3E,gBAAgB,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,eAAe,KAAK,QAAQ,CAAC;IAC1E,YAAY,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,eAAe,KAAK,QAAQ,CAAC;IACtE,YAAY,EAAE,uBAAuB,CAAC;IACtC,SAAS,EAAE,oBAAoB,CAAC;IAChC,YAAY,EAAE,uBAAuB,CAAC;IACtC,YAAY,EAAE,uBAAuB,CAAC;IACtC,SAAS,EAAE,oBAAoB,CAAC;IAChC,UAAU,EAAE,qBAAqB,CAAC;IAClC,YAAY,EAAE,uBAAuB,CAAC;IACtC,eAAe,EAAE,0BAA0B,CAAC;IAC5C,UAAU,EAAE,qBAAqB,CAAC;IAClC,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;CACpD;AAsCD,KAAK,eAAe,GAAG;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,KAAK,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AA+B/D,eAAO,MAAM,cAAc,0EA2mC1B,CAAC"}

package/dist/algebra/simplifyConstant.d.ts

@@ -0,0 +1,20 @@
+import type { MathNode } from '../utils/node.js';
+export declare const createSimplifyConstant: import("../utils/factory.js").FactoryFunction<{
+    typed: any;
+    config: any;
+    mathWithTransform: any;
+    matrix: any;
+    parse: (expr: string) => MathNode;
+    isBounded: any;
+    fraction: any;
+    bignumber: any;
+    AccessorNode: any;
+    ArrayNode: any;
+    ConstantNode: any;
+    FunctionNode: any;
+    IndexNode: any;
+    ObjectNode: any;
+    OperatorNode: any;
+    SymbolNode: any;
+}, any>;
+//# sourceMappingURL=simplifyConstant.d.ts.map

package/dist/algebra/simplifyConstant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simplifyConstant.d.ts","sourceRoot":"","sources":["../../src/algebra/simplifyConstant.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EACV,QAAQ,EAST,MAAM,kBAAkB,CAAC;AAsB1B,eAAO,MAAM,sBAAsB;WAqBxB,GAAG;YACF,GAAG;uBACQ,GAAG;YACd,GAAG;WACJ,CAAC,IAAI,EAAE,MAAM,KAAK,QAAQ;eACtB,GAAG;cACJ,GAAG;eACF,GAAG;kBACA,GAAG;eACN,GAAG;kBACA,GAAG;kBACH,GAAG;eACN,GAAG;gBACF,GAAG;kBACD,GAAG;gBACL,GAAG;OAkflB,CAAC"}

package/dist/algebra/simplifyCore.d.ts

@@ -0,0 +1,21 @@
+export declare const createSimplifyCore: import("../utils/factory.js").FactoryFunction<{
+    typed: any;
+    parse: any;
+    equal: any;
+    isZero: any;
+    add: any;
+    subtract: any;
+    multiply: any;
+    divide: any;
+    pow: any;
+    AccessorNode: any;
+    ArrayNode: any;
+    ConstantNode: any;
+    FunctionNode: any;
+    IndexNode: any;
+    ObjectNode: any;
+    OperatorNode: any;
+    ParenthesisNode: any;
+    SymbolNode: any;
+}, any>;
+//# sourceMappingURL=simplifyCore.d.ts.map

package/dist/algebra/simplifyCore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simplifyCore.d.ts","sourceRoot":"","sources":["../../src/algebra/simplifyCore.ts"],"names":[],"mappings":"AAsCA,eAAO,MAAM,kBAAkB;WAuBpB,GAAG;WACH,GAAG;WACH,GAAG;YACF,GAAG;SACN,GAAG;cACE,GAAG;cACH,GAAG;YACL,GAAG;SACN,GAAG;kBACM,GAAG;eACN,GAAG;kBACA,GAAG;kBACH,GAAG;eACN,GAAG;gBACF,GAAG;kBACD,GAAG;qBACA,GAAG;gBACR,GAAG;OAiRlB,CAAC"}