@danielsimonjr/mathts-functions 0.2.3 → 0.2.4

package/dist/bitwise/rightArithShift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rightArithShift.d.ts","sourceRoot":"","sources":["../../src/bitwise/rightArithShift.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D,UAAU,MAAM;IACd,IAAI,IAAI,MAAM,EAAE,CAAC;IACjB,OAAO,IAAI,MAAM,CAAC;IAClB,KAAK,IAAI,MAAM,CAAC;CACjB;AAED,UAAU,2BAA2B;IACnC,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,MAAM,CAAC;IACpC,WAAW,EAAE,aAAa,CAAC;IAC3B,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IACpD,WAAW,EAAE,KAAK,IAAI,EAAE,OAAO,KAAK,MAAM,CAAC;IAC3C,MAAM,EAAE,aAAa,CAAC;CACvB;AAKD,eAAO,MAAM,qBAAqB,qFAwGjC,CAAC"}

package/dist/bitwise/rightLogShift.d.ts

@@ -0,0 +1,17 @@
+import type { TypedFunction } from '../core/function/typed.js';
+interface Matrix {
+    size(): number[];
+    storage(): string;
+    clone(): Matrix;
+}
+interface RightLogShiftDependencies {
+    typed: TypedFunction;
+    matrix: (data: unknown[]) => Matrix;
+    equalScalar: TypedFunction;
+    zeros: (size: number[], storage?: string) => Matrix;
+    DenseMatrix: new (data: unknown) => Matrix;
+    concat: TypedFunction;
+}
+export declare const createRightLogShift: import("../utils/factory.js").FactoryFunction<RightLogShiftDependencies, unknown>;
+export {};
+//# sourceMappingURL=rightLogShift.d.ts.map

package/dist/bitwise/rightLogShift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rightLogShift.d.ts","sourceRoot":"","sources":["../../src/bitwise/rightLogShift.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D,UAAU,MAAM;IACd,IAAI,IAAI,MAAM,EAAE,CAAC;IACjB,OAAO,IAAI,MAAM,CAAC;IAClB,KAAK,IAAI,MAAM,CAAC;CACjB;AAED,UAAU,yBAAyB;IACjC,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,MAAM,CAAC;IACpC,WAAW,EAAE,aAAa,CAAC;IAC3B,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IACpD,WAAW,EAAE,KAAK,IAAI,EAAE,OAAO,KAAK,MAAM,CAAC;IAC3C,MAAM,EAAE,aAAa,CAAC;CACvB;AAKD,eAAO,MAAM,mBAAmB,mFAuG/B,CAAC"}

package/dist/bitwise/useMatrixForArrayScalar.d.ts

@@ -0,0 +1,19 @@
+import type { TypedFunction } from '../core/function/typed.js';
+interface Matrix {
+    valueOf(): unknown[][];
+}
+interface MatrixConstructor {
+    (data: unknown[]): Matrix;
+}
+interface UseMatrixDependencies {
+    typed: TypedFunction;
+    matrix: MatrixConstructor;
+}
+export declare const createUseMatrixForArrayScalar: import("../utils/factory.js").FactoryFunction<UseMatrixDependencies, {
+    'Array, number': any;
+    'Array, BigNumber': any;
+    'number, Array': any;
+    'BigNumber, Array': any;
+}>;
+export {};
+//# sourceMappingURL=useMatrixForArrayScalar.d.ts.map

package/dist/bitwise/useMatrixForArrayScalar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMatrixForArrayScalar.d.ts","sourceRoot":"","sources":["../../src/bitwise/useMatrixForArrayScalar.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAO/D,UAAU,MAAM;IACd,OAAO,IAAI,OAAO,EAAE,EAAE,CAAC;CACxB;AAED,UAAU,iBAAiB;IACzB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC;CAC3B;AAED,UAAU,qBAAqB;IAC7B,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,EAAE,iBAAiB,CAAC;CAC3B;AAED,eAAO,MAAM,6BAA6B;;;;;EAgCzC,CAAC"}

package/dist/combinatorics/bellNumbers.d.ts

@@ -0,0 +1,14 @@
+import type { TypedFunction } from '../core/function/typed.js';
+interface BigNumberType {
+}
+type NumericValue = number | BigNumberType;
+interface BellNumbersDependencies {
+    typed: TypedFunction;
+    addScalar: (x: NumericValue, y: NumericValue) => NumericValue;
+    isNegative: (x: NumericValue) => boolean;
+    isInteger: (x: NumericValue) => boolean;
+    stirlingS2: (n: NumericValue, k: NumericValue) => NumericValue;
+}
+export declare const createBellNumbers: import("../utils/factory.js").FactoryFunction<BellNumbersDependencies, unknown>;
+export {};
+//# sourceMappingURL=bellNumbers.d.ts.map

package/dist/combinatorics/bellNumbers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bellNumbers.d.ts","sourceRoot":"","sources":["../../src/combinatorics/bellNumbers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D,UAAU,aAAa;CAEtB;AAED,KAAK,YAAY,GAAG,MAAM,GAAG,aAAa,CAAC;AAE3C,UAAU,uBAAuB;IAC/B,KAAK,EAAE,aAAa,CAAC;IACrB,SAAS,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;IAC9D,UAAU,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC;IACxC,UAAU,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;CAChE;AAKD,eAAO,MAAM,iBAAiB,iFAyC7B,CAAC"}

package/dist/combinatorics/catalan.d.ts

@@ -0,0 +1,16 @@
+import type { TypedFunction } from '../core/function/typed.js';
+interface BigNumberType {
+}
+type NumericValue = number | BigNumberType;
+interface CatalanDependencies {
+    typed: TypedFunction;
+    addScalar: (x: NumericValue, y: NumericValue) => NumericValue;
+    divideScalar: (x: NumericValue, y: NumericValue) => NumericValue;
+    multiplyScalar: (x: NumericValue, y: NumericValue) => NumericValue;
+    combinations: (n: NumericValue, k: NumericValue) => NumericValue;
+    isNegative: (x: NumericValue) => boolean;
+    isInteger: (x: NumericValue) => boolean;
+}
+export declare const createCatalan: import("../utils/factory.js").FactoryFunction<CatalanDependencies, unknown>;
+export {};
+//# sourceMappingURL=catalan.d.ts.map

package/dist/combinatorics/catalan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalan.d.ts","sourceRoot":"","sources":["../../src/combinatorics/catalan.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D,UAAU,aAAa;CAEtB;AAED,KAAK,YAAY,GAAG,MAAM,GAAG,aAAa,CAAC;AAE3C,UAAU,mBAAmB;IAC3B,KAAK,EAAE,aAAa,CAAC;IACrB,SAAS,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;IAC9D,YAAY,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;IACjE,cAAc,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;IACnE,YAAY,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;IACjE,UAAU,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC;CACzC;AAaD,eAAO,MAAM,aAAa,6EA2CzB,CAAC"}

package/dist/combinatorics/composition.d.ts

@@ -0,0 +1,16 @@
+import type { TypedFunction } from '../core/function/typed.js';
+interface BigNumberType {
+}
+type NumericValue = number | BigNumberType;
+interface CompositionDependencies {
+    typed: TypedFunction;
+    addScalar: (x: NumericValue, y: NumericValue) => NumericValue;
+    combinations: (n: NumericValue, k: NumericValue) => NumericValue;
+    isPositive: (x: NumericValue) => boolean;
+    isNegative: (x: NumericValue) => boolean;
+    isInteger: (x: NumericValue) => boolean;
+    larger: (x: NumericValue, y: NumericValue) => boolean;
+}
+export declare const createComposition: import("../utils/factory.js").FactoryFunction<CompositionDependencies, unknown>;
+export {};
+//# sourceMappingURL=composition.d.ts.map

package/dist/combinatorics/composition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composition.d.ts","sourceRoot":"","sources":["../../src/combinatorics/composition.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D,UAAU,aAAa;CAEtB;AAED,KAAK,YAAY,GAAG,MAAM,GAAG,aAAa,CAAC;AAE3C,UAAU,uBAAuB;IAC/B,KAAK,EAAE,aAAa,CAAC;IACrB,SAAS,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;IAC9D,YAAY,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;IACjE,UAAU,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC;IACzC,UAAU,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC;IACxC,MAAM,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC;CACvD;AAaD,eAAO,MAAM,iBAAiB,iFAiD7B,CAAC"}

package/dist/combinatorics/stirlingS2.d.ts

@@ -0,0 +1,22 @@
+import type { TypedFunction } from '../core/function/typed.js';
+interface BigNumberType {
+}
+type NumericValue = number | BigNumberType;
+interface StirlingS2Dependencies {
+    typed: TypedFunction;
+    addScalar: (x: NumericValue, y: NumericValue) => NumericValue;
+    subtractScalar: (x: NumericValue, y: NumericValue) => NumericValue;
+    multiplyScalar: (x: NumericValue, y: NumericValue) => NumericValue;
+    divideScalar: (x: NumericValue, y: NumericValue) => NumericValue;
+    pow: (x: NumericValue, y: NumericValue) => NumericValue;
+    factorial: (x: NumericValue) => NumericValue;
+    combinations: (n: NumericValue, k: NumericValue) => NumericValue;
+    isNegative: (x: NumericValue) => boolean;
+    isInteger: (x: NumericValue) => boolean;
+    number: (x: NumericValue) => number;
+    bignumber?: (x: NumericValue) => BigNumberType;
+    larger: (x: NumericValue, y: NumericValue) => boolean;
+}
+export declare const createStirlingS2: import("../utils/factory.js").FactoryFunction<StirlingS2Dependencies, unknown>;
+export {};
+//# sourceMappingURL=stirlingS2.d.ts.map

package/dist/combinatorics/stirlingS2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stirlingS2.d.ts","sourceRoot":"","sources":["../../src/combinatorics/stirlingS2.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D,UAAU,aAAa;CAEtB;AAED,KAAK,YAAY,GAAG,MAAM,GAAG,aAAa,CAAC;AAE3C,UAAU,sBAAsB;IAC9B,KAAK,EAAE,aAAa,CAAC;IACrB,SAAS,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;IAC9D,cAAc,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;IACnE,cAAc,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;IACnE,YAAY,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;IACjE,GAAG,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;IACxD,SAAS,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;IAC7C,YAAY,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;IACjE,UAAU,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC;IACzC,SAAS,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC;IACxC,MAAM,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,MAAM,CAAC;IACpC,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,aAAa,CAAC;IAC/C,MAAM,EAAE,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC;CACvD;AAmBD,eAAO,MAAM,gBAAgB,gFAwF5B,CAAC"}

package/dist/complex/arg.d.ts

@@ -0,0 +1,7 @@
+import type { TypedFunction } from '../core/function/typed.js';
+interface ArgDependencies {
+    typed: TypedFunction;
+}
+export declare const createArg: import("../utils/factory.js").FactoryFunction<ArgDependencies, unknown>;
+export {};
+//# sourceMappingURL=arg.d.ts.map

package/dist/complex/arg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arg.d.ts","sourceRoot":"","sources":["../../src/complex/arg.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAa/D,UAAU,eAAe;IACvB,KAAK,EAAE,aAAa,CAAC;CACtB;AAKD,eAAO,MAAM,SAAS,yEAmDrB,CAAC"}

package/dist/complex/conj.d.ts

@@ -0,0 +1,7 @@
+import type { TypedFunction } from '../core/function/typed.js';
+interface ConjDependencies {
+    typed: TypedFunction;
+}
+export declare const createConj: import("../utils/factory.js").FactoryFunction<ConjDependencies, unknown>;
+export {};
+//# sourceMappingURL=conj.d.ts.map

package/dist/complex/conj.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conj.d.ts","sourceRoot":"","sources":["../../src/complex/conj.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAe/D,UAAU,gBAAgB;IACxB,KAAK,EAAE,aAAa,CAAC;CACtB;AAKD,eAAO,MAAM,UAAU,0EA4CtB,CAAC"}

package/dist/complex/im.d.ts

@@ -0,0 +1,7 @@
+import type { TypedFunction } from '../core/function/typed.js';
+interface ImDependencies {
+    typed: TypedFunction;
+}
+export declare const createIm: import("../utils/factory.js").FactoryFunction<ImDependencies, unknown>;
+export {};
+//# sourceMappingURL=im.d.ts.map

package/dist/complex/im.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"im.d.ts","sourceRoot":"","sources":["../../src/complex/im.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAe/D,UAAU,cAAc;IACtB,KAAK,EAAE,aAAa,CAAC;CACtB;AAKD,eAAO,MAAM,QAAQ,wEAqCnB,CAAC"}

package/dist/complex/re.d.ts

@@ -0,0 +1,7 @@
+import type { TypedFunction } from '../core/function/typed.js';
+interface ReDependencies {
+    typed: TypedFunction;
+}
+export declare const createRe: import("../utils/factory.js").FactoryFunction<ReDependencies, unknown>;
+export {};
+//# sourceMappingURL=re.d.ts.map

package/dist/complex/re.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"re.d.ts","sourceRoot":"","sources":["../../src/complex/re.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAe/D,UAAU,cAAc;IACtB,KAAK,EAAE,aAAa,CAAC;CACtB;AAKD,eAAO,MAAM,QAAQ,wEAqCnB,CAAC"}

package/dist/core/config.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Configuration interface for math.js
+ */
+export interface ConfigOptions {
+    relTol: number;
+    absTol: number;
+    matrix: 'Matrix' | 'Array';
+    number: 'number' | 'BigNumber' | 'bigint' | 'Fraction';
+    numberFallback: 'number' | 'BigNumber';
+    precision: number;
+    predictable: boolean;
+    randomSeed: string | null;
+    legacySubset: boolean;
+}
+export type MathJsConfig = ConfigOptions;
+export declare const DEFAULT_CONFIG: ConfigOptions;
+//# sourceMappingURL=config.d.ts.map

package/dist/core/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/core/config.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,aAAa;IAG5B,MAAM,EAAE,MAAM,CAAC;IAIf,MAAM,EAAE,MAAM,CAAC;IAGf,MAAM,EAAE,QAAQ,GAAG,OAAO,CAAC;IAG3B,MAAM,EAAE,QAAQ,GAAG,WAAW,GAAG,QAAQ,GAAG,UAAU,CAAC;IAIvD,cAAc,EAAE,QAAQ,GAAG,WAAW,CAAC;IAGvC,SAAS,EAAE,MAAM,CAAC;IAMlB,WAAW,EAAE,OAAO,CAAC;IAIrB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAK1B,YAAY,EAAE,OAAO,CAAC;CACvB;AAGD,MAAM,MAAM,YAAY,GAAG,aAAa,CAAC;AAEzC,eAAO,MAAM,cAAc,EAAE,aAoC5B,CAAC"}

package/dist/core/create.d.ts

@@ -0,0 +1,137 @@
+import typedFunction from 'typed-function';
+import { ArgumentsError } from '../error/ArgumentsError.js';
+import { DimensionError } from '../error/DimensionError.js';
+import { IndexError } from '../error/IndexError.js';
+import { factory } from '../utils/factory.js';
+import type { FactoryFunction, LegacyFactory } from '../utils/factory.js';
+import { isAccessorNode, isArray, isArrayNode, isAssignmentNode, isBigInt, isBigNumber, isBlockNode, isBoolean, isChain, isCollection, isComplex, isConditionalNode, isConstantNode, isDate, isDenseMatrix, isFraction, isFunction, isFunctionAssignmentNode, isFunctionNode, isHelp, isIndex, isIndexNode, isMap, isMatrix, isNode, isNull, isNumber, isObject, isObjectNode, isOperatorNode, isParenthesisNode, isPartitionedMap, isRange, isRangeNode, isRegExp, isRelationalNode, isResultSet, isSparseMatrix, isString, isSymbolNode, isUndefined, isUnit } from '../utils/is.js';
+import { isObjectWrappingMap } from '../utils/map.js';
+import type { ConfigOptions, MathJsConfig } from './config.js';
+export type { MathJsConfig };
+/**
+ * Type for the mathjs instance
+ */
+export interface MathJsInstance {
+    isNumber: typeof isNumber;
+    isComplex: typeof isComplex;
+    isBigNumber: typeof isBigNumber;
+    isBigInt: typeof isBigInt;
+    isFraction: typeof isFraction;
+    isUnit: typeof isUnit;
+    isString: typeof isString;
+    isArray: typeof isArray;
+    isMatrix: typeof isMatrix;
+    isCollection: typeof isCollection;
+    isDenseMatrix: typeof isDenseMatrix;
+    isSparseMatrix: typeof isSparseMatrix;
+    isRange: typeof isRange;
+    isIndex: typeof isIndex;
+    isBoolean: typeof isBoolean;
+    isResultSet: typeof isResultSet;
+    isHelp: typeof isHelp;
+    isFunction: typeof isFunction;
+    isDate: typeof isDate;
+    isRegExp: typeof isRegExp;
+    isObject: typeof isObject;
+    isMap: typeof isMap;
+    isPartitionedMap: typeof isPartitionedMap;
+    isObjectWrappingMap: typeof isObjectWrappingMap;
+    isNull: typeof isNull;
+    isUndefined: typeof isUndefined;
+    isAccessorNode: typeof isAccessorNode;
+    isArrayNode: typeof isArrayNode;
+    isAssignmentNode: typeof isAssignmentNode;
+    isBlockNode: typeof isBlockNode;
+    isConditionalNode: typeof isConditionalNode;
+    isConstantNode: typeof isConstantNode;
+    isFunctionAssignmentNode: typeof isFunctionAssignmentNode;
+    isFunctionNode: typeof isFunctionNode;
+    isIndexNode: typeof isIndexNode;
+    isNode: typeof isNode;
+    isObjectNode: typeof isObjectNode;
+    isOperatorNode: typeof isOperatorNode;
+    isParenthesisNode: typeof isParenthesisNode;
+    isRangeNode: typeof isRangeNode;
+    isRelationalNode: typeof isRelationalNode;
+    isSymbolNode: typeof isSymbolNode;
+    isChain: typeof isChain;
+    config: (config?: Partial<ConfigOptions>) => ConfigOptions;
+    import: (factories: any, options?: ImportOptions) => void;
+    create: (factories?: FactoriesInput, config?: Partial<ConfigOptions>) => MathJsInstance;
+    factory: typeof factory;
+    typed: typeof typedFunction & {
+        isTypedFunction?: (value: any) => boolean;
+    };
+    ArgumentsError: typeof ArgumentsError;
+    DimensionError: typeof DimensionError;
+    IndexError: typeof IndexError;
+    expression: {
+        transform: Record<string, any>;
+        mathWithTransform: {
+            config: (config?: Partial<ConfigOptions>) => ConfigOptions;
+            [key: string]: any;
+        };
+    };
+    type?: Record<string, any>;
+    on: (event: string, callback: (...args: any[]) => void) => MathJsInstance;
+    off: (event: string, callback: (...args: any[]) => void) => MathJsInstance;
+    once: (event: string, callback: (...args: any[]) => void) => MathJsInstance;
+    emit: (event: string, ...args: any[]) => MathJsInstance;
+    [key: string]: any;
+}
+/**
+ * Input type for factories
+ */
+export type FactoriesInput = Record<string, FactoryFunction | LegacyFactory> | Array<FactoryFunction | LegacyFactory> | FactoryFunction | LegacyFactory;
+/**
+ * Options for the import function
+ */
+export interface ImportOptions {
+    override?: boolean;
+    silent?: boolean;
+    wrap?: boolean;
+}
+/**
+ * Create a mathjs instance from given factory functions and optionally config
+ *
+ * Usage:
+ *
+ *     const mathjs1 = create({ createAdd, createMultiply, ...})
+ *     const config = { number: 'BigNumber' }
+ *     const mathjs2 = create(all, config)
+ *
+ * @param factories An object with factory functions.
+ *                  The object can contain nested objects,
+ *                  all nested objects will be flattened.
+ * @param config    Available options:
+ *                  {number} relTol
+ *                    Minimum relative difference between two
+ *                    compared values, used by all comparison functions.
+ *                  {number} absTol
+ *                    Minimum absolute difference between two
+ *                    compared values, used by all comparison functions.
+ *                  {string} matrix
+ *                    A string 'Matrix' (default) or 'Array'.
+ *                  {string} number
+ *                    A string 'number' (default), 'BigNumber', or 'Fraction'
+ *                  {number} precision
+ *                    The number of significant digits for BigNumbers.
+ *                    Not applicable for Numbers.
+ *                  {boolean} predictable
+ *                    Predictable output type of functions. When true,
+ *                    output type depends only on the input types. When
+ *                    false (default), output type can vary depending
+ *                    on input values. For example `math.sqrt(-4)`
+ *                    returns `complex('2i')` when predictable is false, and
+ *                    returns `NaN` when true.
+ *                  {string} randomSeed
+ *                    Random seed for seeded pseudo random number generator.
+ *                    Set to null to randomly seed.
+ * @returns Returns a bare-bone math.js instance containing
+ *          functions:
+ *          - `import` to add new functions
+ *          - `config` to change configuration
+ *          - `on`, `off`, `once`, `emit` for events
+ */
+export declare function create(factories?: FactoriesInput, config?: Partial<ConfigOptions>): MathJsInstance;
+//# sourceMappingURL=create.d.ts.map

package/dist/core/create.d.ts.map

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

package/dist/core/function/config.d.ts

@@ -0,0 +1,35 @@
+import { MathJsConfig } from '../config.js';
+export declare const MATRIX_OPTIONS: readonly ["Matrix", "Array"];
+export declare const NUMBER_OPTIONS: readonly ["number", "BigNumber", "bigint", "Fraction"];
+export type MatrixOption = (typeof MATRIX_OPTIONS)[number];
+export type NumberOption = (typeof NUMBER_OPTIONS)[number];
+/**
+ * Type for partial config options
+ */
+export type ConfigOptions = Partial<MathJsConfig> & {
+    epsilon?: number;
+};
+/**
+ * Type for the config function
+ */
+export interface ConfigFunction {
+    (): MathJsConfig;
+    (options: ConfigOptions): MathJsConfig;
+    MATRIX_OPTIONS: readonly string[];
+    NUMBER_OPTIONS: readonly string[];
+    readonly relTol: number;
+    readonly absTol: number;
+    readonly matrix: MatrixOption;
+    readonly number: NumberOption;
+    readonly numberFallback: 'number' | 'BigNumber';
+    readonly precision: number;
+    readonly predictable: boolean;
+    readonly randomSeed: string | null;
+    readonly legacySubset: boolean;
+}
+/**
+ * Type for the emit function
+ */
+export type EmitFunction = (event: string, curr: MathJsConfig, prev: MathJsConfig, changes: Partial<MathJsConfig>) => void;
+export declare function configFactory(config: MathJsConfig, emit: EmitFunction): ConfigFunction;
+//# sourceMappingURL=config.d.ts.map

package/dist/core/function/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/core/function/config.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,YAAY,EAAE,MAAM,cAAc,CAAC;AAE5D,eAAO,MAAM,cAAc,8BAA+B,CAAC;AAC3D,eAAO,MAAM,cAAc,wDAAyD,CAAC;AAErF,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAC3D,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,GAAG;IAElD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,YAAY,CAAC;IACjB,CAAC,OAAO,EAAE,aAAa,GAAG,YAAY,CAAC;IACvC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,cAAc,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,cAAc,EAAE,QAAQ,GAAG,WAAW,CAAC;IAChD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,CACzB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,YAAY,EAClB,OAAO,EAAE,OAAO,CAAC,YAAY,CAAC,KAC3B,IAAI,CAAC;AAEV,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,YAAY,GAAG,cAAc,CAqGtF"}

package/dist/core/function/import.d.ts

@@ -0,0 +1,30 @@
+import { FactoryFunction } from '../../utils/factory.js';
+import type { TypedFunction } from './typed.js';
+/**
+ * Options for the import function
+ */
+export interface ImportOptions {
+    /** If true, existing functions will be overwritten. False by default. */
+    override?: boolean;
+    /** If true, the function will not throw errors on duplicates or invalid types. False by default. */
+    silent?: boolean;
+    /** If true, the functions will be wrapped in a wrapper function which converts data types. */
+    wrap?: boolean;
+}
+/**
+ * The math namespace object that functions are imported into
+ */
+interface MathNamespace {
+    [key: string]: unknown;
+    expression: {
+        transform: Record<string, unknown>;
+        mathWithTransform: Record<string, unknown>;
+    };
+    Unit?: {
+        isValuelessUnit: (name: string) => boolean;
+    };
+    emit: (event: string, name: string, resolver: () => unknown) => void;
+}
+export declare function importFactory(typed: TypedFunction, load: (factory: FactoryFunction) => unknown, math: MathNamespace, importedFactories: Record<string, FactoryFunction>): (functions: unknown, options?: ImportOptions) => void;
+export {};
+//# sourceMappingURL=import.d.ts.map

package/dist/core/function/import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../../src/core/function/import.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,eAAe,EAEhB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,yEAAyE;IACzE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,oGAAoG;IACpG,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,8FAA8F;IAC9F,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAUD;;GAEG;AACH,UAAU,aAAa;IACrB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,UAAU,EAAE;QACV,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACnC,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAC5C,CAAC;IACF,IAAI,CAAC,EAAE;QACL,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;KAC5C,CAAC;IACF,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,KAAK,IAAI,CAAC;CACtE;AAOD,wBAAgB,aAAa,CAC3B,KAAK,EAAE,aAAa,EACpB,IAAI,EAAE,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,EAC3C,IAAI,EAAE,aAAa,EACnB,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GACjD,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,aAAa,KAAK,IAAI,CA8ZvD"}

package/dist/core/function/typed.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Create a typed-function which checks the types of the arguments and
+ * can match them against multiple provided signatures. The typed-function
+ * automatically converts inputs in order to find a matching signature.
+ * Typed functions throw informative errors in case of wrong input arguments.
+ *
+ * See the library [typed-function](https://github.com/josdejong/typed-function)
+ * for detailed documentation.
+ *
+ * Syntax:
+ *
+ *     math.typed(name, signatures) : function
+ *     math.typed(signatures) : function
+ *
+ * Examples:
+ *
+ *     // create a typed function with multiple types per argument (type union)
+ *     const fn2 = typed({
+ *       'number | boolean': function (b) {
+ *         return 'b is a number or boolean'
+ *       },
+ *       'string, number | boolean': function (a, b) {
+ *         return 'a is a string, b is a number or boolean'
+ *       }
+ *     })
+ *
+ *     // create a typed function with an any type argument
+ *     const log = typed({
+ *       'string, any': function (event, data) {
+ *         console.log('event: ' + event + ', data: ' + JSON.stringify(data))
+ *       }
+ *     })
+ *
+ * @param name       Optional name for the typed-function
+ * @param signatures Object with one or multiple function signatures
+ * @returns The created typed-function
+ */
+/**
+ * Type definition for a signature map used in typed functions
+ */
+export type TypedSignatures = Record<string, (...args: unknown[]) => unknown>;
+/**
+ * Type definition for a typed function
+ */
+export interface TypedFunction extends Function {
+    (...args: unknown[]): unknown;
+    /** The signatures of this typed function */
+    signatures?: TypedSignatures;
+    /** Check if a value is a typed function */
+    isTypedFunction: (value: unknown) => value is TypedFunction;
+    referToSelf: (callback: (self: TypedFunction) => (...args: unknown[]) => unknown) => (...args: unknown[]) => unknown;
+    referTo: (...signatureNames: string[]) => (callback: (...refs: Array<(...args: unknown[]) => unknown>) => (...args: unknown[]) => unknown) => (...args: unknown[]) => unknown;
+    create: () => TypedFunction;
+    addTypes: (types: TypeDefinition[]) => void;
+    addConversions: (conversions: TypeConversion[]) => void;
+    addConversion: (conversion: TypeConversion) => void;
+    clear: () => void;
+    onMismatch: (name: string, args: unknown[], signatures: TypedSignatures) => unknown;
+    createError: (name: string, args: unknown[], signatures: TypedSignatures) => Error;
+    find: (fn: TypedFunction, signature: string | string[]) => ((...args: unknown[]) => unknown) | null;
+    resolve: (fn: TypedFunction, args: unknown[]) => {
+        implementation: (...args: unknown[]) => unknown;
+        params: string[];
+    } | null;
+}
+/**
+ * Constructor type for BigNumber
+ */
+interface BigNumberConstructor {
+    new (value: number | string | bigint): unknown;
+}
+/**
+ * Constructor type for Complex numbers
+ */
+interface ComplexConstructor {
+    new (re: number | string, im?: number): unknown;
+}
+/**
+ * Constructor type for DenseMatrix
+ */
+interface DenseMatrixConstructor {
+    new (data: unknown[]): unknown;
+}
+/**
+ * Constructor type for Fraction
+ */
+interface FractionConstructor {
+    new (value: number | string | bigint): {
+        valueOf: () => number;
+    };
+}
+/**
+ * Type for the dependencies required by createTyped
+ */
+interface TypedDependencies {
+    BigNumber?: BigNumberConstructor;
+    Complex?: ComplexConstructor;
+    DenseMatrix?: DenseMatrixConstructor;
+    Fraction?: FractionConstructor;
+}
+/**
+ * Type definition for a type test function
+ */
+export type TypeTest = (value: unknown) => boolean;
+/**
+ * Type definition for a type conversion function
+ */
+export type TypeConversion = {
+    from: string;
+    to: string;
+    convert: (value: unknown) => unknown;
+};
+/**
+ * Type definition for a type definition
+ */
+export type TypeDefinition = {
+    name: string;
+    test: TypeTest;
+};
+/**
+ * Factory function for creating a new typed instance
+ * @param dependencies Object with data types like Complex and BigNumber
+ * @returns The typed function
+ */
+export declare const createTyped: import("../../utils/factory.js").FactoryFunction<TypedDependencies, TypedFunction>;
+export {};
+//# sourceMappingURL=typed.d.ts.map

package/dist/core/function/typed.d.ts.map

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

package/dist/error/ArgumentsError.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Custom error type for wrong number of arguments
+ * @extends Error
+ */
+export declare class ArgumentsError extends Error {
+    fn: string;
+    count: number;
+    min: number;
+    max: number | undefined;
+    isArgumentsError: true;
+    /**
+     * Create an ArgumentsError
+     * @param fn     Function name
+     * @param count  Actual argument count
+     * @param min    Minimum required argument count
+     * @param max    Maximum required argument count (optional)
+     */
+    constructor(fn: string, count: number, min: number, max?: number);
+}
+export declare function createArgumentsError(fn: string, count: number, min: number, max?: number): ArgumentsError;
+//# sourceMappingURL=ArgumentsError.d.ts.map

package/dist/error/ArgumentsError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ArgumentsError.d.ts","sourceRoot":"","sources":["../../src/error/ArgumentsError.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,gBAAgB,EAAG,IAAI,CAAU;IAEjC;;;;;;OAMG;gBACS,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM;CAwBjE;AAGD,wBAAgB,oBAAoB,CAClC,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,GAAG,CAAC,EAAE,MAAM,GACX,cAAc,CAEhB"}

package/dist/error/DimensionError.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Create a range error with the message:
+ *     'Dimension mismatch (<actual size> != <expected size>)'
+ * Or with a custom message when called with a single string argument.
+ */
+export declare class DimensionError extends RangeError {
+    actual?: number | number[];
+    expected?: number | number[];
+    relation?: string;
+    isDimensionError: true;
+    /**
+     * @param actual - The actual size or custom error message
+     * @param expected - The expected size (optional if actual is a custom message)
+     * @param relation - Optional relation between actual and expected size: '!=', '<', etc.
+     */
+    constructor(actual: number | number[] | string, expected?: number | number[], relation?: string);
+}
+//# sourceMappingURL=DimensionError.d.ts.map

package/dist/error/DimensionError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DimensionError.d.ts","sourceRoot":"","sources":["../../src/error/DimensionError.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,cAAe,SAAQ,UAAU;IAC5C,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAG,IAAI,CAAU;IAEjC;;;;OAIG;gBACS,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,QAAQ,CAAC,EAAE,MAAM;CAsChG"}