@danielsimonjr/mathts-core 0.10.0 → 0.12.0

package/dist/internal.d.ts

@@ -1,5 +1,5 @@
-import { F as FactoryFunction, b as UnitConstructor, c as UnitDependencies } from './index-zKEDY9aj.js';
-export { B as BaseUnitDef, d as BigNumber, e as BigNumberConstructor, f as BigNumberValue, C as Complex, g as ComplexConstructor, h as ComplexValue, j as ConverterFn, U as CoreUnit, k as CreateUnitDefObject, l as CreateUnitOptions, D as DenseMatrix, m as Fraction, n as FractionConstructor, o as FractionValue, I as Index, p as IndexDimension, M as Matrix, N as Numeric, P as ParseOptions, q as PrefixDef, r as PrefixTable, R as Range, S as ScalarBinaryOp, s as ScalarUnaryOp, t as SparseMatrix, u as SubtractScalar, T as TypeConverters, v as Unit, w as UnitComponent, x as UnitConfig, y as UnitDef, z as UnitFormatOptions, a as UnitInstance, A as UnitJSON, E as UnitSystem, G as UnitSystemEntry, H as isArray, J as isBigInt, K as isBigNumber, L as isBoolean, O as isCollection, Q as isComplex, V as isDate, W as isDenseMatrix, X as isFraction, Y as isFunction, Z as isIndex, _ as isMap, $ as isMatrix, a0 as isNull, a1 as isNumber, a2 as isObject, a3 as isRange, a4 as isRegExp, a5 as isSparseMatrix, a6 as isString, a7 as isUndefined, i as isUnit, a8 as typeOf } from './index-zKEDY9aj.js';
+import { F as FactoryFunction, b as UnitConstructor, c as UnitDependencies, I as Index, M as Matrix$1 } from './index-B4LIOfHN.js';
+export { B as BaseUnitDef, d as BigNumber, e as BigNumberConstructor, C as Complex, f as ComplexConstructor, g as ComplexValue, h as ConverterFn, U as CoreUnit, j as CreateFunction, k as CreateUnitDefObject, l as CreateUnitOptions, D as DenseMatrix, m as DependencyName, n as FactoryMeta, o as Fraction, p as FractionConstructor, q as FractionValue, r as IndexDimension, L as LegacyFactory, N as Numeric, P as ParseOptions, s as PrefixDef, t as PrefixTable, R as Range, S as ScalarBinaryOp, u as ScalarUnaryOp, v as SparseMatrix, w as SubtractScalar, T as TypeConverters, x as Unit, y as UnitComponent, z as UnitConfig, A as UnitDef, E as UnitFormatOptions, a as UnitInstance, G as UnitJSON, H as UnitSystem, J as UnitSystemEntry, K as assertDependencies, O as create, Q as factory, V as isArray, W as isBigInt, X as isBigNumber, Y as isBoolean, Z as isCollection, _ as isComplex, $ as isDate, a0 as isDenseMatrix, a1 as isFactory, a2 as isFraction, a3 as isFunction, a4 as isIndex, a5 as isMap, a6 as isMatrix, a7 as isNull, a8 as isNumber, a9 as isObject, aa as isOptionalDependency, ab as isRange, ac as isRegExp, ad as isSparseMatrix, ae as isString, af as isUndefined, i as isUnit, ag as sortFactories, ah as stripOptionalNotation, ai as typeOf } from './index-B4LIOfHN.js';
 
 declare const createUnitClass: FactoryFunction<UnitConstructor>;
 
@@ -185,7 +185,7 @@ declare const expm1: (x: number) => number;
  * @param options Optional formatting options or custom formatter function or precision
  * @return The formatted value
  */
-declare function format(value: number, options?: FormatOptions | ((value: number) => string) | number): string;
+declare function format$2(value: number, options?: FormatOptions | ((value: number) => string) | number): string;
 /**
  * Normalize format options into an object:
  *   {
@@ -209,21 +209,21 @@ declare function splitNumber(value: number | string): SplitValue;
  * @param precision Optional number of significant figures to return
  * @returns The formatted string
  */
-declare function toEngineering(value: number | string, precision?: number): string;
+declare function toEngineering$1(value: number | string, precision?: number): string;
 /**
  * Format a number with fixed notation.
  * @param value     The number or string to format
  * @param precision Optional number of decimals after the decimal point
  * @returns The formatted string
  */
-declare function toFixed(value: number | string, precision?: number): string;
+declare function toFixed$1(value: number | string, precision?: number): string;
 /**
  * Format a number in exponential notation. Like '1.23e+5', '2.3e+0', '3.500e-3'
  * @param value     The number or string to format
  * @param precision Number of digits in formatted output
  * @returns The formatted string
  */
-declare function toExponential(value: number | string, precision?: number): string;
+declare function toExponential$1(value: number | string, precision?: number): string;
 /**
  * Format a number with a certain precision
  * @param value     The number or string to format
@@ -372,7 +372,7 @@ declare function memoize(fn: (...args: unknown[]) => unknown, { hasher, limit }?
  * @param {*} x
  * @return {*} clone
  */
-declare function clone<T>(x: T): T;
+declare function clone$1<T>(x: T): T;
 /**
  * Apply map to all properties of an object
  * @param {Object} object
@@ -451,7 +451,7 @@ declare function isLegacyFactory(object: unknown): boolean;
  * @param {string | string[]} path
  * @returns {Object}
  */
-declare function get(object: Record<string, unknown>, path: string | string[]): unknown;
+declare function get$1(object: Record<string, unknown>, path: string | string[]): unknown;
 /**
  * Set a nested property in an object
  * Mutates the object itself
@@ -479,4 +479,762 @@ declare function pick(object: Record<string, unknown>, properties: string[], tra
  */
 declare function pickShallow(object: Record<string, unknown>, properties: string[]): Record<string, unknown>;
 
-export { type FormatOptions, type MemoizedFunction, type NormalizedFormatOptions, type NumberTypeConfig, type SplitValue, UnitConstructor, UnitDependencies, acosh, asinh, atanh, canDefineProperty, cbrt, clone, copysign, cosh, createUnitClass, deepExtend, deepFlatten, deepStrictEqual, digits, endsWith, expm1, extend, format, get, hasOwnProperty, isInteger, isLegacyFactory, isPowZeroAtInfinity, lazy, log10, log1p, log2, mapObject, memoize, nearlyEqual, normalizeFormatOptions, pick, pickShallow, roundDigits, safeNumberType, set, sign, sinh, splitNumber, tanh, toEngineering, toExponential, toFixed, toPrecision, traverse, unitDependencies, warnOnce };
+/**
+ * Configuration interface for math.js
+ */
+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;
+}
+type MathJsConfig = ConfigOptions;
+declare const DEFAULT_CONFIG: ConfigOptions;
+
+/**
+ * Custom error type for Mathjs errors
+ * @extends Error
+ */
+declare class MathjsError extends Error {
+    isMathjsError: true;
+    /**
+     * Create a MathjsError
+     * @param message  Error message
+     */
+    constructor(message: string);
+}
+
+/**
+ * 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.
+ *
+ * The single canonical `DimensionError` for the whole monorepo (Bucket B, commit 1),
+ * exposed via the `@danielsimonjr/mathts-core/internal` subpath. `expression/src/error/
+ * DimensionError.ts` and `functions/src/error/DimensionError.ts` are now thin
+ * re-export shims of this class — a `DimensionError` thrown in one package is
+ * `instanceof DimensionError` in any other, since there is only ever one class
+ * identity. `core/src/array.ts` (and the ~20 other call sites across matrix algos,
+ * subset, resize, concat, reshape, ...) all throw this same class.
+ */
+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);
+}
+
+/**
+ * Custom error type for index out of range errors.
+ *
+ * The single canonical `IndexError` for the whole monorepo (Bucket B, commit 1),
+ * exposed via the `@danielsimonjr/mathts-core/internal` subpath. `expression/src/error/
+ * IndexError.ts` and `functions/src/error/IndexError.ts` are now thin re-export shims
+ * of this class — an `IndexError` thrown in one package is `instanceof IndexError`
+ * in any other, since there is only ever one class identity. `core/src/array.ts` /
+ * `core/src/collection.ts` (and the many other call sites across concat, subset,
+ * cumsum, mapSlices, ...) all throw this same class.
+ *
+ * @extends RangeError
+ */
+declare class IndexError extends RangeError {
+    index: number;
+    min: number | undefined;
+    max: number | undefined;
+    isIndexError: true;
+    /**
+     * Create an IndexError
+     *
+     * Can be called in two ways:
+     * - IndexError(index, max) - assumes min=0
+     * - IndexError(index, min, max)
+     *
+     * @param index  The actual index
+     * @param min    Minimum index (included), or max if only 2 args provided
+     * @param max    Maximum index (excluded)
+     */
+    constructor(index: number, min?: number, max?: number);
+}
+declare function createIndexError(index: number, min?: number, max?: number): IndexError;
+
+/**
+ * Formatting options accepted by the generic `format` helper. Extends the
+ * numeric {@link FormatOptions} with the string-level `truncate` and the
+ * fraction rendering mode, or is a precision number, or a custom formatter.
+ */
+type GeneralFormatOptions = number | ((value: unknown) => string) | (FormatOptions & {
+    truncate?: number;
+    fraction?: 'ratio' | 'decimal';
+});
+/**
+ * Format a value of any type into a string.
+ *
+ * Usage:
+ *     math.format(value)
+ *     math.format(value, precision)
+ *     math.format(value, options)
+ *
+ * When value is a function:
+ *
+ * - When the function has a property `syntax`, it returns this
+ *   syntax description.
+ * - In other cases, a string `'function'` is returned.
+ *
+ * When `value` is an Object:
+ *
+ * - When the object contains a property `format` being a function, this
+ *   function is invoked as `value.format(options)` and the result is returned.
+ * - When the object has its own `toString` method, this method is invoked
+ *   and the result is returned.
+ * - In other cases the function will loop over all object properties and
+ *   return JSON object notation like '{"a": 2, "b": 3}'.
+ *
+ * Example usage:
+ *     math.format(2/7)                // '0.2857142857142857'
+ *     math.format(math.pi, 3)         // '3.14'
+ *     math.format(new Complex(2, 3))  // '2 + 3i'
+ *     math.format('hello')            // '"hello"'
+ *
+ * @param {*} value             Value to be stringified
+ * @param {Object | number | Function} [options]
+ *     Formatting options. See src/utils/number.js:format for a
+ *     description of the available options controlling number output.
+ *     This generic "format" also supports the option property `truncate: NN`
+ *     giving the maximum number NN of characters to return (if there would
+ *     have been more, they are deleted and replaced by an ellipsis).
+ * @return {string} str
+ */
+declare function format$1(value: unknown, options?: unknown): string;
+/**
+ * Stringify a value into a string enclosed in double quotes.
+ * Unescaped double quotes and backslashes inside the value are escaped.
+ * @param {*} value
+ * @return {string}
+ */
+declare function stringify(value: unknown): string;
+/**
+ * Escape special HTML characters
+ * @param {*} value
+ * @return {string}
+ */
+declare function escape(value: unknown): string;
+/**
+ * Compare two strings
+ * @param {string} x
+ * @param {string} y
+ * @returns {number}
+ */
+declare function compareText(x: unknown, y: unknown): number;
+
+/**
+ * Structural contract for the BigNumber values handled by this formatter.
+ * Captures exactly the methods/properties used here. The configured BigNumber
+ * implementation (e.g. decimal.js) provides these; the project's `BigNumber`
+ * type alias points at a minimal local Decimal that does not declare them all,
+ * so we model the runtime contract explicitly.
+ */
+interface BigNumberValue {
+    e: number;
+    constructor: new (value: number | string) => BigNumberValue;
+    isFinite(): boolean;
+    isNaN(): boolean;
+    isZero(): boolean;
+    isInteger(): boolean;
+    gt(other: number | BigNumberValue): boolean;
+    greaterThan(other: number | BigNumberValue): boolean;
+    lessThan(other: number | BigNumberValue): boolean;
+    add(other: number | BigNumberValue): BigNumberValue;
+    sub(other: number | BigNumberValue): BigNumberValue;
+    mul(other: number | BigNumberValue): BigNumberValue;
+    pow(exp: number | BigNumberValue): BigNumberValue;
+    toNumber(): number;
+    toFixed(places?: number): string;
+    toExponential(places?: number): string;
+    toPrecision(sd?: number): string;
+    toSignificantDigits(sd?: number): BigNumberValue;
+    toBinary(): string;
+    toOctal(): string;
+    toHexadecimal(): string;
+}
+/**
+ * Convert a BigNumber to a formatted string representation.
+ *
+ * Syntax:
+ *
+ *    format(value)
+ *    format(value, options)
+ *    format(value, precision)
+ *    format(value, fn)
+ *
+ * Where:
+ *
+ *    {number} value   The value to be formatted
+ *    {Object} options An object with formatting options. Available options:
+ *                     {string} notation
+ *                         Number notation. Choose from:
+ *                         'fixed'          Always use regular number notation.
+ *                                          For example '123.40' and '14000000'
+ *                         'exponential'    Always use exponential notation.
+ *                                          For example '1.234e+2' and '1.4e+7'
+ *                         'auto' (default) Regular number notation for numbers
+ *                                          having an absolute value between
+ *                                          `lower` and `upper` bounds, and uses
+ *                                          exponential notation elsewhere.
+ *                                          Lower bound is included, upper bound
+ *                                          is excluded.
+ *                                          For example '123.4' and '1.4e7'.
+ *                         'bin', 'oct, or
+ *                         'hex'            Format the number using binary, octal,
+ *                                          or hexadecimal notation.
+ *                                          For example '0b1101' and '0x10fe'.
+ *                     {number} wordSize    The word size in bits to use for formatting
+ *                                          in binary, octal, or hexadecimal notation.
+ *                                          To be used only with 'bin', 'oct', or 'hex'
+ *                                          values for 'notation' option. When this option
+ *                                          is defined the value is formatted as a signed
+ *                                          twos complement integer of the given word size
+ *                                          and the size suffix is appended to the output.
+ *                                          For example
+ *                                          format(-1, {notation: 'hex', wordSize: 8}) === '0xffi8'.
+ *                                          Default value is undefined.
+ *                     {number} precision   A number between 0 and 16 to round
+ *                                          the digits of the number.
+ *                                          In case of notations 'exponential',
+ *                                          'engineering', and 'auto',
+ *                                          `precision` defines the total
+ *                                          number of significant digits returned.
+ *                                          In case of notation 'fixed',
+ *                                          `precision` defines the number of
+ *                                          significant digits after the decimal
+ *                                          point.
+ *                                          `precision` is undefined by default.
+ *                     {number} lowerExp    Exponent determining the lower boundary
+ *                                          for formatting a value with an exponent
+ *                                          when `notation='auto`.
+ *                                          Default value is `-3`.
+ *                     {number} upperExp    Exponent determining the upper boundary
+ *                                          for formatting a value with an exponent
+ *                                          when `notation='auto`.
+ *                                          Default value is `5`.
+ *    {Function} fn    A custom formatting function. Can be used to override the
+ *                     built-in notations. Function `fn` is called with `value` as
+ *                     parameter and must return a string. Is useful for example to
+ *                     format all values inside a matrix in a particular way.
+ *
+ * Examples:
+ *
+ *    format(6.4)                                        // '6.4'
+ *    format(1240000)                                    // '1.24e6'
+ *    format(1/3)                                        // '0.3333333333333333'
+ *    format(1/3, 3)                                     // '0.333'
+ *    format(21385, 2)                                   // '21000'
+ *    format(12e8, {notation: 'fixed'})                  // returns '1200000000'
+ *    format(2.3,    {notation: 'fixed', precision: 4})  // returns '2.3000'
+ *    format(52.8,   {notation: 'exponential'})          // returns '5.28e+1'
+ *    format(12400,  {notation: 'engineering'})          // returns '12.400e+3'
+ *
+ * @param {BigNumber} value
+ * @param {Object | Function | number | BigNumber} [options]
+ * @return {string} str The formatted value
+ */
+declare function format(value: unknown, options?: unknown): string;
+/**
+ * Format a BigNumber in engineering notation. Like '1.23e+6', '2.3e+0', '3.500e-3'
+ * @param {BigNumber} value
+ * @param {number} [precision]        Optional number of significant figures to return.
+ */
+declare function toEngineering(value: BigNumberValue, precision?: number): string;
+/**
+ * Format a number in exponential notation. Like '1.23e+5', '2.3e+0', '3.500e-3'
+ * @param {BigNumber} value
+ * @param {number} [precision]  Number of digits in formatted output.
+ *                              If not provided, the maximum available digits
+ *                              is used.
+ * @returns {string} str
+ */
+declare function toExponential(value: BigNumberValue, precision?: number): string;
+/**
+ * Format a number with fixed notation.
+ * @param {BigNumber} value
+ * @param {number} [precision=undefined] Optional number of decimals after the
+ *                                       decimal point. Undefined by default.
+ */
+declare function toFixed(value: BigNumberValue, precision?: number): string;
+
+type NestedArray<T> = T | NestedArray<T>[];
+interface IdentifiedValue<T> {
+    value: T;
+    identifier: number;
+}
+/**
+ * Calculate the size of a multi dimensional array.
+ * This function checks the size of the first entry, it does not validate
+ * whether all dimensions match. (use function `validate` for that)
+ * @param {Array} x
+ * @return {number[]} size
+ */
+declare function arraySize<T>(x: NestedArray<T>): number[];
+/**
+ * Validate whether each element in a multi dimensional array has
+ * a size corresponding to the provided size array.
+ * @param {Array} array    Array to be validated
+ * @param {number[]} size  Array with the size of each dimension
+ * @throws DimensionError
+ */
+declare function validate<T>(array: NestedArray<T>, size: number[]): void;
+/**
+ * Validate whether the source of the index matches the size of the Array
+ * @param {Array | Matrix} value    Array to be validated
+ * @param {Index} index  Index with the source information to validate
+ * @throws DimensionError
+ */
+declare function validateIndexSourceSize(value: unknown[] | Matrix$1, index: Index): void;
+/**
+ * Test whether index is an integer number with index >= 0 and index < length
+ * when length is provided
+ * @param {number} index    Zero-based index
+ * @param {number} [length] Length of the array
+ */
+declare function validateIndex(index: number | undefined, length?: number): void;
+/**
+ * Test if an index has empty values
+ * @param {Index} index    Zero-based index
+ */
+declare function isEmptyIndex(index: Index): boolean;
+/**
+ * Resize a multi dimensional array. The resized array is returned.
+ * @param {Array | number} array         Array to be resized
+ * @param {number[]} size Array with the size of each dimension
+ * @param {*} [defaultValue=0]  Value to be filled in new entries,
+ *                              zero by default. Specify for example `null`,
+ *                              to clearly see entries that are not explicitly
+ *                              set.
+ * @return {Array} array         The resized array
+ */
+declare function resize<T = unknown>(array: T | T[] | NestedArray<T>, size: number[], defaultValue?: T): NestedArray<T>;
+/**
+ * Re-shape a multi dimensional array to fit the specified dimensions
+ * @param {Array} array           Array to be reshaped
+ * @param {number[]} sizes        List of sizes for each dimension
+ * @returns {Array}               Array whose data has been formatted to fit the
+ *                                specified dimensions
+ *
+ * @throws {DimensionError}       If the product of the new dimension sizes does
+ *                                not equal that of the old ones
+ */
+declare function reshape<T = unknown>(array: NestedArray<T>, sizes: number[]): NestedArray<T>;
+/**
+ * Replaces the wildcard -1 in the sizes array.
+ * @param {number[]} sizes  List of sizes for each dimension. At most one wildcard.
+ * @param {number} currentLength  Number of elements in the array.
+ * @throws {Error}                If more than one wildcard or unable to replace it.
+ * @returns {number[]}      The sizes array with wildcard replaced.
+ */
+declare function processSizesWildcard(sizes: number[], currentLength: number): number[];
+/**
+ * Squeeze a multi dimensional array
+ * @param {Array} array
+ * @param {Array} [size]
+ * @returns {Array} returns the array itself
+ */
+declare function squeeze<T>(array: NestedArray<T>, size?: number[]): T | NestedArray<T>;
+/**
+ * Unsqueeze a multi dimensional array: add dimensions when missing
+ *
+ * Parameter `size` will be mutated to match the new, unsqueezed matrix size.
+ *
+ * @param {Array} array
+ * @param {number} dims       Desired number of dimensions of the array
+ * @param {number} [outer]    Number of outer dimensions to be added
+ * @param {Array} [size] Current size of array.
+ * @returns {Array} returns the array itself
+ * @private
+ */
+declare function unsqueeze<T>(array: NestedArray<T>, dims: number, outer?: number, size?: number[]): NestedArray<T>;
+/**
+ * Flatten a multi dimensional array, put all elements in a one dimensional
+ * array
+ * @param {Array} array   A multi dimensional array
+ * @param {boolean} isRectangular Optional. If the array is rectangular (not jagged)
+ * @return {Array}        The flattened array (1 dimensional)
+ */
+declare function flatten<T>(array: NestedArray<T>, isRectangular?: boolean): T[];
+/**
+ * A safe map
+ * @param {Array} array
+ * @param {function} callback
+ */
+declare function map<T, U>(array: T[], callback: (value: T, index: number, array: T[]) => U): U[];
+/**
+ * A safe forEach
+ * @param {Array} array
+ * @param {function} callback
+ */
+declare function forEach<T>(array: T[], callback: (value: T, index: number, array: T[]) => void): void;
+/**
+ * A safe filter
+ * @param {Array} array
+ * @param {function} callback
+ */
+declare function filter<T>(array: T[], callback: (value: T, index: number, array: T[]) => boolean): T[];
+/**
+ * Filter values in an array given a regular expression
+ * @param {Array} array
+ * @param {RegExp} regexp
+ * @return {Array} Returns the filtered array
+ * @private
+ */
+declare function filterRegExp(array: string[], regexp: RegExp): string[];
+/**
+ * A safe join
+ * @param {Array} array
+ * @param {string} separator
+ */
+declare function join<T>(array: T[], separator: string): string;
+/**
+ * Assign a numeric identifier to every element of a sorted array
+ * @param {Array} a  An array
+ * @return {Array} An array of objects containing the original value and its identifier
+ */
+declare function identify<T>(a: T[]): IdentifiedValue<T>[];
+/**
+ * Remove the numeric identifier from the elements
+ * @param {array} a  An array
+ * @return {array} An array of values without identifiers
+ */
+declare function generalize<T>(a: IdentifiedValue<T>[]): T[];
+/**
+ * Check the datatype of a given object
+ * This is a low level implementation that should only be used by
+ * parent Matrix classes such as SparseMatrix or DenseMatrix
+ * This method does not validate Array Matrix shape
+ * @param {Array} array
+ * @param {function} typeOf   Callback function to use to determine the type of a value
+ * @return {string}
+ */
+declare function getArrayDataType(array: unknown[], typeOf: (value: unknown) => string): string | undefined;
+/**
+ * Return the last item from an array
+ * @param {Array} array
+ * @returns {*}
+ */
+declare function last<T>(array: T[]): T;
+/**
+ * Get all but the last element of array.
+ *
+ * KNOWN DIVERGENCE (Bucket B slice 2): only `expression/src/utils/array.ts` had
+ * this; `functions/src/utils/array.ts` never defined it, and it was dead code
+ * even in expression (unused outside its own definition). Re-exported from
+ * expression's shim only — see the module header.
+ * @param {Array} array
+ * @returns {Array}
+ */
+declare function initial<T>(array: T[]): T[];
+/**
+ * Concatenates many arrays in the specified direction
+ * @param {...Array} arrays All the arrays to concatenate
+ * @param {number} concatDim The dimension on which to concatenate (zero-based)
+ * @returns {Array}
+ */
+declare function concat<T>(...args: [...NestedArray<T>[], number]): NestedArray<T>[];
+/**
+ * Receives two or more sizes and gets the broadcasted size for both.
+ * @param  {...number[]} sizes Sizes to broadcast together
+ * @returns {number[]} The broadcasted size
+ */
+declare function broadcastSizes(...sizes: number[][]): number[];
+/**
+ * Checks if it's possible to broadcast a size to another size
+ * @param {number[]} size The size of the array to check
+ * @param {number[]} toSize The size of the array to validate if it can be broadcasted to
+ */
+declare function checkBroadcastingRules(size: number[], toSize: number[]): void;
+/**
+ * Broadcasts a single array to a certain size
+ * @param {Array} array Array to be broadcasted
+ * @param {number[]} toSize Size to broadcast the array
+ * @returns {Array} The broadcasted array
+ */
+declare function broadcastTo<T>(array: NestedArray<T>, toSize: number[]): NestedArray<T>;
+/**
+ * Broadcasts arrays and returns the broadcasted arrays in an array
+ * @param  {...Array | any} arrays
+ * @returns {Array[]} The broadcasted arrays
+ */
+declare function broadcastArrays<T>(...arrays: NestedArray<T>[]): NestedArray<T>[];
+/**
+ * Stretches a matrix up to a certain size in a certain dimension
+ * @param {Array} arrayToStretch
+ * @param {number[]} sizeToStretch
+ * @param {number} dimToStretch
+ * @returns {Array} The stretched array
+ */
+declare function stretch<T>(arrayToStretch: NestedArray<T>, sizeToStretch: number, dimToStretch: number): NestedArray<T>;
+/**
+ * Retrieves a single element from an array given an index.
+ *
+ * @param {Array} array - The array from which to retrieve the value.
+ * @param {Array<number>} index - An array of indices specifying the position of the desired element in each dimension.
+ * @returns {*} - The value at the specified position in the array.
+ *
+ * @example
+ * const arr = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]];
+ * const index = [1, 0, 1];
+ * console.log(get(arr, index)); // 6
+ */
+declare function get<T>(array: NestedArray<T>, index: number[]): T;
+/**
+ * Recursively maps over each element of nested array using a provided callback function.
+ *
+ * @param {Array} array - The array to be mapped.
+ * @param {Function} callback - The function to execute on each element, taking three arguments:
+ *   - `value` (any): The current element being processed in the array.
+ *   - `index` (Array<number>): The index of the current element being processed in the array.
+ *   - `array` (Array): The array `deepMap` was called upon.
+ * @param {boolean} [skipIndex=false] - If true, the callback function is called with only the value.
+ * @returns {Array} A new array with each element being the result of the callback function.
+ */
+declare function deepMap$1<T, U>(array: NestedArray<T>, callback: ((value: T, index: number[], array: NestedArray<T>) => U) | ((value: T) => U), skipIndex?: boolean): NestedArray<U>;
+/**
+ * Recursively iterates over each element in a multi-dimensional array and applies a callback function.
+ *
+ * @param {Array} array - The multi-dimensional array to iterate over.
+ * @param {Function} callback - The function to execute for each element. It receives three arguments:
+ *   - {any} value: The current element being processed in the array.
+ *   - {Array<number>} index: The index of the current element in each dimension.
+ *   - {Array} array: The original array being processed.
+ * @param {boolean} [skipIndex=false] - If true, the callback function is called with only the value.
+ */
+declare function deepForEach$1<T>(array: NestedArray<T>, callback: ((value: T, index: number[], array: NestedArray<T>) => void) | ((value: T) => void), skipIndex?: boolean): void;
+/**
+ * Deep clones a multidimensional array
+ * @param {Array} array
+ * @returns {Array} cloned array
+ */
+declare function clone<T>(array: T[]): T[];
+
+interface Matrix<T = unknown> {
+    forEach(callback: (value: T) => void, skipZeros: boolean, recurse: boolean): void;
+    map<U>(callback: (value: T) => U, skipZeros: boolean, recurse: boolean): Matrix<U>;
+    size(): number[];
+    valueOf(): T[];
+    create(data: T[], datatype?: string): Matrix<T>;
+    datatype(): string | undefined;
+}
+interface SparseMatrix<T = unknown> {
+    _values: T[];
+    _index: number[];
+    _ptr: number[];
+}
+/**
+ * Test whether an array contains collections
+ * @param array - Array to test
+ * @returns Returns true when the array contains one or multiple
+ *          collections (Arrays or Matrices). Returns false otherwise.
+ */
+declare function containsCollections(array: unknown[]): boolean;
+/**
+ * Recursively loop over all elements in a given multi dimensional array
+ * and invoke the callback on each of the elements.
+ * @param array - Array or Matrix to iterate over
+ * @param callback - The callback method is invoked with one parameter: the current element in the array
+ */
+declare function deepForEach<T>(array: T[] | Matrix<T>, callback: (value: T) => void): void;
+/**
+ * Execute the callback function element wise for each element in array and any
+ * nested array
+ * Returns an array with the results
+ * @param array - Array or Matrix to map over
+ * @param callback - The callback is called with two parameters:
+ *                   value1 and value2, which contain the current
+ *                   element of both arrays.
+ * @param skipZeros - Invoke callback function for non-zero values only.
+ *
+ * @return Mapped result
+ */
+declare function deepMap<T, U>(array: T[] | Matrix<T>, callback: (value: T) => U, skipZeros?: boolean): U[] | Matrix<U>;
+/**
+ * Reduce a given matrix or array to a new matrix or
+ * array with one less dimension, applying the given
+ * callback in the selected dimension.
+ * @param mat - Array or Matrix to reduce
+ * @param dim - Dimension to reduce
+ * @param callback - Callback function
+ * @return Reduced result
+ */
+declare function reduce<T, U>(mat: T[] | Matrix<T>, dim: number, callback: (acc: U | T, val: T) => U): U[] | Matrix<U>;
+/**
+ * Scatter function for sparse matrix operations
+ * @param a - Sparse matrix
+ * @param j - Column index
+ * @param w - Work array for marking visited rows
+ * @param x - Work array for storing values
+ * @param u - Work array for marking updated rows
+ * @param mark - Current mark value
+ * @param cindex - Column index array to update
+ * @param f - Binary function to apply
+ * @param inverse - Whether to inverse the function arguments
+ * @param update - Whether to update existing values
+ * @param value - Value to use in binary function
+ */
+declare function scatter<T>(a: SparseMatrix<T>, j: number, w: number[], x: T[] | null, u: number[], mark: number, cindex: number[], f?: (a: T, b: T) => T, inverse?: boolean, update?: boolean, value?: T): void;
+
+/**
+ * A map facade on a bare object.
+ *
+ * The small number of methods needed to implement a scope,
+ * forwarding on to the SafeProperty functions. Over time, the codebase
+ * will stop using this method, as all objects will be Maps, rather than
+ * more security prone objects.
+ */
+/**
+ * The iterator type `Map` itself declares, derived from the installed TS lib
+ * rather than hard-coded: older libs say `IterableIterator<[K, V]>`, TS >= 5.6
+ * says `MapIterator<[K, V]>` (which additionally requires `[Symbol.dispose]`).
+ * Deriving it keeps `implements Map<K, V>` honest on every TS version.
+ */
+type MapEntryIterator<K, V> = ReturnType<Map<K, V>[typeof Symbol.iterator]>;
+declare class ObjectWrappingMap<K = string, V = unknown> implements Map<K, V> {
+    wrappedObject: Record<string, V>;
+    readonly [Symbol.toStringTag]: string;
+    constructor(object: Record<string, V>);
+    /**
+     * Declared as a real method rather than assigned in the constructor through a
+     * cast. The old form satisfied the runtime but never appeared in the emitted
+     * type, so `implements Map<K, V>` was a lie that only surfaced downstream:
+     * consumers compiling with `skipLibCheck: false` got TS2420 ("incorrectly
+     * implements interface 'Map'... '[Symbol.iterator]' is missing").
+     */
+    [Symbol.iterator](): MapEntryIterator<K, V>;
+    keys(): IterableIterator<K>;
+    get(key: K): V | undefined;
+    set(key: K, value: V): this;
+    has(key: K): boolean;
+    entries(): IterableIterator<[K, V]>;
+    values(): IterableIterator<V>;
+    forEach(callback: (value: V, key: K, map: Map<K, V>) => void): void;
+    delete(key: K): boolean;
+    clear(): void;
+    get size(): number;
+}
+/**
+ * Create a map with two partitions: a and b.
+ * The set with bKeys determines which keys/values are read/written to map b,
+ * all other values are read/written to map a
+ *
+ * For example:
+ *
+ *   const a = new Map()
+ *   const b = new Map()
+ *   const p = new PartitionedMap(a, b, new Set(['x', 'y']))
+ *
+ * In this case, values `x` and `y` are read/written to map `b`,
+ * all other values are read/written to map `a`.
+ */
+declare class PartitionedMap<K = unknown, V = unknown> implements Map<K, V> {
+    a: Map<K, V>;
+    b: Map<K, V>;
+    bKeys: Set<K>;
+    readonly [Symbol.toStringTag]: string;
+    /**
+     * @param a - Primary map
+     * @param b - Secondary map
+     * @param bKeys - Set of keys that should be read/written to map b
+     */
+    constructor(a: Map<K, V>, b: Map<K, V>, bKeys: Set<K>);
+    /** See the note on `ObjectWrappingMap[Symbol.iterator]` — same fix. */
+    [Symbol.iterator](): MapEntryIterator<K, V>;
+    get(key: K): V | undefined;
+    set(key: K, value: V): this;
+    has(key: K): boolean;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    forEach(callback: (value: V, key: K, map: Map<K, V>) => void): void;
+    delete(key: K): boolean;
+    clear(): void;
+    get size(): number;
+}
+/**
+ * Creates an empty map, or whatever your platform's polyfill is.
+ *
+ * @returns an empty Map or Map like object.
+ */
+declare function createEmptyMap<K = string, V = unknown>(): Map<K, V>;
+/**
+ * Creates a Map from the given object.
+ *
+ * @param mapOrObject - Map or object to convert
+ * @returns Map instance
+ */
+declare function createMap<K = string, V = unknown>(mapOrObject?: Map<K, V> | Record<string, V> | null): Map<K, V>;
+/**
+ * Unwraps a map into an object.
+ *
+ * @param map - Map to convert to object
+ * @returns Plain object
+ */
+declare function toObject<V = unknown>(map: Map<unknown, V>): Record<string, V>;
+/**
+ * Copies the contents of key-value pairs from each `objects` in to `map`.
+ *
+ * Object is `objects` can be a `Map` or object.
+ *
+ * This is the `Map` analog to `Object.assign`.
+ */
+declare function assign<K = unknown, V = unknown>(map: Map<K, V>, ...objects: (Map<K, V> | Record<string, V> | null | undefined)[]): Map<K, V>;
+/**
+ * Returns `true` if `object` is an {@link ObjectWrappingMap}.
+ *
+ * Defined here, next to the class it guards, so `is.ts` need not import
+ * `map.ts` — that import was the sole edge closing the `is`/`map` cycle.
+ */
+declare function isObjectWrappingMap(object: unknown): object is ObjectWrappingMap;
+
+/**
+ * Shared type-only shapes for the two independent WASM loader implementations
+ * (`functions/src/wasm/WasmLoader.ts` and `matrix/src/backends/WasmLoader.ts`).
+ *
+ * Both packages bind to the same `mathts-as.wasm` AssemblyScript binary but each
+ * declares its own package-scoped subset of the exported function ABI (`WasmModule`
+ * genuinely differs between the two — matrix only needs matrix-relevant exports,
+ * functions needs the full breadth including signal/geometry/special-function
+ * kernels — so `WasmModule` stays local to each package). `LoadingMetrics` (perf
+ * timings) and `WasmManifest` (the SHA-384 integrity manifest shape) were,
+ * however, byte-for-byte identical copies with no principled reason to diverge;
+ * consolidated here (cross-package type-dedup pass,
+ * docs/Architecture/duplicate-symbols.json).
+ *
+ * @module @danielsimonjr/mathts-core/types/wasm-loader
+ */
+/**
+ * Loading performance metrics for a WASM module load/instantiate cycle.
+ */
+interface LoadingMetrics {
+    fileReadMs: number;
+    compileMs: number;
+    instantiateMs: number;
+    totalMs: number;
+    fromCache: boolean;
+}
+/**
+ * SHA-384 integrity manifest: maps a `.wasm` filename to its
+ * `"sha384-<base64 digest>"` value (SRI-style), as generated by
+ * `tools/generate-wasm-manifest.mjs`.
+ */
+interface WasmManifest {
+    [fileName: string]: string;
+}
+
+export { type BigNumberValue, type ConfigOptions, DEFAULT_CONFIG, DimensionError, FactoryFunction, type FormatOptions, type GeneralFormatOptions, type IdentifiedValue, Index, IndexError, type LoadingMetrics, type MathJsConfig, MathjsError, Matrix$1 as Matrix, type MemoizedFunction, type NestedArray, type NormalizedFormatOptions, type NumberTypeConfig, ObjectWrappingMap, PartitionedMap, type SplitValue, UnitConstructor, UnitDependencies, type WasmManifest, acosh, arraySize, asinh, assign as assignMap, atanh, broadcastArrays, broadcastSizes, broadcastTo, canDefineProperty, cbrt, checkBroadcastingRules, clone$1 as clone, clone as cloneArray, compareText, concat, containsCollections, copysign, cosh, createEmptyMap, createIndexError, createMap, createUnitClass, deepExtend, deepFlatten, deepForEach, deepForEach$1 as deepForEachArray, deepMap, deepMap$1 as deepMapArray, deepStrictEqual, digits, endsWith, escape, expm1, extend, filter, filterRegExp, flatten, forEach, format$2 as format, format as formatBigNumber, format$1 as formatGeneric, generalize, get$1 as get, getArrayDataType, get as getArrayElement, hasOwnProperty, identify, initial, isEmptyIndex, isInteger, isLegacyFactory, isObjectWrappingMap, isPowZeroAtInfinity, join, last, lazy, log10, log1p, log2, map, mapObject, memoize, nearlyEqual, normalizeFormatOptions, pick, pickShallow, processSizesWildcard, reduce, reshape, resize, roundDigits, safeNumberType, scatter, set, sign, sinh, splitNumber, squeeze, stretch, stringify, tanh, toEngineering$1 as toEngineering, toEngineering as toEngineeringBigNumber, toExponential$1 as toExponential, toExponential as toExponentialBigNumber, toFixed$1 as toFixed, toFixed as toFixedBigNumber, toObject, toPrecision, traverse, unitDependencies, unsqueeze, validate, validateIndex, validateIndexSourceSize, warnOnce };