@danielsimonjr/mathts-core 0.14.1 → 0.15.0

package/dist/numeric/stable.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Numerically stable reduction primitives.
+ *
+ * Floating-point addition is not associative, so *how* you accumulate decides how much error you
+ * carry. These are the algorithms the established numerical stack uses, and the reason it is
+ * trusted.
+ *
+ * Measured on this repo's own reductions before these existed — 1e6 copies of `0.1`, exact answer
+ * 100000:
+ *
+ * | accumulation                    | relative error |
+ * | ------------------------------- | -------------- |
+ * | naive `s += x`                  | **1.3e-11**    |
+ * | pairwise (this, = NumPy's algo) | **2.9e-16**    |
+ * | Neumaier compensated (`fsum`)   | **0** (exact)  |
+ *
+ * NumPy 2.3.4 reports 2.9e-16 on the same input — we are now at parity. Before this, we were
+ * ~46,000× worse than NumPy on a bog-standard `sum`, and `mean`, `std`, `var` and every statistic
+ * inherit that error.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Sum with **pairwise (cascade) summation** — the algorithm behind `np.sum`.
+ *
+ * Naive accumulation lets the running total grow large while the addends stay small, so each
+ * addition rounds off a little more of the total: error grows as **O(n)·ε**. Pairwise summation
+ * adds numbers of *comparable magnitude* by recursively halving the range, so error grows as
+ * **O(log n)·ε** — for n = 10⁶ that is the difference between ~1e-11 and ~1e-16.
+ *
+ * It costs the same number of additions as the naive loop. There is no speed/accuracy trade here;
+ * the naive version is simply worse.
+ *
+ * Not exact: for that, use {@link neumaierSum}. Pairwise is the right default because it is free.
+ */
+export declare function pairwiseSum(xs: ArrayLike<number>, start?: number, end?: number): number;
+/**
+ * Sum with **Neumaier compensation** — correctly rounded for practical purposes, the equivalent
+ * of Python's `math.fsum`.
+ *
+ * Tracks the low-order bits that each addition throws away and folds them back in at the end. It
+ * recovers information that pairwise summation cannot: `[1e16, 1, -1e16]` sums to **1** here,
+ * while both naive and pairwise (and `np.sum`) give **0**, because the `1` is annihilated the
+ * moment it meets `1e16`.
+ *
+ * ~2-4× slower than {@link pairwiseSum}, so it is opt-in rather than the default. Reach for it
+ * when catastrophic cancellation is possible: near-zero results from large terms, long-running
+ * accumulators, conservation checks.
+ *
+ * (Neumaier's variant, not classic Kahan: Kahan loses the compensation when the *addend* is
+ * larger than the running sum, which is precisely the `1e16` case.)
+ */
+export declare function neumaierSum(xs: ArrayLike<number>): number;
+/**
+ * Euclidean (2-)norm that does **not** overflow or underflow — BLAS's `dnrm2` scaling.
+ *
+ * The obvious `sqrt(Σxᵢ²)` squares before it adds, so it dies well inside the representable
+ * range: `‖[1e200, 1e200, 1e200, 1e200]‖` overflows to `Infinity` (the true answer, 2e200, is
+ * perfectly representable), and `‖[1e-200] × 4‖` **flushes to 0** — a silent wrong answer, which
+ * is worse.
+ *
+ * NumPy has this bug too: `np.linalg.norm([1e200]*4)` returns `inf` with an overflow warning.
+ * LAPACK does not, and neither do we.
+ *
+ * The fix is to carry a running scale: keep the largest magnitude seen out of the sum of squares,
+ * so the accumulator only ever holds ratios in [0, 1].
+ */
+export declare function norm2(xs: ArrayLike<number>): number;
+/**
+ * Dot product `Σ aᵢ·bᵢ` with **pairwise (cascade) summation** of the products — the accuracy of
+ * {@link pairwiseSum} applied to a dot without materialising the product array.
+ *
+ * A naive `s += a[i]*b[i]` loop carries the same **O(n)·ε** error as a naive sum; measured against
+ * an exact reference on an ill-conditioned dot (large mean × small factor, n = 10⁶) it is ~18×
+ * worse than `np.dot`, which sums pairwise. This closes that gap — and, like {@link pairwiseSum},
+ * costs the same number of flops as the naive loop.
+ *
+ * The two ranges are assumed the same length; callers guard that. Reads only `[start, end)`.
+ */
+export declare function pairwiseDot(a: ArrayLike<number>, b: ArrayLike<number>, start?: number, end?: number): number;
+/**
+ * Euclidean distance `‖a − b‖₂` that does **not** overflow or underflow — {@link norm2}'s BLAS
+ * `dnrm2` scaling applied to the elementwise difference.
+ *
+ * `distance` is just a 2-norm, so the obvious `sqrt(Σ(aᵢ−bᵢ)²)` inherits norm's pathology: it
+ * squares before it adds, overflowing to `Infinity` and — the dangerous case — **flushing to a
+ * silent 0** for small differences well inside the representable range. NumPy's `linalg.norm` has
+ * the same bug; scaling on the largest *difference* seen avoids both. The scale tracks the residual
+ * `a − b`, not the inputs, so it stays accurate even when `a` and `b` are individually huge.
+ *
+ * The two ranges are assumed the same length; callers guard that.
+ */
+export declare function scaledDistance(a: ArrayLike<number>, b: ArrayLike<number>): number;
+/**
+ * Sum of squared deviations from the mean, `Σ(xᵢ − x̄)²` — the **corrected two-pass** form, the
+ * numerator of a numerically stable variance.
+ *
+ * Variance is where large means bite: the deviations `xᵢ − x̄` can be O(1) while the values sit on
+ * a huge pedestal, so any error in `x̄` rides straight into every deviation. Two things fix it:
+ *   1. compute the mean with {@link pairwiseSum}, not a naive running total; and
+ *   2. subtract the residual mean-bias term `(Σd)²/n` — `Σd` is zero in exact arithmetic but not in
+ *      floating point, and that leftover is exactly the systematic error a plain `Σd²` carries.
+ *
+ * Measured on 1e9-pedestal data: the plain naive two-pass (what shipped) lands ~1e-7 relative error;
+ * this lands ~1e-16 — better than `np.var`, which uses the uncorrected two-pass (~1e-13).
+ *
+ * The deviation vector is never materialised: both pairwise sums walk `xs` in
+ * registers, so variance/std no longer pay an extra n-long allocation.
+ *
+ * Divide the result by `n` (uncorrected), `n − 1` (unbiased/sample), or `n + 1` (biased) for the
+ * corresponding variance. Returns 0 for fewer than two elements.
+ */
+export declare function sumSquaredDeviations(xs: ArrayLike<number>): number;
+/**
+ * Cumulative sum with **Neumaier compensation** — each prefix total is written to `out[i]` carrying
+ * the low-order bits a naive running sum throws away.
+ *
+ * A cumulative sum is an inherently sequential prefix scan, so pairwise summation does not apply:
+ * you need every intermediate total, not just the final one. `np.cumsum` therefore accumulates
+ * naively and its tail drifts by **O(n)·ε** (relErr ~1.3e-11 over 10⁶ terms). Carrying a running
+ * compensation costs a few extra flops per element, no extra memory, and makes every prefix exact
+ * for practical purposes — a strict improvement over NumPy where accumulated drift matters (e.g.
+ * integrating a signal).
+ *
+ * Writes `out[i]` for `i` in `[0, xs.length)`; `out` may be a `number[]` or a `Float64Array`.
+ */
+export declare function neumaierCumsum(xs: ArrayLike<number>, out: {
+    [index: number]: number;
+}): void;
+//# sourceMappingURL=stable.d.ts.map

package/dist/numeric/stable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stable.d.ts","sourceRoot":"","sources":["../../src/numeric/stable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAWH;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,KAAK,SAAI,EAAE,GAAG,SAAY,GAAG,MAAM,CAuCrF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAazD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAsBnD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CACzB,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,EACpB,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,EACpB,KAAK,SAAI,EACT,GAAG,SAAW,GACb,MAAM,CAoCR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAqBjF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,CAelE;AAiFD;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GAAG,IAAI,CAW5F"}

package/dist/object.d.ts

@@ -0,0 +1,119 @@
+import { hasOwnProperty } from './shared.js';
+/**
+ * Clone an object
+ *
+ *     clone(x)
+ *
+ * Can clone any primitive type, array, and object.
+ * If x has a function clone, this function will be invoked to clone the object.
+ *
+ * @param {*} x
+ * @return {*} clone
+ */
+export declare function clone<T>(x: T): T;
+/**
+ * Apply map to all properties of an object
+ * @param {Object} object
+ * @param {function} callback
+ * @return {Object} Returns a copy of the object with mapped properties
+ */
+export declare function mapObject<T, U>(object: Record<string, T>, callback: (value: T) => U): Record<string, U>;
+/**
+ * Extend object a with the properties of object b
+ * @param {Object} a
+ * @param {Object} b
+ * @return {Object} a
+ */
+export declare function extend<T extends Record<string, unknown>, U extends Record<string, unknown>>(a: T, b: U): T & U;
+/**
+ * Deep extend an object a with the properties of object b
+ * @param {Object} a
+ * @param {Object} b
+ * @returns {Object}
+ */
+export declare function deepExtend<T>(a: T, b: unknown): T;
+/**
+ * Deep test equality of all fields in two pairs of arrays or objects.
+ * Compares values and functions strictly (ie. 2 is not the same as '2').
+ * @param {Array | Object} a
+ * @param {Array | Object} b
+ * @returns {boolean}
+ */
+export declare function deepStrictEqual(a: unknown, b: unknown): boolean;
+/**
+ * Recursively flatten a nested object.
+ * @param {Object} nestedObject
+ * @return {Object} Returns the flattened object
+ */
+export declare function deepFlatten(nestedObject: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Test whether the current JavaScript engine supports Object.defineProperty
+ * @returns {boolean} returns true if supported
+ */
+export declare function canDefineProperty(): boolean;
+/**
+ * Attach a lazy loading property to a constant.
+ * The given function `fn` is called once when the property is first requested.
+ *
+ * @param {Object} object         Object where to add the property
+ * @param {string} prop           Property name
+ * @param {Function} valueResolver Function returning the property value. Called
+ *                                without arguments.
+ */
+export declare function lazy<T>(object: Record<string, unknown>, prop: string, valueResolver: () => T): void;
+/**
+ * Traverse a path into an object.
+ * When a namespace is missing, it will be created
+ * @param {Object} object
+ * @param {string | string[]} path   A dot separated string like 'name.space'
+ * @return {Object} Returns the object at the end of the path
+ */
+export declare function traverse(object: Record<string, unknown>, path: string | string[]): Record<string, unknown>;
+export { hasOwnProperty };
+/**
+ * Test whether an object is a factory. a factory has fields:
+ *
+ * - factory: function (type: Object, config: Object, load: function, typed: function [, math: Object])   (required)
+ * - name: string (optional)
+ * - path: string    A dot separated path (optional)
+ * - math: boolean   If true (false by default), the math namespace is passed
+ *                   as fifth argument of the factory function
+ *
+ * @param {*} object
+ * @returns {boolean}
+ */
+export declare function isLegacyFactory(object: unknown): boolean;
+/**
+ * Get a nested property from an object
+ * @param {Object} object
+ * @param {string | string[]} path
+ * @returns {Object}
+ */
+export declare function get(object: Record<string, unknown>, path: string | string[]): unknown;
+/**
+ * Set a nested property in an object
+ * Mutates the object itself
+ * If the path doesn't exist, it will be created
+ * @param {Object} object
+ * @param {string | string[]} path
+ * @param {*} value
+ * @returns {Object}
+ */
+export declare function set<T extends Record<string, unknown>>(object: T, path: string | string[], value: unknown): T;
+/**
+ * Create an object composed of the picked object properties
+ * @param {Object} object
+ * @param {string[]} properties
+ * @param {function} [transform] Optional value to transform a value when picking it
+ * @return {Object}
+ */
+export declare function pick(object: Record<string, unknown>, properties: string[], transform?: (value: unknown, key: string) => unknown): Record<string, unknown>;
+/**
+ * Shallow version of pick, creating an object composed of the picked object properties
+ * but not for nested properties
+ * @param {Object} object
+ * @param {string[]} properties
+ * @return {Object}
+ */
+export declare function pickShallow(object: Record<string, unknown>, properties: string[]): Record<string, unknown>;
+//# sourceMappingURL=object.d.ts.map

package/dist/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../src/object.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAwChC;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EACzB,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GACxB,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAUnB;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACzF,CAAC,EAAE,CAAC,EACJ,CAAC,EAAE,CAAC,GACH,CAAC,GAAG,CAAC,CAQP;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,GAAG,CAAC,CA8DjD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CA6C/D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAM1F;AAmBD;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAgB3C;AAED;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,CAAC,GACrB,IAAI,CAqBN;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GACtB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAkBzB;AAGD,OAAO,EAAE,cAAc,EAAE,CAAC;AAE1B;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAiBrF;AAED;;;;;;;;GAQG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnD,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EACvB,KAAK,EAAE,OAAO,GACb,CAAC,CAyBH;AAED;;;;;;GAMG;AACH,wBAAgB,IAAI,CAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,UAAU,EAAE,MAAM,EAAE,EACpB,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,GACnD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAYzB;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,UAAU,EAAE,MAAM,EAAE,GACnB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAYzB"}

package/dist/shared.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Shared utility functions used across core utility modules.
+ * This file must have ZERO imports from other core utility files
+ * to serve as the base of the dependency graph and break circular imports.
+ */
+/**
+ * A safe hasOwnProperty
+ * @param {Object} object
+ * @param {string} property
+ */
+export declare function hasOwnProperty(object: unknown, property: string): boolean;
+/**
+ * True when `text` ends with `search`. (Equivalent to `String.prototype.endsWith`;
+ * kept as a named helper so relocated modules read the same as their mathjs origin.)
+ */
+export declare function endsWith(text: string, search: string): boolean;
+/**
+ * Warn to the console at most once per distinct message, deduped for the process
+ * lifetime. Used for deprecation notices (e.g. `Unit.toNumber`).
+ */
+export declare const warnOnce: (...args: unknown[]) => void;
+/** A function whose results are cached; clear the cache with `delete fn.cache`. */
+export interface MemoizedFunction {
+    (...args: unknown[]): unknown;
+    cache?: Map<string, unknown>;
+}
+/**
+ * Memoize a pure function, caching results in a `Map` keyed by a string hash of the
+ * arguments (default `JSON.stringify`; override via `hasher`). Pass `limit` to bound
+ * the cache to N most-recently-used entries (LRU eviction via `Map` insertion order —
+ * on a hit the key is moved to the most-recent end; on overflow the oldest key is
+ * dropped); omit for an unbounded cache. The cache is exposed as `fn.cache` and can be
+ * reset with `delete fn.cache` — the next call lazily recreates it. (The relocated
+ * `Unit` relies on that reset when `createUnit`/`deleteUnit` invalidate the unit-name
+ * lookup cache, and passes `limit: 100` to bound the parse cache.)
+ */
+export declare function memoize(fn: (...args: unknown[]) => unknown, { hasher, limit }?: {
+    hasher?: (args: unknown[]) => string;
+    limit?: number;
+}): MemoizedFunction;
+//# sourceMappingURL=shared.d.ts.map

package/dist/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../src/shared.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEzE;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAG9D;AAED;;;GAGG;AACH,eAAO,MAAM,QAAQ,YAGe,OAAO,EAAE,KAAG,IAO5C,CAAC;AAEL,mFAAmF;AACnF,MAAM,WAAW,gBAAgB;IAC/B,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;IAC9B,KAAK,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC9B;AAED;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CACrB,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,EACnC,EAAE,MAAM,EAAE,KAAK,EAAE,GAAE;IAAE,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/E,gBAAgB,CA2BlB"}

package/dist/string.d.ts

@@ -0,0 +1,70 @@
+import { type FormatOptions } from './number.js';
+/**
+ * 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.
+ */
+export 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
+ */
+export declare function format(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}
+ */
+export declare function stringify(value: unknown): string;
+/**
+ * Escape special HTML characters
+ * @param {*} value
+ * @return {string}
+ */
+export declare function escape(value: unknown): string;
+/**
+ * Compare two strings
+ * @param {string} x
+ * @param {string} y
+ * @returns {number}
+ */
+export declare function compareText(x: unknown, y: unknown): number;
+//# sourceMappingURL=string.d.ts.map

package/dist/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../src/string.ts"],"names":[],"mappings":"AAoBA,OAAO,EAA0B,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAGzE;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAC5B,MAAM,GACN,CAAC,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC,GAC5B,CAAC,aAAa,GAAG;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,CAAC,CAAC;AASP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,CAShE;AA2DD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAWhD;AAYD;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAU7C;AA8CD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAoB1D"}

package/dist/switch.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Transpose a 2D array. Private helper used only by `core/src/collection.ts`'s
+ * `_reduce` (Bucket B slice 2 canonical) — mirrors `expression/src/utils/switch.ts`
+ * / `functions/src/utils/switch.ts`, which remain in place unchanged for now
+ * (not part of this slice's named scope). Not exported from `internal.ts`.
+ * @private
+ */
+export declare function _switch<T>(mat: T[][]): T[][];
+//# sourceMappingURL=switch.d.ts.map

package/dist/switch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"switch.d.ts","sourceRoot":"","sources":["../src/switch.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,CAa5C"}

package/dist/typed/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * typed-function integration exports
+ */
+export { mathTyped, createMathTSTyped, typed, create, createTypedFunction, TypeRegistry, MATHTS_TYPES, MATHTS_CONVERSIONS, isNumber, isBoolean, isString, isBigInt, isArray, isFunction, isObject, isNull, isUndefined, isComplex, isFraction, isBigNumber, isFloat64Array, isFloat32Array, isInt32Array, isUint32Array, isUint8Array, isMatrix, isDenseMatrix, isSparseMatrix, isUnit, initTypedWasm, isTypedWasmAvailable, } from './mathts-typed.js';
+export type { TypedFunction, TypedInstance, TypeDef, ConversionDef, SignatureFunction, ReferTo, ReferToSelf, } from './mathts-typed.js';
+export { registerNativeTypes } from './type-bridge.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/typed/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/typed/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,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,SAAS,EACT,UAAU,EACV,WAAW,EAGX,cAAc,EACd,cAAc,EACd,YAAY,EACZ,aAAa,EACb,YAAY,EAGZ,QAAQ,EACR,aAAa,EACb,cAAc,EAGd,MAAM,EAGN,aAAa,EACb,oBAAoB,GACrB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACV,aAAa,EACb,aAAa,EACb,OAAO,EACP,aAAa,EACb,iBAAiB,EACjB,OAAO,EACP,WAAW,GACZ,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/typed/mathts-typed.d.ts

@@ -0,0 +1,246 @@
+/**
+ * MathTS typed-function Integration
+ *
+ * Creates a configured typed-function instance with MathTS types
+ * for runtime type dispatch across numeric types, matrices, and more.
+ *
+ * This module directly uses the typed-function library API without
+ * any intermediate abstraction layers.
+ *
+ * Supports WASM-accelerated dispatch when available.
+ *
+ * @packageDocumentation
+ */
+import typed, { create } from 'typed-function';
+import type { TypedFunction, TypedInstance, SignatureFunction, ReferTo, ReferToSelf } from 'typed-function';
+/**
+ * Initialize WASM dispatch for typed-function (optional, improves performance)
+ *
+ * Uses the unified typed.init() API to enable WASM-accelerated dispatch
+ * with automatic fallback to pure JS when WASM is unavailable.
+ *
+ * @param options - Initialization options
+ * @returns Promise resolving to true if WASM was initialized successfully
+ */
+export declare function initTypedWasm(options?: {
+    preferWasm?: boolean;
+}): Promise<boolean>;
+/**
+ * Check if WASM dispatch is available
+ */
+export declare function isTypedWasmAvailable(): boolean;
+import { Complex } from '../types/complex.js';
+import { Fraction } from '../types/fraction.js';
+import { BigNumber } from '../types/bignumber.js';
+export type { TypedFunction, TypedInstance, SignatureFunction, ReferTo, ReferToSelf };
+/**
+ * Any concrete implementation accepted when *declaring* a typed signature.
+ *
+ * typed-function's published `SignatureFunction` is `(...args: unknown[]) =>
+ * unknown`, which is correct for *internal/output* positions (where the stored
+ * impl is later CALLED with validated args) but wrong as an *input* type:
+ * under `strictFunctionTypes`, function parameters are contravariant, so a
+ * concrete impl such as `(a: number, b: number) => number` is NOT assignable
+ * to an `unknown[]` parameter list (`unknown` is not assignable to `number`).
+ * The correct top-type for "any function" in an input position uses `never`
+ * parameters — every function is assignable to it because `never` is
+ * assignable to every parameter type. This is exactly the set of values
+ * typed-function genuinely accepts when declaring signatures.
+ */
+export type SignatureImpl = (...args: never[]) => unknown;
+/** Signature record accepted by the MathTS typed factory (see {@link SignatureImpl}). */
+export type SignatureRecord = Record<string, SignatureImpl | ReferTo | ReferToSelf>;
+/**
+ * The MathTS typed-function factory type.
+ *
+ * Structurally identical to typed-function's {@link TypedInstance} except its
+ * call signatures accept implementations declared with concrete parameter
+ * types (see {@link SignatureImpl}). All instance methods are inherited
+ * unchanged via `Omit<TypedInstance, never>` (a mapped type, which drops the
+ * overly-strict published call signatures while preserving every method).
+ */
+export interface MathTSTyped extends Omit<TypedInstance, never> {
+    (name: string, signatures: SignatureRecord): TypedFunction;
+    (signatures: SignatureRecord): TypedFunction;
+    (...args: Array<string | SignatureRecord | TypedFunction | (SignatureImpl & {
+        signature: string;
+    })>): TypedFunction;
+    referToSelf: (callback: (self: TypedFunction) => SignatureImpl) => ReferToSelf;
+    referTo: (...args: [...string[], (...fns: SignatureFunction[]) => SignatureImpl]) => ReferTo;
+}
+/**
+ * Type definition for typed-function
+ */
+export interface TypeDef {
+    name: string;
+    test: (x: unknown) => boolean;
+}
+/**
+ * Conversion definition for typed-function
+ */
+export interface ConversionDef {
+    from: string;
+    to: string;
+    convert: (value: unknown) => unknown;
+}
+export declare const isNumber: (x: unknown) => x is number;
+export declare const isBoolean: (x: unknown) => x is boolean;
+export declare const isString: (x: unknown) => x is string;
+export declare const isBigInt: (x: unknown) => x is bigint;
+export declare const isArray: (x: unknown) => x is unknown[];
+export declare const isFunction: (x: unknown) => x is (...args: unknown[]) => unknown;
+export declare const isObject: (x: unknown) => x is object;
+export declare const isNull: (x: unknown) => x is null;
+export declare const isUndefined: (x: unknown) => x is undefined;
+export declare const isFloat64Array: (x: unknown) => x is Float64Array;
+export declare const isFloat32Array: (x: unknown) => x is Float32Array;
+export declare const isInt32Array: (x: unknown) => x is Int32Array;
+export declare const isUint32Array: (x: unknown) => x is Uint32Array;
+export declare const isUint8Array: (x: unknown) => x is Uint8Array;
+/**
+ * Check if value is a Complex number
+ */
+export declare const isComplex: (x: unknown) => x is Complex;
+/**
+ * Check if value is a Fraction
+ */
+export declare const isFraction: (x: unknown) => x is Fraction;
+/**
+ * Check if value is a BigNumber
+ */
+export declare const isBigNumber: (x: unknown) => x is BigNumber;
+/**
+ * Check if value is a Matrix (duck typing until Matrix class is implemented)
+ */
+export declare const isMatrix: (x: unknown) => boolean;
+/**
+ * Check if value is a DenseMatrix
+ */
+export declare const isDenseMatrix: (x: unknown) => boolean;
+/**
+ * Check if value is a SparseMatrix
+ */
+export declare const isSparseMatrix: (x: unknown) => boolean;
+/**
+ * Check if value is a Unit
+ *
+ * Recognises both the native {@link Unit} class (which exposes `value`,
+ * `dimensions`, and `notation`) and the legacy duck-typed shape used by
+ * mathjs-compatibility shims (`{ value, unit, type }`).
+ */
+export declare const isUnit: (x: unknown) => boolean;
+/**
+ * Extended type definition with optional WASM mask support
+ */
+export interface MathTSTypeDef extends TypeDef {
+    /** Optional WASM type mask for accelerated dispatch (auto-registered when WASM available) */
+    wasmMask?: number;
+}
+/**
+ * MathTS-specific types to add to typed-function.
+ * Note: Most primitive types (number, boolean, string, etc.) are already built into typed-function
+ *
+ * When WASM is available, custom type masks are automatically registered for efficient dispatch.
+ */
+export declare const MATHTS_TYPES: MathTSTypeDef[];
+export declare const MATHTS_CONVERSIONS: ConversionDef[];
+/**
+ * Create a new MathTS typed instance
+ *
+ * This creates an isolated typed universe with MathTS types and conversions.
+ * Uses typed-function's addType() API which automatically registers WASM
+ * type masks when available.
+ *
+ * @returns A new typed-function instance configured for MathTS
+ *
+ * @example
+ * ```typescript
+ * const myTyped = createMathTSTyped();
+ *
+ * const add = myTyped('add', {
+ *   'number, number': (a, b) => a + b,
+ *   'Complex, Complex': (a, b) => a.add(b),
+ *   'Fraction, Fraction': (a, b) => a.add(b),
+ *   'BigNumber, BigNumber': (a, b) => a.add(b),
+ * });
+ * ```
+ */
+export declare function createMathTSTyped(): TypedInstance;
+/**
+ * Default MathTS typed instance
+ *
+ * This is the primary typed-function instance used throughout MathTS.
+ * It comes pre-configured with all MathTS types and conversions.
+ *
+ * @example
+ * ```typescript
+ * import { mathTyped, Complex, Fraction, BigNumber } from '@danielsimonjr/mathts-core';
+ *
+ * // Create a polymorphic add function
+ * const add = mathTyped('add', {
+ *   'number, number': (a, b) => a + b,
+ *   'Complex, Complex': (a, b) => a.add(b),
+ *   'Fraction, Fraction': (a, b) => a.add(b),
+ *   'BigNumber, BigNumber': (a, b) => a.add(b),
+ * });
+ *
+ * // Works with automatic type coercion
+ * add(1, 2);                              // 3
+ * add(new Complex(1, 2), new Complex(3, 4)); // Complex(4, 6)
+ * add(new Fraction(1, 2), new Fraction(1, 3)); // Fraction(5, 6)
+ * add(1, new Complex(2, 3));              // Complex(3, 3) - auto-converts
+ * ```
+ */
+export declare const mathTyped: MathTSTyped;
+/**
+ * The default typed-function export (for creating functions without MathTS types)
+ */
+export { typed };
+/**
+ * Create a new typed-function instance (typed-function's create)
+ */
+export { create };
+/**
+ * TypeRegistry class for managing custom type registrations
+ * This is a MathTS utility, not from typed-function
+ */
+export declare class TypeRegistry {
+    private types;
+    private conversions;
+    private instance;
+    /**
+     * Register a new type
+     */
+    registerType<T>(name: string, test: (x: unknown) => x is T): this;
+    /**
+     * Register a type conversion
+     */
+    registerConversion<From, To>(from: string, to: string, convert: (value: From) => To): this;
+    /**
+     * Check if a type is registered
+     */
+    hasType(name: string): boolean;
+    /**
+     * Check if a conversion is registered
+     */
+    hasConversion(from: string, to: string): boolean;
+    /**
+     * Get all registered type names
+     */
+    getTypeNames(): string[];
+    /**
+     * Build a typed-function instance from the registry
+     */
+    build(): TypedInstance;
+    /**
+     * Clear all registered types and conversions
+     */
+    clear(): void;
+}
+/**
+ * Helper to create a typed function with the MathTS typed instance
+ */
+export declare function createTypedFunction<T>(name: string, signatures: {
+    [signature: string]: (...args: unknown[]) => T;
+}, typedInstance?: TypedInstance): (...args: unknown[]) => T;
+//# sourceMappingURL=mathts-typed.d.ts.map

package/dist/typed/mathts-typed.d.ts.map

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

package/dist/typed/type-bridge.d.ts

@@ -0,0 +1,2 @@
+export declare function registerNativeTypes(): void;
+//# sourceMappingURL=type-bridge.d.ts.map