@danielsimonjr/mathts-core 0.14.1 → 0.15.0

package/dist/{chunk-VPK5YTKG.js → chunk-L5MWGOLB.js}

@@ -2,6 +2,16 @@
 function isComplex(value) {
   return value instanceof Complex;
 }
+function hypotFast(re, im) {
+  if (im === 0) return Math.abs(re);
+  if (re === 0) return Math.abs(im);
+  const a = re < 0 ? -re : re;
+  const b = im < 0 ? -im : im;
+  if (a < 1e150 && b < 1e150 && (a > 1e-150 || b > 1e-150)) {
+    return Math.sqrt(re * re + im * im);
+  }
+  return Math.hypot(re, im);
+}
 var Complex = class _Complex {
   type = "Complex";
   re;
@@ -150,7 +160,7 @@ var Complex = class _Complex {
    * Magnitude (absolute value) |z| = √(re² + im²)
    */
   abs() {
-    return Math.hypot(this.re, this.im);
+    return hypotFast(this.re, this.im);
   }
   /**
    * Phase angle (argument) in radians, range (-π, π]
@@ -266,13 +276,28 @@ var Complex = class _Complex {
   // Transcendental Functions
   // ============================================================
   /**
-   * Square root using principal branch
-   * √z = √r · e^(iθ/2) where r = |z|, θ = arg(z)
+   * Square root using the principal branch (Re ≥ 0; Im has the sign of `this.im`).
+   *
+   * Algebraic form, not polar: one hypot + one sqrt instead of hypot + atan2 +
+   * cos + sin. Same branch cut as C99 / the previous polar implementation,
+   * including `sqrt(-x - 0i) = −√x · i`.
    */
   sqrt() {
-    const r = this.abs();
-    const theta = this.arg();
-    return _Complex.fromPolar(Math.sqrt(r), theta / 2);
+    const x = this.re;
+    const y = this.im;
+    if (y === 0) {
+      if (x >= 0) return new _Complex(Math.sqrt(x), y);
+      const im2 = Math.sqrt(-x);
+      return new _Complex(0, Object.is(y, -0) ? -im2 : im2);
+    }
+    const r = hypotFast(x, y);
+    if (x >= 0) {
+      const t2 = Math.sqrt(0.5 * (r + x));
+      return new _Complex(t2, y / (2 * t2));
+    }
+    const t = Math.sqrt(0.5 * (r - x));
+    const im = y < 0 ? -t : t;
+    return new _Complex(y / (2 * im), im);
   }
   /**
    * n-th root (returns principal root)
@@ -312,13 +337,15 @@ var Complex = class _Complex {
    * Logarithm base 10
    */
   log10() {
-    return this.log().divide(new _Complex(Math.LN10, 0));
+    const ln10 = Math.LN10;
+    return new _Complex(Math.log(hypotFast(this.re, this.im)) / ln10, this.arg() / ln10);
   }
   /**
    * Logarithm base 2
    */
   log2() {
-    return this.log().divide(new _Complex(Math.LN2, 0));
+    const ln2 = Math.LN2;
+    return new _Complex(Math.log(hypotFast(this.re, this.im)) / ln2, this.arg() / ln2);
   }
   /**
    * Power: z^w = e^(w·ln(z))
@@ -359,16 +386,24 @@ var Complex = class _Complex {
     );
   }
   /**
-   * Tangent: tan(z) = sin(z) / cos(z)
+   * Tangent: tan(x+iy) = (sin 2x + i sinh 2y) / (cos 2x + cosh 2y)
+   *
+   * Closed form — no intermediate `sin`/`cos` Complex allocations.
    */
   tan() {
-    return this.sin().divide(this.cos());
+    const x2 = this.re * 2;
+    const y2 = this.im * 2;
+    const d = Math.cos(x2) + Math.cosh(y2);
+    return new _Complex(Math.sin(x2) / d, Math.sinh(y2) / d);
   }
   /**
-   * Cotangent: cot(z) = cos(z) / sin(z)
+   * Cotangent: cot(x+iy) = (sin 2x − i sinh 2y) / (cosh 2y − cos 2x)
    */
   cot() {
-    return this.cos().divide(this.sin());
+    const x2 = this.re * 2;
+    const y2 = this.im * 2;
+    const d = Math.cosh(y2) - Math.cos(x2);
+    return new _Complex(Math.sin(x2) / d, -Math.sinh(y2) / d);
   }
   /**
    * Secant: sec(z) = 1 / cos(z)
@@ -404,16 +439,22 @@ var Complex = class _Complex {
     );
   }
   /**
-   * Hyperbolic tangent: tanh(z) = sinh(z) / cosh(z)
+   * Hyperbolic tangent: tanh(x+iy) = (sinh 2x + i sin 2y) / (cosh 2x + cos 2y)
    */
   tanh() {
-    return this.sinh().divide(this.cosh());
+    const x2 = this.re * 2;
+    const y2 = this.im * 2;
+    const d = Math.cosh(x2) + Math.cos(y2);
+    return new _Complex(Math.sinh(x2) / d, Math.sin(y2) / d);
   }
   /**
-   * Hyperbolic cotangent: coth(z) = cosh(z) / sinh(z)
+   * Hyperbolic cotangent: coth(x+iy) = (sinh 2x − i sin 2y) / (cosh 2x − cos 2y)
    */
   coth() {
-    return this.cosh().divide(this.sinh());
+    const x2 = this.re * 2;
+    const y2 = this.im * 2;
+    const d = Math.cosh(x2) - Math.cos(y2);
+    return new _Complex(Math.sinh(x2) / d, -Math.sin(y2) / d);
   }
   /**
    * Hyperbolic secant: sech(z) = 1 / cosh(z)
@@ -1491,11 +1532,49 @@ function gcd(a, b) {
   }
   return a;
 }
+function reducePair(num, den) {
+  if (den === 0n) {
+    throw new Error("Fraction denominator cannot be zero");
+  }
+  if (den < 0n) {
+    num = -num;
+    den = -den;
+  }
+  if (num === 0n) return [0n, 1n];
+  const g = gcd(num, den);
+  return [num / g, den / g];
+}
 var Fraction = class _Fraction {
   type = "Fraction";
   numerator;
   denominator;
   constructor(numerator, denominator = 1n) {
+    if (typeof numerator === "bigint" && typeof denominator === "bigint") {
+      const [num2, den2] = reducePair(numerator, denominator);
+      this.numerator = num2;
+      this.denominator = den2;
+      return;
+    }
+    if (typeof numerator === "number" && Number.isInteger(numerator)) {
+      if (typeof denominator === "bigint") {
+        const [num2, den2] = reducePair(BigInt(numerator), denominator);
+        this.numerator = num2;
+        this.denominator = den2;
+        return;
+      }
+      if (typeof denominator === "number" && Number.isInteger(denominator)) {
+        const [num2, den2] = reducePair(BigInt(numerator), BigInt(denominator));
+        this.numerator = num2;
+        this.denominator = den2;
+        return;
+      }
+    }
+    if (typeof numerator === "bigint" && typeof denominator === "number" && Number.isInteger(denominator)) {
+      const [num2, den2] = reducePair(numerator, BigInt(denominator));
+      this.numerator = num2;
+      this.denominator = den2;
+      return;
+    }
     const toRatio = (x) => {
       if (isFraction2(x)) {
         return [x.numerator, x.denominator];
@@ -1692,6 +1771,9 @@ var Fraction = class _Fraction {
    */
   add(other) {
     if (other instanceof _Fraction) {
+      if (this.denominator === other.denominator) {
+        return new _Fraction(this.numerator + other.numerator, this.denominator);
+      }
       const num = this.numerator * other.denominator + other.numerator * this.denominator;
       const den = this.denominator * other.denominator;
       return new _Fraction(num, den);
@@ -1703,6 +1785,9 @@ var Fraction = class _Fraction {
    */
   subtract(other) {
     if (other instanceof _Fraction) {
+      if (this.denominator === other.denominator) {
+        return new _Fraction(this.numerator - other.numerator, this.denominator);
+      }
       const num = this.numerator * other.denominator - other.numerator * this.denominator;
       const den = this.denominator * other.denominator;
       return new _Fraction(num, den);
@@ -2041,6 +2126,9 @@ var BigNumber = class _BigNumber {
     if (n === 0) {
       return new _BigNumber(0, 0n, 0);
     }
+    if (Number.isSafeInteger(n)) {
+      return _BigNumber.fromBigInt(BigInt(n));
+    }
     return _BigNumber.parse(n.toString());
   }
   /**
@@ -2105,19 +2193,13 @@ var BigNumber = class _BigNumber {
       return new _BigNumber(0, 0n, 0);
     }
     const sign2 = n < 0n ? -1 : 1;
-    let str = (n < 0n ? -n : n).toString();
-    let trailingZeros = 0;
-    for (let i = str.length - 1; i >= 0; i--) {
-      if (str[i] === "0") {
-        trailingZeros++;
-      } else {
-        break;
-      }
-    }
-    if (trailingZeros > 0) {
-      str = str.slice(0, -trailingZeros);
+    let coef = n < 0n ? -n : n;
+    let exp = 0;
+    while (coef % 10n === 0n) {
+      coef /= 10n;
+      exp++;
     }
-    return new _BigNumber(sign2, BigInt(str), trailingZeros);
+    return new _BigNumber(sign2, coef, exp);
   }
   /**
    * Create a BigNumber from a JSON object
@@ -6199,7 +6281,7 @@ var createUnitClass = /* @__PURE__ */ factory(
       } else {
         prefixes = PREFIXES.NONE;
       }
-      let newUnit = {};
+      let newUnit;
       if (!defUnit) {
         baseName = baseName || name2 + "_STUFF";
         if (BASE_DIMENSIONS.indexOf(baseName) >= 0) {

package/dist/collection.d.ts

@@ -0,0 +1,67 @@
+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.
+ */
+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
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export 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;
+export {};
+//# sourceMappingURL=collection.d.ts.map

package/dist/collection.d.ts.map

@@ -0,0 +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"}

package/dist/config.d.ts

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

package/dist/config.d.ts.map

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

package/dist/constants.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Named mathematical constants (plain `number`).
+ *
+ * These mirror the constants documented in `docs/reference/constants.md` and the
+ * familiar `Math.*` values, exported as first-class named bindings so callers can
+ * `import { PI, E, TAU } from '@danielsimonjr/mathts-core'`. The imaginary unit
+ * `I` and the type-specific constants (`COMPLEX_*`, `BIGNUMBER_*`, `FRACTION_*`)
+ * live with their respective types.
+ */
+/** Ratio of a circle's circumference to its diameter. */
+export declare const PI: number;
+/** Euler's number, the base of the natural logarithm. */
+export declare const E: number;
+/** Full-circle constant, `2·PI`. */
+export declare const TAU: number;
+/** Golden ratio, `(1 + √5) / 2`. */
+export declare const PHI: number;
+/** Square root of 2. */
+export declare const SQRT2: number;
+/** Square root of one-half. */
+export declare const SQRT1_2: number;
+/** Natural logarithm of 2. */
+export declare const LN2: number;
+/** Natural logarithm of 10. */
+export declare const LN10: number;
+/** Base-2 logarithm of E. */
+export declare const LOG2E: number;
+/** Base-10 logarithm of E. */
+export declare const LOG10E: number;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,yDAAyD;AACzD,eAAO,MAAM,EAAE,QAAU,CAAC;AAC1B,yDAAyD;AACzD,eAAO,MAAM,CAAC,QAAS,CAAC;AACxB,oCAAoC;AACpC,eAAO,MAAM,GAAG,QAAc,CAAC;AAC/B,oCAAoC;AACpC,eAAO,MAAM,GAAG,QAAyB,CAAC;AAC1C,wBAAwB;AACxB,eAAO,MAAM,KAAK,QAAa,CAAC;AAChC,+BAA+B;AAC/B,eAAO,MAAM,OAAO,QAAe,CAAC;AACpC,8BAA8B;AAC9B,eAAO,MAAM,GAAG,QAAW,CAAC;AAC5B,+BAA+B;AAC/B,eAAO,MAAM,IAAI,QAAY,CAAC;AAC9B,6BAA6B;AAC7B,eAAO,MAAM,KAAK,QAAa,CAAC;AAChC,8BAA8B;AAC9B,eAAO,MAAM,MAAM,QAAc,CAAC"}

package/dist/customs.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Get a property of a plain object
+ * Throws an error in case the object is not a plain object or the
+ * property is not defined on the object itself
+ * @param {Object} object
+ * @param {string} prop
+ * @return {*} Returns the property value when safe
+ */
+export declare function getSafeProperty(object: unknown, prop: string): unknown;
+/**
+ * Set a property on a plain object.
+ * Throws an error in case the object is not a plain object or the
+ * property would override an inherited property like .constructor or .toString
+ * @param {Object} object
+ * @param {string} prop
+ * @param {*} value
+ * @return {*} Returns the value
+ */
+export declare function setSafeProperty(object: unknown, prop: string, value: unknown): unknown;
+/**
+ * Test whether a property is safe to use on an object or Array.
+ * For example .toString and .constructor are not safe
+ * @param {Object | Array} object
+ * @param {string} prop
+ * @return {boolean} Returns true when safe
+ */
+export declare function isSafeProperty(object: unknown, prop: string): boolean;
+/**
+ * Validate whether a method is safe.
+ * Throws an error when that's not the case.
+ * @param {Object} object
+ * @param {string} method
+ * @return {function} Returns the method when valid
+ */
+export declare function getSafeMethod(object: unknown, method: string): unknown;
+/**
+ * Check whether a method is safe.
+ * Throws an error when that's not the case (for example for `constructor`).
+ * @param {Object} object
+ * @param {string} method
+ * @return {boolean} Returns true when safe, false otherwise
+ */
+export declare function isSafeMethod(object: unknown, method: string): boolean;
+//# sourceMappingURL=customs.d.ts.map

package/dist/customs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customs.d.ts","sourceRoot":"","sources":["../src/customs.ts"],"names":[],"mappings":"AAcA;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAYtE;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAQtF;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CA0BrE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAMtE;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAwCrE"}

package/dist/error/DimensionError.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ */
+export declare class DimensionError extends RangeError {
+    actual?: number | number[];
+    expected?: number | number[];
+    relation?: string;
+    isDimensionError: true;
+    /**
+     * @param actual - The actual size or custom error message
+     * @param expected - The expected size (optional if actual is a custom message)
+     * @param relation - Optional relation between actual and expected size: '!=', '<', etc.
+     */
+    constructor(actual: number | number[] | string, expected?: number | number[], relation?: string);
+}
+//# sourceMappingURL=DimensionError.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DimensionError.d.ts","sourceRoot":"","sources":["../../src/error/DimensionError.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,qBAAa,cAAe,SAAQ,UAAU;IAC5C,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,OAAiB;IAEjC;;;;OAIG;IACH,YAAY,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,QAAQ,CAAC,EAAE,MAAM,EAwC9F;CACF"}

package/dist/error/IndexError.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 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
+ */
+export 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);
+}
+export declare function createIndexError(index: number, min?: number, max?: number): IndexError;
+//# sourceMappingURL=IndexError.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IndexError.d.ts","sourceRoot":"","sources":["../../src/error/IndexError.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,qBAAa,UAAW,SAAQ,UAAU;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC;IACxB,YAAY,OAAiB;IAE7B;;;;;;;;;;OAUG;IACH,YAAY,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAqCpD;CACF;AAID,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,UAAU,CAEtF"}

package/dist/error/MathjsError.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Custom error type for Mathjs errors
+ * @extends Error
+ */
+export declare class MathjsError extends Error {
+    isMathjsError: true;
+    /**
+     * Create a MathjsError
+     * @param message  Error message
+     */
+    constructor(message: string);
+}
+//# sourceMappingURL=MathjsError.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MathjsError.d.ts","sourceRoot":"","sources":["../../src/error/MathjsError.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,WAAY,SAAQ,KAAK;IACpC,aAAa,OAAiB;IAE9B;;;OAGG;IACH,YAAY,OAAO,EAAE,MAAM,EAgB1B;CACF"}

package/dist/factory/factory.d.ts

@@ -0,0 +1,154 @@
+/**
+ * MathTS Function Factory
+ *
+ * Provides a factory pattern for creating MathTS functions with:
+ * - Typed function dispatch via typed-function
+ * - Dependency injection for inter-function references
+ * - Backend selection integration
+ * - Lazy loading support
+ *
+ * @packageDocumentation
+ */
+import type { TypedFunction, TypedInstance, SignatureFunction, ReferTo, ReferToSelf } from '../typed/mathts-typed.js';
+/**
+ * Configuration for MathTS instance
+ */
+export interface MathTSConfig {
+    /** Numeric precision (for BigNumber) */
+    precision: number;
+    /** Default matrix type */
+    matrix: 'Matrix' | 'Array';
+    /** Number type for parsing */
+    number: 'number' | 'BigNumber' | 'Fraction';
+    /** Enable predictable randomness */
+    randomSeed: string | null;
+    /** Epsilon for floating point comparison */
+    epsilon: number;
+    /** Preferred backend for matrix operations */
+    preferredBackend: 'auto' | 'js' | 'wasm' | 'gpu';
+    /** Minimum elements to use WASM backend */
+    wasmThreshold: number;
+    /** Minimum elements to use GPU backend */
+    gpuThreshold: number;
+    /** Enable parallel processing */
+    parallelEnabled: boolean;
+    /** Minimum elements to parallelize */
+    parallelThreshold: number;
+}
+/**
+ * Default MathTS configuration
+ */
+export declare const DEFAULT_CONFIG: MathTSConfig;
+/**
+ * Factory function definition
+ */
+export interface FactoryFunction<T = TypedFunction> {
+    /** Name of the function */
+    name: string;
+    /** Dependencies required by this function */
+    dependencies: string[];
+    /** Factory that creates the function given dependencies */
+    factory: (deps: FactoryDependencies) => T;
+}
+/**
+ * Dependencies passed to factory functions
+ */
+export interface FactoryDependencies {
+    /** MathTS configuration */
+    config: MathTSConfig;
+    /** typed-function instance */
+    typed: TypedInstance;
+    /** Registered functions (for cross-references) */
+    [key: string]: unknown;
+}
+/**
+ * Import definition for a factory function
+ */
+export type FactoryImport = FactoryFunction | (() => Promise<FactoryFunction>);
+/**
+ * MathTS function registry
+ */
+export declare class FunctionRegistry {
+    private factories;
+    private instances;
+    private dependencies;
+    private creating;
+    constructor(config?: Partial<MathTSConfig>, typed?: TypedInstance);
+    /**
+     * Register a factory function
+     */
+    register(factory: FactoryFunction): void;
+    /**
+     * Register multiple factory functions
+     */
+    registerAll(factories: FactoryFunction[]): void;
+    /**
+     * Get or create a function by name
+     */
+    get(name: string): TypedFunction;
+    /**
+     * Check if a function is registered
+     */
+    has(name: string): boolean;
+    /**
+     * Get all registered function names
+     */
+    names(): string[];
+    /**
+     * Update configuration
+     */
+    updateConfig(config: Partial<MathTSConfig>): void;
+    /**
+     * Get current configuration
+     */
+    getConfig(): MathTSConfig;
+}
+/**
+ * Create a factory function definition
+ *
+ * @example
+ * ```typescript
+ * export const addFactory = createFactory('add', ['typed'], ({ typed }) =>
+ *   typed('add', {
+ *     'number, number': (a, b) => a + b,
+ *     'Complex, Complex': (a, b) => ({ re: a.re + b.re, im: a.im + b.im }),
+ *   })
+ * );
+ * ```
+ */
+export declare function createFactory<T = TypedFunction>(name: string, dependencies: string[], factory: (deps: FactoryDependencies) => T): FactoryFunction<T>;
+/**
+ * Create a typed function using the factory pattern
+ *
+ * This is a convenience wrapper that creates a factory and immediately
+ * invokes it with the default dependencies.
+ *
+ * @example
+ * ```typescript
+ * export const add = createTypedFunction('add', {
+ *   'number, number': (a, b) => a + b,
+ *   'string, string': (a, b) => a + b,
+ * });
+ * ```
+ */
+export declare function createTypedFunction(name: string, signatures: Record<string, SignatureFunction | ReferTo | ReferToSelf>): TypedFunction;
+export declare const registry: FunctionRegistry;
+export declare const math: {
+    /**
+     * Get a registered function
+     */
+    get: (name: string) => TypedFunction;
+    /**
+     * Register a factory function
+     */
+    register: (factory: FactoryFunction) => void;
+    /**
+     * Get configuration
+     */
+    config: () => MathTSConfig;
+    /**
+     * Update configuration
+     */
+    configure: (config: Partial<MathTSConfig>) => void;
+};
+//# sourceMappingURL=factory.d.ts.map

package/dist/factory/factory.d.ts.map

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