@danielsimonjr/mathts-core 0.14.0 → 0.14.3

package/dist/{chunk-YZN52XIQ.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;
@@ -19,7 +29,15 @@ var Complex = class _Complex {
    * @param theta - angle in radians
    */
   static fromPolar(r, theta) {
-    return new _Complex(r * Math.cos(theta), r * Math.sin(theta));
+    const cosT = Math.cos(theta);
+    const sinT = Math.sin(theta);
+    let re = r * cosT;
+    let im = r * sinT;
+    if (!Number.isFinite(r) && !Number.isNaN(r)) {
+      if (cosT === 0) re = cosT;
+      if (sinT === 0) im = sinT;
+    }
+    return new _Complex(re, im);
   }
   /**
    * Create a Complex from a real number
@@ -142,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 (-π, π]
@@ -258,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)
@@ -304,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))
@@ -351,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)
@@ -396,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)
@@ -1483,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];
@@ -1684,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);
@@ -1695,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);
@@ -2033,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());
   }
   /**
@@ -2097,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
@@ -4459,83 +4549,87 @@ var createUnitClass = /* @__PURE__ */ factory(
       "LUMINOUS_INTENSITY",
       "AMOUNT_OF_SUBSTANCE",
       "ANGLE",
-      "BIT"
+      "BIT",
+      "SOLID_ANGLE"
     ];
     const BASE_UNITS = {
       NONE: {
-        dimensions: [0, 0, 0, 0, 0, 0, 0, 0, 0]
+        dimensions: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
       },
       MASS: {
-        dimensions: [1, 0, 0, 0, 0, 0, 0, 0, 0]
+        dimensions: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
       },
       LENGTH: {
-        dimensions: [0, 1, 0, 0, 0, 0, 0, 0, 0]
+        dimensions: [0, 1, 0, 0, 0, 0, 0, 0, 0, 0]
       },
       TIME: {
-        dimensions: [0, 0, 1, 0, 0, 0, 0, 0, 0]
+        dimensions: [0, 0, 1, 0, 0, 0, 0, 0, 0, 0]
       },
       CURRENT: {
-        dimensions: [0, 0, 0, 1, 0, 0, 0, 0, 0]
+        dimensions: [0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
       },
       TEMPERATURE: {
-        dimensions: [0, 0, 0, 0, 1, 0, 0, 0, 0]
+        dimensions: [0, 0, 0, 0, 1, 0, 0, 0, 0, 0]
       },
       LUMINOUS_INTENSITY: {
-        dimensions: [0, 0, 0, 0, 0, 1, 0, 0, 0]
+        dimensions: [0, 0, 0, 0, 0, 1, 0, 0, 0, 0]
       },
       AMOUNT_OF_SUBSTANCE: {
-        dimensions: [0, 0, 0, 0, 0, 0, 1, 0, 0]
+        dimensions: [0, 0, 0, 0, 0, 0, 1, 0, 0, 0]
       },
       FORCE: {
-        dimensions: [1, 1, -2, 0, 0, 0, 0, 0, 0]
+        dimensions: [1, 1, -2, 0, 0, 0, 0, 0, 0, 0]
       },
       SURFACE: {
-        dimensions: [0, 2, 0, 0, 0, 0, 0, 0, 0]
+        dimensions: [0, 2, 0, 0, 0, 0, 0, 0, 0, 0]
       },
       VOLUME: {
-        dimensions: [0, 3, 0, 0, 0, 0, 0, 0, 0]
+        dimensions: [0, 3, 0, 0, 0, 0, 0, 0, 0, 0]
       },
       ENERGY: {
-        dimensions: [1, 2, -2, 0, 0, 0, 0, 0, 0]
+        dimensions: [1, 2, -2, 0, 0, 0, 0, 0, 0, 0]
       },
       POWER: {
-        dimensions: [1, 2, -3, 0, 0, 0, 0, 0, 0]
+        dimensions: [1, 2, -3, 0, 0, 0, 0, 0, 0, 0]
       },
       PRESSURE: {
-        dimensions: [1, -1, -2, 0, 0, 0, 0, 0, 0]
+        dimensions: [1, -1, -2, 0, 0, 0, 0, 0, 0, 0]
       },
       ELECTRIC_CHARGE: {
-        dimensions: [0, 0, 1, 1, 0, 0, 0, 0, 0]
+        dimensions: [0, 0, 1, 1, 0, 0, 0, 0, 0, 0]
       },
       ELECTRIC_CAPACITANCE: {
-        dimensions: [-1, -2, 4, 2, 0, 0, 0, 0, 0]
+        dimensions: [-1, -2, 4, 2, 0, 0, 0, 0, 0, 0]
       },
       ELECTRIC_POTENTIAL: {
-        dimensions: [1, 2, -3, -1, 0, 0, 0, 0, 0]
+        dimensions: [1, 2, -3, -1, 0, 0, 0, 0, 0, 0]
       },
       ELECTRIC_RESISTANCE: {
-        dimensions: [1, 2, -3, -2, 0, 0, 0, 0, 0]
+        dimensions: [1, 2, -3, -2, 0, 0, 0, 0, 0, 0]
       },
       ELECTRIC_INDUCTANCE: {
-        dimensions: [1, 2, -2, -2, 0, 0, 0, 0, 0]
+        dimensions: [1, 2, -2, -2, 0, 0, 0, 0, 0, 0]
       },
       ELECTRIC_CONDUCTANCE: {
-        dimensions: [-1, -2, 3, 2, 0, 0, 0, 0, 0]
+        dimensions: [-1, -2, 3, 2, 0, 0, 0, 0, 0, 0]
       },
       MAGNETIC_FLUX: {
-        dimensions: [1, 2, -2, -1, 0, 0, 0, 0, 0]
+        dimensions: [1, 2, -2, -1, 0, 0, 0, 0, 0, 0]
       },
       MAGNETIC_FLUX_DENSITY: {
-        dimensions: [1, 0, -2, -1, 0, 0, 0, 0, 0]
+        dimensions: [1, 0, -2, -1, 0, 0, 0, 0, 0, 0]
       },
       FREQUENCY: {
-        dimensions: [0, 0, -1, 0, 0, 0, 0, 0, 0]
+        dimensions: [0, 0, -1, 0, 0, 0, 0, 0, 0, 0]
       },
       ANGLE: {
-        dimensions: [0, 0, 0, 0, 0, 0, 0, 1, 0]
+        dimensions: [0, 0, 0, 0, 0, 0, 0, 1, 0, 0]
       },
       BIT: {
-        dimensions: [0, 0, 0, 0, 0, 0, 0, 0, 1]
+        dimensions: [0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
+      },
+      SOLID_ANGLE: {
+        dimensions: [0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
       }
     };
     for (const key in BASE_UNITS) {
@@ -5450,9 +5544,21 @@ var createUnitClass = /* @__PURE__ */ factory(
         value: 1,
         offset: 0
       },
-      // TODO: units STERADIAN
-      // {name: 'sr', base: BASE_UNITS.STERADIAN, prefixes: PREFIXES.NONE, value: 1, offset: 0},
-      // {name: 'steradian', base: BASE_UNITS.STERADIAN, prefixes: PREFIXES.NONE, value: 1, offset: 0},
+      // Solid angle
+      sr: {
+        name: "sr",
+        base: BASE_UNITS.SOLID_ANGLE,
+        prefixes: PREFIXES.NONE,
+        value: 1,
+        offset: 0
+      },
+      steradian: {
+        name: "steradian",
+        base: BASE_UNITS.SOLID_ANGLE,
+        prefixes: PREFIXES.LONG,
+        value: 1,
+        offset: 0
+      },
       // Force
       N: {
         name: "N",
@@ -5962,6 +6068,7 @@ var createUnitClass = /* @__PURE__ */ factory(
         LUMINOUS_INTENSITY: { unit: UNITS.cd, prefix: PREFIXES.SHORT[""] },
         AMOUNT_OF_SUBSTANCE: { unit: UNITS.mol, prefix: PREFIXES.SHORT[""] },
         ANGLE: { unit: UNITS.rad, prefix: PREFIXES.SHORT[""] },
+        SOLID_ANGLE: { unit: UNITS.sr, prefix: PREFIXES.NONE[""] },
         BIT: { unit: UNITS.bits, prefix: PREFIXES.SHORT[""] },
         // Derived units
         FORCE: { unit: UNITS.N, prefix: PREFIXES.SHORT[""] },
@@ -6174,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/index.d.ts

@@ -258,8 +258,11 @@ declare class Complex implements IComplex {
      */
     inverse(): Complex;
     /**
-     * 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(): Complex;
     /**
@@ -299,11 +302,13 @@ declare class Complex implements IComplex {
      */
     cos(): 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(): Complex;
     /**
-     * Cotangent: cot(z) = cos(z) / sin(z)
+     * Cotangent: cot(x+iy) = (sin 2x − i sinh 2y) / (cosh 2y − cos 2x)
      */
     cot(): Complex;
     /**
@@ -323,11 +328,11 @@ declare class Complex implements IComplex {
      */
     cosh(): Complex;
     /**
-     * Hyperbolic tangent: tanh(z) = sinh(z) / cosh(z)
+     * Hyperbolic tangent: tanh(x+iy) = (sinh 2x + i sin 2y) / (cosh 2x + cos 2y)
      */
     tanh(): Complex;
     /**
-     * Hyperbolic cotangent: coth(z) = cosh(z) / sinh(z)
+     * Hyperbolic cotangent: coth(x+iy) = (sinh 2x − i sin 2y) / (cosh 2x − cos 2y)
      */
     coth(): Complex;
     /**
@@ -2558,6 +2563,9 @@ declare function scaledDistance(a: ArrayLike<number>, b: ArrayLike<number>): num
  * 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.
  */

package/dist/index.js

@@ -44,7 +44,7 @@ import {
   round,
   sign,
   subtractScalar
-} from "./chunk-YZN52XIQ.js";
+} from "./chunk-L5MWGOLB.js";
 
 // src/types/matrix/Range.ts
 var name = "Range";
@@ -1301,13 +1301,60 @@ function sumSquaredDeviations(xs) {
   const n = xs.length;
   if (n < 2) return 0;
   const mean = pairwiseSum(xs) / n;
-  const d = new Float64Array(n);
-  for (let i = 0; i < n; i++) d[i] = xs[i] - mean;
-  const sumD = pairwiseSum(d);
-  const sumDD = pairwiseDot(d, d);
+  const { sumD, sumDD } = pairwiseDeviationSums(xs, mean, 0, n);
   const corrected = sumDD - sumD * sumD / n;
   return corrected < 0 ? 0 : corrected;
 }
+function pairwiseDeviationSums(xs, mean, start, end) {
+  const n = end - start;
+  if (n <= PAIRWISE_BLOCK) {
+    let d0 = 0, d1 = 0, d2 = 0, d3 = 0, d4 = 0, d5 = 0, d6 = 0, d7 = 0;
+    let q0 = 0, q1 = 0, q2 = 0, q3 = 0, q4 = 0, q5 = 0, q6 = 0, q7 = 0;
+    let i = start;
+    const limit = start + (n - n % 8);
+    for (; i < limit; i += 8) {
+      const a0 = xs[i] - mean;
+      const a1 = xs[i + 1] - mean;
+      const a2 = xs[i + 2] - mean;
+      const a3 = xs[i + 3] - mean;
+      const a4 = xs[i + 4] - mean;
+      const a5 = xs[i + 5] - mean;
+      const a6 = xs[i + 6] - mean;
+      const a7 = xs[i + 7] - mean;
+      d0 += a0;
+      q0 += a0 * a0;
+      d1 += a1;
+      q1 += a1 * a1;
+      d2 += a2;
+      q2 += a2 * a2;
+      d3 += a3;
+      q3 += a3 * a3;
+      d4 += a4;
+      q4 += a4 * a4;
+      d5 += a5;
+      q5 += a5 * a5;
+      d6 += a6;
+      q6 += a6 * a6;
+      d7 += a7;
+      q7 += a7 * a7;
+    }
+    let tailD = 0;
+    let tailDD = 0;
+    for (; i < end; i++) {
+      const a = xs[i] - mean;
+      tailD += a;
+      tailDD += a * a;
+    }
+    return {
+      sumD: d0 + d1 + (d2 + d3) + (d4 + d5 + (d6 + d7)) + tailD,
+      sumDD: q0 + q1 + (q2 + q3) + (q4 + q5 + (q6 + q7)) + tailDD
+    };
+  }
+  const half = (n >> 1) - (n >> 1) % 8;
+  const left = pairwiseDeviationSums(xs, mean, start, start + half);
+  const right = pairwiseDeviationSums(xs, mean, start + half, end);
+  return { sumD: left.sumD + right.sumD, sumDD: left.sumDD + right.sumDD };
+}
 function neumaierCumsum(xs, out) {
   let sum = 0;
   let c = 0;
@@ -1321,7 +1368,7 @@ function neumaierCumsum(xs, out) {
 }
 
 // src/index.ts
-var VERSION = "0.14.0";
+var VERSION = "0.14.3";
 export {
   ALL_UNITS,
   BASE_UNITS,

package/dist/internal.js

@@ -78,7 +78,7 @@ import {
   typeOf,
   unitDependencies,
   warnOnce
-} from "./chunk-YZN52XIQ.js";
+} from "./chunk-L5MWGOLB.js";
 
 // src/error/DimensionError.ts
 var DimensionError = class _DimensionError extends RangeError {
@@ -232,7 +232,7 @@ function format2(value, options) {
       let str;
       const rounded = v.toSignificantDigits(precision);
       const exp = rounded.e;
-      let condition = false;
+      let condition;
       if (isBigNumber(lowerExp) && isBigNumber(upperExp)) {
         const lowerExpBn = lowerExp;
         const upperExpBn = upperExp;
@@ -559,7 +559,9 @@ function reshape(array, sizes) {
     return _reshape(flatArray, processedSizes);
   } catch (e) {
     if (e instanceof DimensionError) {
-      throw new DimensionError(newLength, currentLength, "!=");
+      const dimErr = new DimensionError(newLength, currentLength, "!=");
+      dimErr.cause = e;
+      throw dimErr;
     }
     throw e;
   }

package/package.json

@@ -1,59 +1,59 @@
-{
-  "name": "@danielsimonjr/mathts-core",
-  "version": "0.14.0",
-  "description": "Core types, utilities, and configuration for MathTS",
-  "author": "Daniel Simon Jr.",
-  "license": "MIT",
-  "type": "module",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    },
-    "./internal": {
-      "import": "./dist/internal.js",
-      "types": "./dist/internal.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "README.md"
-  ],
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src --ext .ts",
-    "lint:fix": "eslint src --ext .ts --fix",
-    "clean": "rm -rf dist",
-    "build:prod": "tsup --minify --treeshake"
-  },
-  "dependencies": {
-    "typed-function": "github:danielsimonjr/typed-function"
-  },
-  "devDependencies": {
-    "@types/node": "^25.5.2",
-    "tsup": "^8.0.0",
-    "typescript": "^5.3.0",
-    "vitest": "^4.1.5"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/danielsimonjr/MathTS.git",
-    "directory": "core"
-  },
-  "keywords": [
-    "math",
-    "typescript",
-    "core"
-  ]
-}
+{
+  "name": "@danielsimonjr/mathts-core",
+  "version": "0.14.3",
+  "description": "Core types, utilities, and configuration for MathTS",
+  "author": "Daniel Simon Jr.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./internal": {
+      "import": "./dist/internal.js",
+      "types": "./dist/internal.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "lint:fix": "eslint src --ext .ts --fix",
+    "clean": "rm -rf dist",
+    "build:prod": "tsup --minify --treeshake"
+  },
+  "dependencies": {
+    "typed-function": "github:danielsimonjr/typed-function"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^4.1.10"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/danielsimonjr/MathTS.git",
+    "directory": "core"
+  },
+  "keywords": [
+    "math",
+    "typescript",
+    "core"
+  ]
+}