@danielsimonjr/mathts-core 0.19.0 → 0.21.0

package/README.md

@@ -11,10 +11,11 @@ npm install @danielsimonjr/mathts-core
 ## Usage
 
 ```typescript
-import { DEFAULT_CONFIG, isNumber, isMatrix, VERSION } from '@danielsimonjr/mathts-core';
+import { DEFAULT_CONFIG, isNumber, isMatrix } from '@danielsimonjr/mathts-core';
+import { DenseMatrix } from '@danielsimonjr/mathts-matrix';
 
-// Default configuration
-const config = { ...DEFAULT_CONFIG, backend: 'wasm' };
+// Factory default configuration (MathTSConfig)
+const config = { ...DEFAULT_CONFIG, preferredBackend: 'wasm' };
 
 // Type guards
 console.log(isNumber(42)); // true
@@ -23,7 +24,12 @@ console.log(
     [1, 2],
     [3, 4],
   ])
-); // true
+); // false — nested arrays are not matrices
+const m = DenseMatrix.fromArray([
+  [1, 2],
+  [3, 4],
+]);
+console.log(isMatrix(m)); // true
 ```
 
 ## API
@@ -34,12 +40,31 @@ console.log(
 - `NumericType` - Numeric precision types
 - `MathTSConfig` - Configuration interface
 
+### SI dimension vectors
+
+`toSiDimensionVector` returns exact `Fraction` exponents `[L, M, T, I, Θ, N, J]`; use
+`vec.map((f) => f.toNumber())` when you need plain numbers (there is no
+`toSiDimensionNumbers` helper). `fromSiDimensionVector` accepts `SiDimensionExponent`
+(`number | Fraction`) and produces the length-10 `Unit` exponent array.
+
 ### Functions
 
+- `createSeededRng(seed)` / `SeededRng` — forkable Mulberry32 stream (`next`, `nextInt`, `normal`, `fork`); number seeds match `mulberry32`, strings are FNV-1a UTF-8 (not cryptographically secure)
+
+  ```ts
+  const rng = createSeededRng(42);
+  rng.next(); // 0.6011037519201636
+  rng.fork('a').next(); // 0.668102843221277
+  createSeededRng('a').seed; // -468965076
+  ```
+
+- `mulberry32(seed)` — seeded Mulberry32 PRNG returning U[0, 1) samples (not cryptographically secure)
+- `boxMuller(u1, u2)` — Box–Muller pair of N(0, 1) samples from two uniforms
+- `rowMajorStrides(shape)` — row-major stride vector for a dense tensor shape
 - `DEFAULT_CONFIG` - Default configuration object
 - `isNumber(value)` - Type guard for numbers
 - `isComplex(value)` - Type guard for complex numbers
-- `isMatrix(value)` - Type guard for matrices
+- `isMatrix(value)` - Type guard for matrix-like objects (`rows`, `cols`, `get`, `type`)
 
 ## License
 

package/dist/collection.d.ts

@@ -1,3 +1,4 @@
+import { type NestedArray } from './array.js';
 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>;
@@ -19,35 +20,46 @@ interface SparseMatrix<T = unknown> {
  */
 export 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
+ * Recursively loop over all elements in a given multi-dimensional array or matrix
+ * and invoke the callback on each scalar leaf.
+ *
+ * Nested arrays are first-class inputs: `deepForEach([[1, 2], 3], fn)` visits `1`, `2`, then `3`.
+ * For a matrix argument, recursion follows `forEach` with `recurse: true`.
+ *
+ * @param array - Nested array or matrix to iterate over
+ * @param callback - Invoked once per scalar element
  */
-export declare function deepForEach<T>(array: T[] | Matrix<T>, callback: (value: T) => void): void;
+export declare function deepForEach<T>(array: NestedArray<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.
+ * Map a callback over every scalar in a nested array or matrix, preserving structure.
+ *
+ * When `skipZeros` is `true`, numeric zero leaves are kept as the original value (`T`);
+ * other leaves become `callback(value)` (`U`), so the result type is `NestedArray<T | U>`
+ * or `Matrix<T | U>`. When `skipZeros` is omitted or `false`, every leaf is mapped to `U`.
  *
- * @return Mapped result
+ * @param array - Nested array or matrix to map over
+ * @param callback - Applied to each scalar element
+ * @param skipZeros - When true, skip the callback for zero values (zeros stay as `T`)
+ * @returns A nested array or matrix with the same shape as the input
  */
-export declare function deepMap<T, U>(array: T[] | Matrix<T>, callback: (value: T) => U, skipZeros?: boolean): U[] | Matrix<U>;
+export declare function deepMap<T, U>(array: Matrix<T>, callback: (value: T) => U, skipZeros: true): Matrix<T | U>;
+export declare function deepMap<T, U>(array: NestedArray<T>, callback: (value: T) => U, skipZeros: true): NestedArray<T | U>;
+export declare function deepMap<T, U>(array: Matrix<T>, callback: (value: T) => U, skipZeros?: false): Matrix<U>;
+export declare function deepMap<T, U>(array: NestedArray<T>, callback: (value: T) => U, skipZeros?: false): NestedArray<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
+ * Reduce a nested array or matrix along one dimension.
+ *
+ * For a one-dimensional nested array and `dim === 0`, the result is a **scalar** (`U`), not a
+ * one-element array — e.g. `reduce([1, 2, 3], 0, add)` is `6`. Higher-rank inputs return a
+ * nested array with one fewer effective dimension; matrices return a new matrix.
+ *
+ * @param mat - Nested array or matrix to reduce
+ * @param dim - Zero-based dimension index (must be in range for `arraySize(mat)`)
+ * @param callback - Fold function `(accumulator, value) => newAccumulator`
+ * @returns Scalar, nested array, or matrix depending on rank and `dim`
  */
-export declare function reduce<T, U>(mat: T[] | Matrix<T>, dim: number, callback: (acc: U | T, val: T) => U): U[] | Matrix<U>;
+export declare function reduce<T, U>(mat: Matrix<T>, dim: number, callback: (acc: U | T, val: T) => U): Matrix<U>;
+export declare function reduce<T, U>(mat: NestedArray<T>, dim: number, callback: (acc: U | T, val: T) => U): U | NestedArray<U>;
 /**
  * Scatter function for sparse matrix operations
  * @param a - Sparse matrix

package/dist/collection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../src/collection.ts"],"names":[],"mappings":"AAqBA,UAAU,MAAM,CAAC,CAAC,GAAG,OAAO;IAC1B,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IAClF,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACnF,IAAI,IAAI,MAAM,EAAE,CAAC;IACjB,OAAO,IAAI,CAAC,EAAE,CAAC;IACf,MAAM,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAChD,QAAQ,IAAI,MAAM,GAAG,SAAS,CAAC;CAChC;AAED,UAAU,YAAY,CAAC,CAAC,GAAG,OAAO;IAChC,OAAO,EAAE,CAAC,EAAE,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,CAO7D;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,IAAI,CAMzF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC1B,KAAK,EAAE,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,EACtB,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,EACzB,SAAS,CAAC,EAAE,OAAO,GAClB,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAcjB;AAED;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,GAAG,EAAE,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,EACpB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,GAClC,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAejB;AAwCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,EAClB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EAAE,EACX,CAAC,EAAE,CAAC,EAAE,GAAG,IAAI,EACb,CAAC,EAAE,MAAM,EAAE,EACX,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EAAE,EAChB,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,EACrB,OAAO,CAAC,EAAE,OAAO,EACjB,MAAM,CAAC,EAAE,OAAO,EAChB,KAAK,CAAC,EAAE,CAAC,GACR,IAAI,CA8DN"}
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../src/collection.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -17,10 +17,10 @@ export { addScalar, subtractScalar, multiplyScalar, divideScalar, pow, abs, fix,
 export type { NumericScalar } from './arithmetic/scalar.js';
 export { Unit, isUnit as isUnitValue, DimensionMismatchError, UnitParseError, DIMENSIONLESS, dim, } from './types/unit.js';
 export type { Dimensions, UnitDef, UnitInstance } from './types/unit.js';
-export { UNIT_EXACT_SCALE, PI_EXACT_SCALE, LN2_EXACT_SCALE, NAMED_IRRATIONALS, namedIrrationalScale, irrationalPower, isRationalScale, decimalExactScale, exactScaleOf, binaryExactScale, ratioExactScale, multiplyExactScales, divideExactScales, powerExactScale, addExactScales, exactScalesEqual, exactScaleToNumber, clearExactScaleNumberCache, exactScaleNumberCacheSize, formatExactScale, readScaleExpression, NAMED_SCALES, UNIT_ROWS, UNIT_ROW_ALIASES, namedExactScale, readUnitScale, getUnitRow, unitRowExactScale, unitRowValue, unitRowExactOffset, UNIT_PREFIX_SETS, unitPrefixExactScale, getUnitPrefix, } from './types/unit.js';
+export { UNIT_EXACT_SCALE, PI_EXACT_SCALE, LN2_EXACT_SCALE, NAMED_IRRATIONALS, namedIrrationalScale, irrationalPower, isRationalScale, decimalExactScale, exactScaleOf, binaryExactScale, ratioExactScale, multiplyExactScales, divideExactScales, powerExactScale, addExactScales, exactScalesEqual, exactScaleToNumber, clearExactScaleNumberCache, exactScaleNumberCacheSize, formatExactScale, readScaleExpression, NAMED_SCALES, UNIT_ROWS, UNIT_ROW_ALIASES, REFUSED_UNIT_SPELLINGS, namedExactScale, readUnitScale, getUnitRow, unitRowExactScale, unitRowValue, unitRowExactOffset, UNIT_PREFIX_SETS, unitPrefixExactScale, getUnitPrefix, } from './types/unit.js';
 export type { ExactScale, IrrationalName, IrrationalPowers, UnitRow, UnitBaseKey, UnitPrefixSetKey, UnitPrefix, } from './types/unit.js';
 export { UNIT_DIMENSION_LENGTH, SI_DIMENSION_LENGTH, toSiDimensions, toSiDimensionVector, fromSiDimensions, fromSiDimensionVector, } from './types/unit.js';
-export type { SiDimensionVector, SiDimensionOptions } from './types/unit.js';
+export type { SiDimensionVector, SiDimensionOptions, SiDimensionExponent } from './types/unit.js';
 export { BASE_UNITS, DERIVED_UNITS, ALL_UNITS, UNIT_ALIASES, getUnitDef, } from './types/unit-definitions.js';
 export { SI_PREFIXES, BEST_PREFIXES, getPrefix } from './types/unit-prefixes.js';
 export { mathTyped, createMathTSTyped, typed, create, createTypedFunction, TypeRegistry, MATHTS_TYPES, MATHTS_CONVERSIONS, isNumber, isBoolean, isString, isBigInt, isArray, isFunction, isObject, isNull, isUndefined, isMatrix, isDenseMatrix, isSparseMatrix, isUnit, initTypedWasm, isTypedWasmAvailable, registerNativeTypes, } from './typed/index.js';
@@ -29,4 +29,6 @@ export { FunctionRegistry, createFactory, registry, math, DEFAULT_CONFIG, } from
 export type { MathTSConfig, FactoryFunction, FactoryDependencies, FactoryImport, } from './factory/index.js';
 export declare const VERSION: string;
 export { pairwiseSum, neumaierSum, norm2, pairwiseDot, scaledDistance, neumaierCumsum, sumSquaredDeviations, } from './numeric/stable.js';
+export { mulberry32, boxMuller, createSeededRng, type SeededRng } from './numeric/rng.js';
+export { rowMajorStrides } from './numeric/strides.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH,YAAY,EACV,WAAW,EACX,MAAM,EACN,WAAW,EACX,WAAW,EACX,aAAa,EACb,OAAO,EACP,QAAQ,EACR,SAAS,EACT,UAAU,EACV,gBAAgB,GACjB,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,OAAO,EACP,SAAS,EACT,CAAC,EACD,YAAY,EACZ,WAAW,EACX,eAAe,GAChB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAE,gBAAgB,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAClE,YAAY,EACV,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,SAAS,GACV,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAE/C,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,YAAY,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAG9E,OAAO,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAG3F,OAAO,EACL,QAAQ,EACR,UAAU,EACV,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,gBAAgB,GACjB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACL,SAAS,EACT,WAAW,EACX,cAAc,EACd,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,YAAY,EACZ,WAAW,EACX,aAAa,EACb,cAAc,GACf,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAG1E,OAAO,EACL,SAAS,EACT,cAAc,EACd,cAAc,EACd,YAAY,EACZ,GAAG,EACH,GAAG,EACH,GAAG,EACH,KAAK,EACL,KAAK,EACL,SAAS,EACT,MAAM,GACP,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAG5D,OAAO,EACL,IAAI,EACJ,MAAM,IAAI,WAAW,EACrB,sBAAsB,EACtB,cAAc,EACd,aAAa,EACb,GAAG,GACJ,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,UAAU,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,oBAAoB,EACpB,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,EAChB,eAAe,EACf,mBAAmB,EACnB,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAClB,0BAA0B,EAC1B,yBAAyB,EACzB,gBAAgB,EAChB,mBAAmB,EACnB,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,eAAe,EACf,aAAa,EACb,UAAU,EACV,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,aAAa,GACd,MAAM,iBAAiB,CAAC;AACzB,YAAY,EACV,UAAU,EACV,cAAc,EACd,gBAAgB,EAChB,OAAO,EACP,WAAW,EACX,gBAAgB,EAChB,UAAU,GACX,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,qBAAqB,EACrB,mBAAmB,EACnB,cAAc,EACd,mBAAmB,EACnB,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC7E,OAAO,EACL,UAAU,EACV,aAAa,EACb,SAAS,EACT,YAAY,EACZ,UAAU,GACX,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAMjF,OAAO,EAEL,SAAS,EACT,iBAAiB,EACjB,KAAK,EACL,MAAM,EACN,mBAAmB,EACnB,YAAY,EAGZ,YAAY,EACZ,kBAAkB,EAGlB,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,UAAU,EACV,QAAQ,EACR,MAAM,EACN,WAAW,EAGX,QAAQ,EACR,aAAa,EACb,cAAc,EAGd,MAAM,EAGN,aAAa,EACb,oBAAoB,EAGpB,mBAAmB,GACpB,MAAM,kBAAkB,CAAC;AAE1B,YAAY,EACV,aAAa,EACb,aAAa,EACb,OAAO,EACP,aAAa,EACb,iBAAiB,EACjB,OAAO,EACP,WAAW,GACZ,MAAM,kBAAkB,CAAC;AAM1B,OAAO,EACL,gBAAgB,EAChB,aAAa,EACb,QAAQ,EACR,IAAI,EACJ,cAAc,GACf,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EACV,YAAY,EACZ,eAAe,EACf,mBAAmB,EACnB,aAAa,GACd,MAAM,oBAAoB,CAAC;AAW5B,eAAO,MAAM,OAAO,EAAE,MAAwB,CAAC;AAI/C,OAAO,EACL,WAAW,EACX,WAAW,EACX,KAAK,EACL,WAAW,EACX,cAAc,EACd,cAAc,EACd,oBAAoB,GACrB,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -1,4 +1,4 @@
-import { $ as BIGNUMBER_LN2, A as irrationalPower, B as addScalar, Bn as I, C as decimalExactScale, D as exactScaleToNumber, E as exactScaleOf, F as ratioExactScale, G as multiplyScalar, H as equal, I as readScaleExpression, In as COMPLEX_NEG_ONE, J as round, K as number, L as DimensionMismatchError, Ln as COMPLEX_ONE, M as multiplyExactScales, N as namedIrrationalScale, O as exactScalesEqual, P as powerExactScale, Pn as isUnit$1, Q as BIGNUMBER_LN10, R as UnitParseError, Rn as COMPLEX_ZERO, S as clearExactScaleNumberCache, T as exactScaleNumberCacheSize, U as fix, V as divideScalar, Vn as isComplex, W as isNumeric, Y as subtractScalar, Yt as format, Z as BIGNUMBER_E, _ as NAMED_IRRATIONALS, _t as factory, a as UNIT_PREFIX_SETS, an as sign, at as BigNumber, b as addExactScales, c as getUnitPrefix, ct as FRACTION_NEG_ONE, d as readUnitScale, dt as FRACTION_THIRD, et as BIGNUMBER_NEG_ONE, f as unitPrefixExactScale, ft as FRACTION_ZERO, g as LN2_EXACT_SCALE, h as unitRowValue, hn as isBigNumber$2, i as NAMED_SCALES, it as BIGNUMBER_ZERO, j as isRationalScale, k as formatExactScale, l as getUnitRow, lt as FRACTION_ONE, m as unitRowExactScale, mn as isBigInt$1, mt as isFraction, nt as BIGNUMBER_PI, o as UNIT_ROWS, ot as isBigNumber, p as unitRowExactOffset, pt as Fraction, q as pow, rt as BIGNUMBER_TEN, s as UNIT_ROW_ALIASES, st as FRACTION_HALF, t as Unit, tn as nearlyEqual, tt as BIGNUMBER_ONE, u as namedExactScale, ut as FRACTION_QUARTER, v as PI_EXACT_SCALE, w as divideExactScales, x as binaryExactScale, y as UNIT_EXACT_SCALE, z as abs, zn as Complex } from "./unit-l_r8z5Fv.js";
+import { $ as BIGNUMBER_LN10, A as formatExactScale, B as abs, Bn as Complex, C as clearExactScaleNumberCache, D as exactScaleOf, E as exactScaleNumberCacheSize, F as powerExactScale, Fn as isUnit$1, G as isNumeric, H as divideScalar, Hn as isComplex, I as ratioExactScale, J as pow, K as multiplyScalar, L as readScaleExpression, Ln as COMPLEX_NEG_ONE, M as isRationalScale, N as multiplyExactScales, O as exactScaleToNumber, P as namedIrrationalScale, Q as BIGNUMBER_E, R as DimensionMismatchError, Rn as COMPLEX_ONE, S as binaryExactScale, T as divideExactScales, U as equal, V as addScalar, Vn as I, W as fix, X as subtractScalar, Xt as format, Y as round, _ as LN2_EXACT_SCALE, a as REFUSED_UNIT_SPELLINGS, at as BIGNUMBER_ZERO, b as UNIT_EXACT_SCALE, c as UNIT_ROW_ALIASES, ct as FRACTION_HALF, d as namedExactScale, dt as FRACTION_QUARTER, et as BIGNUMBER_LN2, f as readUnitScale, ft as FRACTION_THIRD, g as unitRowValue, gn as isBigNumber$2, h as unitRowExactScale, hn as isBigInt$1, ht as isFraction, i as NAMED_SCALES, it as BIGNUMBER_TEN, j as irrationalPower, k as exactScalesEqual, l as getUnitPrefix, lt as FRACTION_NEG_ONE, m as unitRowExactOffset, mt as Fraction, nn as nearlyEqual, nt as BIGNUMBER_ONE, o as UNIT_PREFIX_SETS, on as sign, ot as BigNumber, p as unitPrefixExactScale, pt as FRACTION_ZERO, q as number, rt as BIGNUMBER_PI, s as UNIT_ROWS, st as isBigNumber, t as Unit, tt as BIGNUMBER_NEG_ONE, u as getUnitRow, ut as FRACTION_ONE, v as NAMED_IRRATIONALS, vt as factory, w as decimalExactScale, x as addExactScales, y as PI_EXACT_SCALE, z as UnitParseError, zn as COMPLEX_ZERO } from "./unit-D3yD3jbu.js";
 import typed, { create } from "typed-function";
 const createRangeClass = /* #__PURE__ */ factory("Range", [], () => {
 	class Range {
@@ -580,6 +580,15 @@ const EXTRA_INDEXES = [
 function assertFinite(label, value) {
 	if (typeof value !== "number" || !Number.isFinite(value)) throw new TypeError(`${label} must be a finite number`);
 }
+function numberToFractionExponent(value, label = "exponent") {
+	assertFinite(label, value);
+	if (Number.isInteger(value)) return new Fraction(BigInt(value), 1n);
+	return Fraction.fromNumber(value);
+}
+function siExponentToFraction(value, label = "exponent") {
+	if (isFraction(value)) return value;
+	return numberToFractionExponent(value, label);
+}
 function assertUnitVector(vector) {
 	if (vector.length !== 10) throw new TypeError(`dimension vector must have length 10`);
 	for (let i = 0; i < vector.length; i++) assertFinite(`dimension vector[${i}]`, vector[i]);
@@ -604,13 +613,13 @@ function toSiDimensions(vector, options) {
 function toSiDimensionVector(vector, options) {
 	const d = toSiDimensions(vector, options);
 	return [
-		d.length,
-		d.mass,
-		d.time,
-		d.current,
-		d.temperature,
-		d.amount,
-		d.luminosity
+		numberToFractionExponent(d.length),
+		numberToFractionExponent(d.mass),
+		numberToFractionExponent(d.time),
+		numberToFractionExponent(d.current),
+		numberToFractionExponent(d.temperature),
+		numberToFractionExponent(d.amount),
+		numberToFractionExponent(d.luminosity)
 	];
 }
 function fromSiDimensions(dimensions) {
@@ -639,14 +648,20 @@ function fromSiDimensions(dimensions) {
 }
 function fromSiDimensionVector(vector) {
 	if (vector.length !== 7) throw new TypeError(`SI dimension vector must have length 7 [L, M, T, I, Θ, N, J]`);
+	const nums = vector.map((component, i) => {
+		const label = `SI dimension vector[${i}]`;
+		const n = siExponentToFraction(component, label).toNumber();
+		assertFinite(label, n);
+		return n;
+	});
 	return fromSiDimensions({
-		length: vector[0],
-		mass: vector[1],
-		time: vector[2],
-		current: vector[3],
-		temperature: vector[4],
-		amount: vector[5],
-		luminosity: vector[6]
+		length: nums[0],
+		mass: nums[1],
+		time: nums[2],
+		current: nums[3],
+		temperature: nums[4],
+		amount: nums[5],
+		luminosity: nums[6]
 	});
 }
 //#endregion
@@ -1302,7 +1317,96 @@ function neumaierCumsum(xs, out) {
 	}
 }
 //#endregion
+//#region src/numeric/rng.ts
+function mulberry32(seed) {
+	let s = seed | 0;
+	return () => {
+		s = s + 1831565813 | 0;
+		let z = s;
+		z = Math.imul(z ^ z >>> 15, z | 1);
+		z ^= z + Math.imul(z ^ z >>> 7, z | 61);
+		z = (z ^ z >>> 14) >>> 0;
+		return z / 4294967296;
+	};
+}
+function boxMuller(u1, u2) {
+	const r = Math.sqrt(-2 * Math.log(u1 === 0 ? Number.EPSILON : u1));
+	const theta = 2 * Math.PI * u2;
+	return [r * Math.cos(theta), r * Math.sin(theta)];
+}
+const FNV_OFFSET = 2166136261;
+const FNV_PRIME = 16777619;
+function fnv1a32(bytes) {
+	let h = FNV_OFFSET;
+	for (let i = 0; i < bytes.length; i++) {
+		h ^= bytes[i];
+		h = Math.imul(h, FNV_PRIME) >>> 0;
+	}
+	return h >>> 0;
+}
+const textEncoder = new TextEncoder();
+function coerceSeedInt(seed) {
+	if (typeof seed === "number") return seed | 0;
+	if (typeof seed === "string") return fnv1a32(textEncoder.encode(seed)) | 0;
+	throw new TypeError("seed must be a number or a string");
+}
+function mixFork(parentSeed, label) {
+	const payload = [
+		parentSeed >>> 0 & 255,
+		parentSeed >>> 8 & 255,
+		parentSeed >>> 16 & 255,
+		parentSeed >>> 24 & 255
+	];
+	if (typeof label === "number") {
+		const n = label | 0;
+		payload.push(0, n >>> 0 & 255, n >>> 8 & 255, n >>> 16 & 255, n >>> 24 & 255);
+	} else if (typeof label === "string") {
+		payload.push(1);
+		for (const b of textEncoder.encode(label)) payload.push(b);
+	} else throw new TypeError("fork label must be a string or a number");
+	return fnv1a32(new Uint8Array(payload)) | 0;
+}
+function makeSeededRng(seedInt) {
+	const uniform = mulberry32(seedInt);
+	let spare = null;
+	return Object.freeze({
+		seed: seedInt,
+		next: () => uniform(),
+		nextInt(maxExclusive) {
+			if (!Number.isInteger(maxExclusive) || maxExclusive < 1 || maxExclusive > 4294967296) throw new RangeError("maxExclusive must be an integer in [1, 4294967296]");
+			return Math.floor(uniform() * maxExclusive);
+		},
+		normal() {
+			if (spare !== null) {
+				const z = spare;
+				spare = null;
+				return z;
+			}
+			const pair = boxMuller(uniform(), uniform());
+			spare = pair[1];
+			return pair[0];
+		},
+		fork(label) {
+			return makeSeededRng(mixFork(seedInt, label));
+		}
+	});
+}
+function createSeededRng(seed) {
+	return makeSeededRng(coerceSeedInt(seed));
+}
+//#endregion
+//#region src/numeric/strides.ts
+function rowMajorStrides(shape) {
+	const strides = new Array(shape.length);
+	let acc = 1;
+	for (let k = shape.length - 1; k >= 0; k--) {
+		strides[k] = acc;
+		acc *= shape[k];
+	}
+	return strides;
+}
+//#endregion
 //#region src/index.ts
-const VERSION = "0.19.0";
+const VERSION = "0.21.0";
 //#endregion
-export { ALL_UNITS, BASE_UNITS, BEST_PREFIXES, BIGNUMBER_E, BIGNUMBER_LN10, BIGNUMBER_LN2, BIGNUMBER_NEG_ONE, BIGNUMBER_ONE, BIGNUMBER_PI, BIGNUMBER_TEN, BIGNUMBER_ZERO, BigNumber, COMPLEX_NEG_ONE, COMPLEX_ONE, COMPLEX_ZERO, Complex, DEFAULT_CONFIG, DERIVED_UNITS, DIMENSIONLESS, DUAL_UNARY_RULES, DimensionMismatchError, Dual, E, FRACTION_HALF, FRACTION_NEG_ONE, FRACTION_ONE, FRACTION_QUARTER, FRACTION_THIRD, FRACTION_ZERO, Fraction, FunctionRegistry, I, LN10, LN2, LN2_EXACT_SCALE, LOG10E, LOG2E, MATHTS_CONVERSIONS, MATHTS_TYPES, NAMED_IRRATIONALS, NAMED_SCALES, PHI, PI, PI_EXACT_SCALE, Range, SI_DIMENSION_LENGTH, SI_PREFIXES, SQRT1_2, SQRT2, TAU, TypeRegistry, UNIT_ALIASES, UNIT_DIMENSION_LENGTH, UNIT_EXACT_SCALE, UNIT_PREFIX_SETS, UNIT_ROWS, UNIT_ROW_ALIASES, Unit, UnitParseError, VERSION, abs, addExactScales, addScalar, binaryExactScale, clearExactScaleNumberCache, create, createFactory, createMathTSTyped, createRangeClass, createTypedFunction, decimalExactScale, dim, divideExactScales, divideScalar, equal, exactScaleNumberCacheSize, exactScaleOf, exactScaleToNumber, exactScalesEqual, fix, formatExactScale, fromSiDimensionVector, fromSiDimensions, getPrefix, getUnitDef, getUnitPrefix, getUnitRow, initTypedWasm, irrationalPower, isArray, isBigInt, isBigNumber, isBoolean, isComplex, isDenseMatrix, isDual, isFraction, isFunction, isMatrix, isNull, isNumber, isNumeric, isObject, isRationalScale, isSparseMatrix, isString, isTypedWasmAvailable, isUndefined, isUnit, isUnit$1 as isUnitValue, math, mathTyped, multiplyExactScales, multiplyScalar, namedExactScale, namedIrrationalScale, neumaierCumsum, neumaierSum, norm2, number, pairwiseDot, pairwiseSum, pow, powerExactScale, ratioExactScale, readScaleExpression, readUnitScale, registerNativeTypes, registry, round, scaledDistance, subtractScalar, sumSquaredDeviations, toSiDimensionVector, toSiDimensions, typed, unitPrefixExactScale, unitRowExactOffset, unitRowExactScale, unitRowValue };
+export { ALL_UNITS, BASE_UNITS, BEST_PREFIXES, BIGNUMBER_E, BIGNUMBER_LN10, BIGNUMBER_LN2, BIGNUMBER_NEG_ONE, BIGNUMBER_ONE, BIGNUMBER_PI, BIGNUMBER_TEN, BIGNUMBER_ZERO, BigNumber, COMPLEX_NEG_ONE, COMPLEX_ONE, COMPLEX_ZERO, Complex, DEFAULT_CONFIG, DERIVED_UNITS, DIMENSIONLESS, DUAL_UNARY_RULES, DimensionMismatchError, Dual, E, FRACTION_HALF, FRACTION_NEG_ONE, FRACTION_ONE, FRACTION_QUARTER, FRACTION_THIRD, FRACTION_ZERO, Fraction, FunctionRegistry, I, LN10, LN2, LN2_EXACT_SCALE, LOG10E, LOG2E, MATHTS_CONVERSIONS, MATHTS_TYPES, NAMED_IRRATIONALS, NAMED_SCALES, PHI, PI, PI_EXACT_SCALE, REFUSED_UNIT_SPELLINGS, Range, SI_DIMENSION_LENGTH, SI_PREFIXES, SQRT1_2, SQRT2, TAU, TypeRegistry, UNIT_ALIASES, UNIT_DIMENSION_LENGTH, UNIT_EXACT_SCALE, UNIT_PREFIX_SETS, UNIT_ROWS, UNIT_ROW_ALIASES, Unit, UnitParseError, VERSION, abs, addExactScales, addScalar, binaryExactScale, boxMuller, clearExactScaleNumberCache, create, createFactory, createMathTSTyped, createRangeClass, createSeededRng, createTypedFunction, decimalExactScale, dim, divideExactScales, divideScalar, equal, exactScaleNumberCacheSize, exactScaleOf, exactScaleToNumber, exactScalesEqual, fix, formatExactScale, fromSiDimensionVector, fromSiDimensions, getPrefix, getUnitDef, getUnitPrefix, getUnitRow, initTypedWasm, irrationalPower, isArray, isBigInt, isBigNumber, isBoolean, isComplex, isDenseMatrix, isDual, isFraction, isFunction, isMatrix, isNull, isNumber, isNumeric, isObject, isRationalScale, isSparseMatrix, isString, isTypedWasmAvailable, isUndefined, isUnit, isUnit$1 as isUnitValue, math, mathTyped, mulberry32, multiplyExactScales, multiplyScalar, namedExactScale, namedIrrationalScale, neumaierCumsum, neumaierSum, norm2, number, pairwiseDot, pairwiseSum, pow, powerExactScale, ratioExactScale, readScaleExpression, readUnitScale, registerNativeTypes, registry, round, rowMajorStrides, scaledDistance, subtractScalar, sumSquaredDeviations, toSiDimensionVector, toSiDimensions, typed, unitPrefixExactScale, unitRowExactOffset, unitRowExactScale, unitRowValue };

package/dist/internal.d.ts

@@ -22,7 +22,7 @@ export { IndexError, createIndexError } from './error/IndexError.js';
 export * from './factory.js';
 export { format as formatGeneric, stringify, escape, compareText, type GeneralFormatOptions, } from './string.js';
 export { format as formatBigNumber, toEngineering as toEngineeringBigNumber, toExponential as toExponentialBigNumber, toFixed as toFixedBigNumber, type BigNumberValue, } from './bignumber-formatter.js';
-export type * from './types/unit/unit-types.js';
+export type { ComplexValue, ComplexConstructor, BigNumberConstructor, FractionConstructor, FractionValue, Numeric, PrefixDef, PrefixTable, BaseUnitDef, UnitDef, UnitComponent, UnitSystemEntry, UnitSystem, UnitJSON, ConverterFn, TypeConverters, ParseOptions, UnitFormatOptions, CreateUnitOptions, CreateUnitDefObject, UnitConfig, SubtractScalar, ScalarBinaryOp, ScalarUnaryOp, UnitDependencies, UnitInstance, UnitConstructor, } from './types/unit/unit-types.js';
 export { createUnitClass, unitDependencies, Unit as CoreUnit } from './types/unit/index.js';
 export type { NestedArray, IdentifiedValue } from './array.js';
 export { arraySize, validate, validateIndexSourceSize, validateIndex, isEmptyIndex, resize, reshape, processSizesWildcard, squeeze, unsqueeze, flatten, map, forEach, filter, filterRegExp, join, identify, generalize, getArrayDataType, last, initial, concat, broadcastSizes, checkBroadcastingRules, broadcastTo, broadcastArrays, stretch, get as getArrayElement, deepMap as deepMapArray, deepForEach as deepForEachArray, clone as cloneArray, } from './array.js';
@@ -30,5 +30,6 @@ export { containsCollections, deepMap, deepForEach, reduce, scatter } from './co
 export { _switch } from './switch.js';
 export { ObjectWrappingMap, PartitionedMap, createEmptyMap, createMap, toObject, assign as assignMap, isObjectWrappingMap, } from './map.js';
 export type { LoadingMetrics, WasmManifest } from './types/wasm-loader.js';
-export { sha384OfBuffer, loadWasmManifest, verifyWasmIntegrity, resolvePackagedWasm, defaultWasmLocation, } from './wasm-loader.js';
+export { sha384OfBuffer, loadWasmManifest, verifyWasmIntegrity, resolvePackagedWasm, defaultWasmLocation, WasmModuleLoader, } from './wasm-loader.js';
+export { allocAsHeader } from './wasm-as-header.js';
 //# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC1E,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AASpD,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAU7C,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAoBrE,cAAc,cAAc,CAAC;AAM7B,OAAO,EACL,MAAM,IAAI,aAAa,EACvB,SAAS,EACT,MAAM,EACN,WAAW,EACX,KAAK,oBAAoB,GAC1B,MAAM,aAAa,CAAC;AAMrB,OAAO,EACL,MAAM,IAAI,eAAe,EACzB,aAAa,IAAI,sBAAsB,EACvC,aAAa,IAAI,sBAAsB,EACvC,OAAO,IAAI,gBAAgB,EAC3B,KAAK,cAAc,GACpB,MAAM,0BAA0B,CAAC;AAIlC,mBAAmB,4BAA4B,CAAC;AAMhD,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAe5F,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,EACL,SAAS,EACT,QAAQ,EACR,uBAAuB,EACvB,aAAa,EACb,YAAY,EACZ,MAAM,EACN,OAAO,EACP,oBAAoB,EACpB,OAAO,EACP,SAAS,EACT,OAAO,EACP,GAAG,EACH,OAAO,EACP,MAAM,EACN,YAAY,EACZ,IAAI,EACJ,QAAQ,EACR,UAAU,EACV,gBAAgB,EAChB,IAAI,EACJ,OAAO,EACP,MAAM,EACN,cAAc,EACd,sBAAsB,EACtB,WAAW,EACX,eAAe,EACf,OAAO,EACP,GAAG,IAAI,eAAe,EACtB,OAAO,IAAI,YAAY,EACvB,WAAW,IAAI,gBAAgB,EAC/B,KAAK,IAAI,UAAU,GACpB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,mBAAmB,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC7F,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,SAAS,EACT,QAAQ,EACR,MAAM,IAAI,SAAS,EACnB,mBAAmB,GACpB,MAAM,UAAU,CAAC;AAOlB,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAc3E,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,GACpB,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAC1E,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AASpD,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAU7C,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAoBrE,cAAc,cAAc,CAAC;AAM7B,OAAO,EACL,MAAM,IAAI,aAAa,EACvB,SAAS,EACT,MAAM,EACN,WAAW,EACX,KAAK,oBAAoB,GAC1B,MAAM,aAAa,CAAC;AAMrB,OAAO,EACL,MAAM,IAAI,eAAe,EACzB,aAAa,IAAI,sBAAsB,EACvC,aAAa,IAAI,sBAAsB,EACvC,OAAO,IAAI,gBAAgB,EAC3B,KAAK,cAAc,GACpB,MAAM,0BAA0B,CAAC;AAIlC,YAAY,EACV,YAAY,EACZ,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,EACnB,aAAa,EACb,OAAO,EACP,SAAS,EACT,WAAW,EACX,WAAW,EACX,OAAO,EACP,aAAa,EACb,eAAe,EACf,UAAU,EACV,QAAQ,EACR,WAAW,EACX,cAAc,EACd,YAAY,EACZ,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,UAAU,EACV,cAAc,EACd,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,YAAY,EACZ,eAAe,GAChB,MAAM,4BAA4B,CAAC;AAMpC,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAe5F,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC/D,OAAO,EACL,SAAS,EACT,QAAQ,EACR,uBAAuB,EACvB,aAAa,EACb,YAAY,EACZ,MAAM,EACN,OAAO,EACP,oBAAoB,EACpB,OAAO,EACP,SAAS,EACT,OAAO,EACP,GAAG,EACH,OAAO,EACP,MAAM,EACN,YAAY,EACZ,IAAI,EACJ,QAAQ,EACR,UAAU,EACV,gBAAgB,EAChB,IAAI,EACJ,OAAO,EACP,MAAM,EACN,cAAc,EACd,sBAAsB,EACtB,WAAW,EACX,eAAe,EACf,OAAO,EACP,GAAG,IAAI,eAAe,EACtB,OAAO,IAAI,YAAY,EACvB,WAAW,IAAI,gBAAgB,EAC/B,KAAK,IAAI,UAAU,GACpB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,mBAAmB,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC7F,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,SAAS,EACT,QAAQ,EACR,MAAM,IAAI,SAAS,EACnB,mBAAmB,GACpB,MAAM,UAAU,CAAC;AAOlB,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAe3E,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/internal.js

@@ -1,4 +1,4 @@
-import { $t as log1p, An as isRegExp, At as isLegacyFactory, Bt as warnOnce, Cn as isIndex, Ct as canDefineProperty, Dn as isNumber, Dt as deepStrictEqual, En as isNull, Et as deepFlatten, Fn as typeOf, Ft as set, Gt as copysign, Ht as asinh, It as traverse, Jt as expm1, Kt as cosh, Lt as endsWith, Mn as isString, Mt as mapObject, Nn as isUndefined, Nt as pick, On as isObject, Ot as extend, Pn as isUnit, Pt as pickShallow, Qt as log10, Rt as hasOwnProperty, Sn as isFunction, St as MathjsError, Tn as isMatrix, Tt as deepExtend, Ut as atanh, Vt as acosh, Wt as cbrt, X as DEFAULT_CONFIG, Xt as isInteger, Yt as format, Zt as isPowZeroAtInfinity, _n as isCollection, _t as factory, an as sign, bn as isDenseMatrix, bt as sortFactories, cn as tanh, dn as toFixed, en as log2, fn as toPrecision, gn as isBoolean, gt as create, hn as isBigNumber, ht as assertDependencies, in as safeNumberType, jn as isSparseMatrix, jt as lazy, kn as isRange, kt as get, ln as toEngineering, mn as isBigInt, n as unitDependencies, nn as normalizeFormatOptions, on as sinh, pn as isArray, qt as digits, r as createUnitClass, rn as roundDigits, sn as splitNumber, t as Unit, tn as nearlyEqual, un as toExponential, vn as isComplex, vt as isFactory, wn as isMap, wt as clone, xn as isFraction, xt as stripOptionalNotation, yn as isDate, yt as isOptionalDependency, zt as memoize } from "./unit-l_r8z5Fv.js";
+import { $t as log10, An as isRange, At as get, Bt as memoize, Cn as isFunction, Ct as MathjsError, Dn as isNull, Dt as deepFlatten, En as isMatrix, Et as deepExtend, Fn as isUnit, Ft as pickShallow, Gt as cbrt, Ht as acosh, In as typeOf, It as set, Jt as digits, Kt as copysign, Lt as traverse, Mn as isSparseMatrix, Mt as lazy, Nn as isString, Nt as mapObject, On as isNumber, Ot as deepStrictEqual, Pn as isUndefined, Pt as pick, Qt as isPowZeroAtInfinity, Rt as endsWith, Sn as isFraction, St as stripOptionalNotation, Tn as isMap, Tt as clone, Ut as asinh, Vt as warnOnce, Wt as atanh, Xt as format, Yt as expm1, Z as DEFAULT_CONFIG, Zt as isInteger, _n as isBoolean, _t as create, an as safeNumberType, bn as isDate, bt as isOptionalDependency, cn as splitNumber, dn as toExponential, en as log1p, fn as toFixed, gn as isBigNumber, gt as assertDependencies, hn as isBigInt, in as roundDigits, jn as isRegExp, jt as isLegacyFactory, kn as isObject, kt as extend, ln as tanh, mn as isArray, n as unitDependencies, nn as nearlyEqual, on as sign, pn as toPrecision, qt as cosh, r as createUnitClass, rn as normalizeFormatOptions, sn as sinh, t as Unit, tn as log2, un as toEngineering, vn as isCollection, vt as factory, wn as isIndex, wt as canDefineProperty, xn as isDenseMatrix, xt as sortFactories, yn as isComplex, yt as isFactory, zt as hasOwnProperty } from "./unit-D3yD3jbu.js";
 //#region src/error/DimensionError.ts
 var DimensionError = class DimensionError extends RangeError {
 	actual;
@@ -984,5 +984,164 @@ async function defaultWasmLocation(metaUrl, wasmFile, opts) {
 	}
 	return join(dirname(fileURLToPath(metaUrl)), "wasm", wasmFile);
 }
+var WasmModuleLoader = class {
+	wasmModule = null;
+	compiledModule = null;
+	loading = null;
+	isNode;
+	lastMetrics = null;
+	constructor() {
+		this.isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
+	}
+	async load(wasmPath) {
+		if (this.wasmModule) return this.wasmModule;
+		if (this.loading) return this.loading;
+		this.loading = this.loadModule(wasmPath);
+		try {
+			this.wasmModule = await this.loading;
+		} catch (error) {
+			this.compiledModule = null;
+			throw error;
+		} finally {
+			this.loading = null;
+		}
+		return this.wasmModule;
+	}
+	async loadModule(wasmPath) {
+		const path = wasmPath || await this.getDefaultWasmPath();
+		const totalStart = performance.now();
+		if (this.compiledModule) {
+			const instStart = performance.now();
+			const instance = await WebAssembly.instantiate(this.compiledModule, this.getImports());
+			this.lastMetrics = {
+				fileReadMs: 0,
+				compileMs: 0,
+				instantiateMs: performance.now() - instStart,
+				totalMs: performance.now() - totalStart,
+				fromCache: true
+			};
+			return instance.exports;
+		}
+		if (this.isNode) return this.loadNodeWasm(path, totalStart);
+		return this.loadBrowserWasm(path, totalStart);
+	}
+	async precompile(wasmPath) {
+		if (this.compiledModule) return;
+		const path = wasmPath || await this.getDefaultWasmPath();
+		const startTime = performance.now();
+		if (this.isNode) {
+			const fs = await import("fs");
+			const { promisify } = await import("util");
+			const buffer = await promisify(fs.readFile)(path);
+			await verifyWasmIntegrity(buffer, path);
+			this.compiledModule = await WebAssembly.compile(buffer);
+		} else {
+			const manifest = await loadWasmManifest(path);
+			if (!manifest && typeof WebAssembly.compileStreaming === "function") this.compiledModule = await WebAssembly.compileStreaming(fetch(path));
+			else {
+				const buffer = await (await fetch(path)).arrayBuffer();
+				await verifyWasmIntegrity(buffer, path, { manifest });
+				this.compiledModule = await WebAssembly.compile(buffer);
+			}
+		}
+		this.lastMetrics = {
+			fileReadMs: 0,
+			compileMs: performance.now() - startTime,
+			instantiateMs: 0,
+			totalMs: performance.now() - startTime,
+			fromCache: false
+		};
+	}
+	async loadNodeWasm(path, totalStart) {
+		const fs = await import("fs");
+		const { promisify } = await import("util");
+		const readFile = promisify(fs.readFile);
+		const readStart = performance.now();
+		const buffer = await readFile(path);
+		const readEnd = performance.now();
+		await verifyWasmIntegrity(buffer, path);
+		const compileStart = performance.now();
+		this.compiledModule = await WebAssembly.compile(buffer);
+		const compileEnd = performance.now();
+		const instStart = performance.now();
+		const instance = await WebAssembly.instantiate(this.compiledModule, this.getImports());
+		const instEnd = performance.now();
+		this.lastMetrics = {
+			fileReadMs: readEnd - readStart,
+			compileMs: compileEnd - compileStart,
+			instantiateMs: instEnd - instStart,
+			totalMs: performance.now() - totalStart,
+			fromCache: false
+		};
+		return instance.exports;
+	}
+	async loadBrowserWasm(path, totalStart) {
+		const manifest = await loadWasmManifest(path);
+		if (!manifest && typeof WebAssembly.instantiateStreaming === "function") {
+			const instStart = performance.now();
+			const result = await WebAssembly.instantiateStreaming(fetch(path), this.getImports());
+			this.compiledModule = result.module;
+			this.lastMetrics = {
+				fileReadMs: 0,
+				compileMs: 0,
+				instantiateMs: performance.now() - instStart,
+				totalMs: performance.now() - totalStart,
+				fromCache: false
+			};
+			return result.instance.exports;
+		}
+		const readStart = performance.now();
+		const buffer = await (await fetch(path)).arrayBuffer();
+		const readEnd = performance.now();
+		await verifyWasmIntegrity(buffer, path, { manifest });
+		const compileStart = performance.now();
+		this.compiledModule = await WebAssembly.compile(buffer);
+		const compileEnd = performance.now();
+		const instStart = performance.now();
+		const instance = await WebAssembly.instantiate(this.compiledModule, this.getImports());
+		const instEnd = performance.now();
+		this.lastMetrics = {
+			fileReadMs: readEnd - readStart,
+			compileMs: compileEnd - compileStart,
+			instantiateMs: instEnd - instStart,
+			totalMs: performance.now() - totalStart,
+			fromCache: false
+		};
+		return instance.exports;
+	}
+	getImports() {
+		return {
+			env: {
+				abort: (msg, file, line, column) => {
+					console.error("WASM abort", {
+						msg,
+						file,
+						line,
+						column
+					});
+					throw new Error("WASM abort");
+				},
+				seed: () => Date.now()
+			},
+			Math,
+			Date
+		};
+	}
+};
+//#endregion
+//#region src/wasm-as-header.ts
+function allocAsHeader(mod, byteLength, typeId) {
+	const bufferPtr = mod.__pin(mod.__new(byteLength, 1)) >>> 0;
+	const headerPtr = mod.__new(12, typeId) >>> 0;
+	mod.__pin(headerPtr);
+	const dv = new DataView(mod.memory.buffer);
+	dv.setUint32(headerPtr + 0, bufferPtr, true);
+	dv.setUint32(headerPtr + 4, bufferPtr, true);
+	dv.setUint32(headerPtr + 8, byteLength, true);
+	return {
+		headerPtr,
+		bufferPtr
+	};
+}
 //#endregion
-export { Unit as CoreUnit, DEFAULT_CONFIG, DimensionError, IndexError, MathjsError, ObjectWrappingMap, PartitionedMap, _switch, acosh, arraySize, asinh, assertDependencies, assign as assignMap, atanh, broadcastArrays, broadcastSizes, broadcastTo, canDefineProperty, cbrt, checkBroadcastingRules, clone, clone$1 as cloneArray, compareText, concat, containsCollections, copysign, cosh, create, createEmptyMap, createIndexError, createMap, createUnitClass, deepExtend, deepFlatten, deepForEach, deepForEach$1 as deepForEachArray, deepMap, deepMap$1 as deepMapArray, deepStrictEqual, defaultWasmLocation, digits, endsWith, escape, expm1, extend, factory, filter, filterRegExp, flatten, forEach, format, format$1 as formatBigNumber, format$2 as formatGeneric, generalize, get, getArrayDataType, get$1 as getArrayElement, hasOwnProperty, identify, initial, isArray, isBigInt, isBigNumber, isBoolean, isCollection, isComplex, isDate, isDenseMatrix, isEmptyIndex, isFactory, isFraction, isFunction, isIndex, isInteger, isLegacyFactory, isMap, isMatrix, isNull, isNumber, isObject, isObjectWrappingMap, isOptionalDependency, isPowZeroAtInfinity, isRange, isRegExp, isSparseMatrix, isString, isUndefined, isUnit, join, last, lazy, loadWasmManifest, log10, log1p, log2, map, mapObject, memoize, nearlyEqual, normalizeFormatOptions, pick, pickShallow, processSizesWildcard, reduce, reshape, resize, resolvePackagedWasm, roundDigits, safeNumberType, scatter, set, sha384OfBuffer, sign, sinh, sortFactories, splitNumber, squeeze, stretch, stringify, stripOptionalNotation, tanh, toEngineering, toEngineering$1 as toEngineeringBigNumber, toExponential, toExponential$1 as toExponentialBigNumber, toFixed, toFixed$1 as toFixedBigNumber, toObject, toPrecision, traverse, typeOf, unitDependencies, unsqueeze, validate, validateIndex, validateIndexSourceSize, verifyWasmIntegrity, warnOnce };
+export { Unit as CoreUnit, DEFAULT_CONFIG, DimensionError, IndexError, MathjsError, ObjectWrappingMap, PartitionedMap, WasmModuleLoader, _switch, acosh, allocAsHeader, arraySize, asinh, assertDependencies, assign as assignMap, atanh, broadcastArrays, broadcastSizes, broadcastTo, canDefineProperty, cbrt, checkBroadcastingRules, clone, clone$1 as cloneArray, compareText, concat, containsCollections, copysign, cosh, create, createEmptyMap, createIndexError, createMap, createUnitClass, deepExtend, deepFlatten, deepForEach, deepForEach$1 as deepForEachArray, deepMap, deepMap$1 as deepMapArray, deepStrictEqual, defaultWasmLocation, digits, endsWith, escape, expm1, extend, factory, filter, filterRegExp, flatten, forEach, format, format$1 as formatBigNumber, format$2 as formatGeneric, generalize, get, getArrayDataType, get$1 as getArrayElement, hasOwnProperty, identify, initial, isArray, isBigInt, isBigNumber, isBoolean, isCollection, isComplex, isDate, isDenseMatrix, isEmptyIndex, isFactory, isFraction, isFunction, isIndex, isInteger, isLegacyFactory, isMap, isMatrix, isNull, isNumber, isObject, isObjectWrappingMap, isOptionalDependency, isPowZeroAtInfinity, isRange, isRegExp, isSparseMatrix, isString, isUndefined, isUnit, join, last, lazy, loadWasmManifest, log10, log1p, log2, map, mapObject, memoize, nearlyEqual, normalizeFormatOptions, pick, pickShallow, processSizesWildcard, reduce, reshape, resize, resolvePackagedWasm, roundDigits, safeNumberType, scatter, set, sha384OfBuffer, sign, sinh, sortFactories, splitNumber, squeeze, stretch, stringify, stripOptionalNotation, tanh, toEngineering, toEngineering$1 as toEngineeringBigNumber, toExponential, toExponential$1 as toExponentialBigNumber, toFixed, toFixed$1 as toFixedBigNumber, toObject, toPrecision, traverse, typeOf, unitDependencies, unsqueeze, validate, validateIndex, validateIndexSourceSize, verifyWasmIntegrity, warnOnce };