@danielsimonjr/mathts-core 0.1.1

package/dist/index.js

@@ -0,0 +1,2608 @@
+// src/types/complex.ts
+function isComplex(value) {
+  return value instanceof Complex;
+}
+var Complex = class _Complex {
+  type = "Complex";
+  re;
+  im;
+  constructor(re, im = 0) {
+    this.re = re;
+    this.im = im;
+  }
+  // ============================================================
+  // Static Factory Methods
+  // ============================================================
+  /**
+   * Create a Complex from polar form (r, θ)
+   * @param r - magnitude (radius)
+   * @param theta - angle in radians
+   */
+  static fromPolar(r, theta) {
+    return new _Complex(r * Math.cos(theta), r * Math.sin(theta));
+  }
+  /**
+   * Create a Complex from a real number
+   */
+  static fromNumber(n) {
+    return new _Complex(n, 0);
+  }
+  /**
+   * Create a Complex from a JSON object
+   */
+  static fromJSON(json) {
+    return new _Complex(json.re, json.im);
+  }
+  /**
+   * Parse a complex number from a string
+   * Supports formats: "3+4i", "3-4i", "3", "4i", "-4i", "i", "-i"
+   */
+  static parse(str) {
+    str = str.replace(/\s/g, "");
+    const match = str.match(/^([+-]?[\d.]+)([+-])([\d.]*)i$/);
+    if (match) {
+      const re = parseFloat(match[1]);
+      const sign = match[2] === "-" ? -1 : 1;
+      const imMag = match[3] === "" ? 1 : parseFloat(match[3]);
+      return new _Complex(re, sign * imMag);
+    }
+    if (str.endsWith("i")) {
+      const imStr = str.slice(0, -1);
+      if (imStr === "" || imStr === "+") return new _Complex(0, 1);
+      if (imStr === "-") return new _Complex(0, -1);
+      return new _Complex(0, parseFloat(imStr));
+    }
+    return new _Complex(parseFloat(str), 0);
+  }
+  /**
+   * Compare two complex numbers lexicographically (re first, then im)
+   * @returns -1, 0, or 1
+   */
+  static compare(a, b) {
+    if (a.re > b.re) return 1;
+    if (a.re < b.re) return -1;
+    if (a.im > b.im) return 1;
+    if (a.im < b.im) return -1;
+    return 0;
+  }
+  // ============================================================
+  // Conversion Methods
+  // ============================================================
+  valueOf() {
+    return this.abs();
+  }
+  toString() {
+    if (this.im === 0) return `${this.re}`;
+    if (this.re === 0) {
+      if (this.im === 1) return "i";
+      if (this.im === -1) return "-i";
+      return `${this.im}i`;
+    }
+    const sign = this.im >= 0 ? " + " : " - ";
+    const absIm = Math.abs(this.im);
+    const imStr = absIm === 1 ? "i" : `${absIm}i`;
+    return `${this.re}${sign}${imStr}`;
+  }
+  toJSON() {
+    return { mathjs: "Complex", re: this.re, im: this.im };
+  }
+  /**
+   * Return polar representation
+   */
+  toPolar() {
+    return { r: this.abs(), phi: this.arg() };
+  }
+  /**
+   * Format with options (precision, notation, etc.)
+   */
+  format(options) {
+    const formatNum = (n) => {
+      if (!options) return String(n);
+      if (options.precision !== void 0) {
+        if (options.notation === "exponential") {
+          return n.toExponential(options.precision);
+        }
+        if (options.notation === "fixed") {
+          return n.toFixed(options.precision);
+        }
+        return Number(n.toPrecision(options.precision)).toString();
+      }
+      return String(n);
+    };
+    let re = this.re;
+    let im = this.im;
+    if (options?.precision !== void 0) {
+      const epsilon = Math.pow(10, -options.precision);
+      if (Math.abs(re) < epsilon * Math.abs(im)) re = 0;
+      if (Math.abs(im) < epsilon * Math.abs(re)) im = 0;
+    }
+    if (im === 0) return formatNum(re);
+    if (re === 0) {
+      if (im === 1) return "i";
+      if (im === -1) return "-i";
+      return `${formatNum(im)}i`;
+    }
+    const sign = im < 0 ? " - " : " + ";
+    const absIm = Math.abs(im);
+    if (absIm === 1) {
+      return `${formatNum(re)}${sign}i`;
+    }
+    return `${formatNum(re)}${sign}${formatNum(absIm)}i`;
+  }
+  // ============================================================
+  // Basic Properties
+  // ============================================================
+  /**
+   * Complex conjugate (a + bi → a - bi)
+   */
+  conjugate() {
+    return new _Complex(this.re, -this.im);
+  }
+  /**
+   * Magnitude (absolute value) |z| = √(re² + im²)
+   */
+  abs() {
+    return Math.hypot(this.re, this.im);
+  }
+  /**
+   * Phase angle (argument) in radians, range (-π, π]
+   */
+  arg() {
+    return Math.atan2(this.im, this.re);
+  }
+  /**
+   * Squared magnitude |z|² = re² + im²
+   * More efficient than abs() when you don't need the square root
+   */
+  abs2() {
+    return this.re * this.re + this.im * this.im;
+  }
+  // ============================================================
+  // Arithmetic Operations (Scalar interface)
+  // ============================================================
+  /**
+   * Addition: (a + bi) + (c + di) = (a + c) + (b + d)i
+   */
+  add(other) {
+    if (other instanceof _Complex) {
+      return new _Complex(this.re + other.re, this.im + other.im);
+    }
+    return new _Complex(this.re + Number(other.valueOf()), this.im);
+  }
+  /**
+   * Subtraction: (a + bi) - (c + di) = (a - c) + (b - d)i
+   */
+  subtract(other) {
+    if (other instanceof _Complex) {
+      return new _Complex(this.re - other.re, this.im - other.im);
+    }
+    return new _Complex(this.re - Number(other.valueOf()), this.im);
+  }
+  /**
+   * Multiplication: (a + bi)(c + di) = (ac - bd) + (ad + bc)i
+   */
+  multiply(other) {
+    if (other instanceof _Complex) {
+      return new _Complex(
+        this.re * other.re - this.im * other.im,
+        this.re * other.im + this.im * other.re
+      );
+    }
+    const n = Number(other.valueOf());
+    return new _Complex(this.re * n, this.im * n);
+  }
+  /**
+   * Division: (a + bi)/(c + di) = ((ac + bd) + (bc - ad)i) / (c² + d²)
+   */
+  divide(other) {
+    if (other instanceof _Complex) {
+      const denom = other.re * other.re + other.im * other.im;
+      if (denom === 0) {
+        return new _Complex(
+          this.re !== 0 ? this.re > 0 ? Infinity : -Infinity : NaN,
+          this.im !== 0 ? this.im > 0 ? Infinity : -Infinity : NaN
+        );
+      }
+      return new _Complex(
+        (this.re * other.re + this.im * other.im) / denom,
+        (this.im * other.re - this.re * other.im) / denom
+      );
+    }
+    const n = Number(other.valueOf());
+    if (n === 0) {
+      return new _Complex(
+        this.re !== 0 ? this.re > 0 ? Infinity : -Infinity : NaN,
+        this.im !== 0 ? this.im > 0 ? Infinity : -Infinity : NaN
+      );
+    }
+    return new _Complex(this.re / n, this.im / n);
+  }
+  /**
+   * Negation: -(a + bi) = -a - bi
+   */
+  negate() {
+    return new _Complex(-this.re, -this.im);
+  }
+  /**
+   * Multiplicative inverse: 1/z = z̄/|z|²
+   */
+  inverse() {
+    const denom = this.abs2();
+    if (denom === 0) {
+      return new _Complex(Infinity, Infinity);
+    }
+    return new _Complex(this.re / denom, -this.im / denom);
+  }
+  // ============================================================
+  // Transcendental Functions
+  // ============================================================
+  /**
+   * Square root using principal branch
+   * √z = √r · e^(iθ/2) where r = |z|, θ = arg(z)
+   */
+  sqrt() {
+    const r = this.abs();
+    const theta = this.arg();
+    return _Complex.fromPolar(Math.sqrt(r), theta / 2);
+  }
+  /**
+   * n-th root (returns principal root)
+   */
+  nthRoot(n) {
+    const r = this.abs();
+    const theta = this.arg();
+    return _Complex.fromPolar(Math.pow(r, 1 / n), theta / n);
+  }
+  /**
+   * All n-th roots
+   */
+  nthRoots(n) {
+    const r = this.abs();
+    const theta = this.arg();
+    const rootR = Math.pow(r, 1 / n);
+    const roots = [];
+    for (let k = 0; k < n; k++) {
+      roots.push(_Complex.fromPolar(rootR, (theta + 2 * Math.PI * k) / n));
+    }
+    return roots;
+  }
+  /**
+   * Exponential: e^(a+bi) = e^a · (cos(b) + i·sin(b))
+   */
+  exp() {
+    const ea = Math.exp(this.re);
+    return new _Complex(ea * Math.cos(this.im), ea * Math.sin(this.im));
+  }
+  /**
+   * Natural logarithm: ln(z) = ln|z| + i·arg(z)
+   */
+  log() {
+    return new _Complex(Math.log(this.abs()), this.arg());
+  }
+  /**
+   * Logarithm base 10
+   */
+  log10() {
+    return this.log().divide(new _Complex(Math.LN10, 0));
+  }
+  /**
+   * Logarithm base 2
+   */
+  log2() {
+    return this.log().divide(new _Complex(Math.LN2, 0));
+  }
+  /**
+   * Power: z^w = e^(w·ln(z))
+   */
+  pow(n) {
+    if (typeof n === "number") {
+      if (this.re === 0 && this.im === 0) {
+        return n === 0 ? new _Complex(1, 0) : new _Complex(0, 0);
+      }
+      const r = this.abs();
+      const theta = this.arg();
+      return _Complex.fromPolar(Math.pow(r, n), theta * n);
+    }
+    if (this.re === 0 && this.im === 0) {
+      return new _Complex(0, 0);
+    }
+    return this.log().multiply(n).exp();
+  }
+  // ============================================================
+  // Trigonometric Functions
+  // ============================================================
+  /**
+   * Sine: sin(a + bi) = sin(a)cosh(b) + i·cos(a)sinh(b)
+   */
+  sin() {
+    return new _Complex(
+      Math.sin(this.re) * Math.cosh(this.im),
+      Math.cos(this.re) * Math.sinh(this.im)
+    );
+  }
+  /**
+   * Cosine: cos(a + bi) = cos(a)cosh(b) - i·sin(a)sinh(b)
+   */
+  cos() {
+    return new _Complex(
+      Math.cos(this.re) * Math.cosh(this.im),
+      -Math.sin(this.re) * Math.sinh(this.im)
+    );
+  }
+  /**
+   * Tangent: tan(z) = sin(z) / cos(z)
+   */
+  tan() {
+    return this.sin().divide(this.cos());
+  }
+  /**
+   * Cotangent: cot(z) = cos(z) / sin(z)
+   */
+  cot() {
+    return this.cos().divide(this.sin());
+  }
+  /**
+   * Secant: sec(z) = 1 / cos(z)
+   */
+  sec() {
+    return this.cos().inverse();
+  }
+  /**
+   * Cosecant: csc(z) = 1 / sin(z)
+   */
+  csc() {
+    return this.sin().inverse();
+  }
+  // ============================================================
+  // Hyperbolic Functions
+  // ============================================================
+  /**
+   * Hyperbolic sine: sinh(z) = (e^z - e^(-z)) / 2
+   */
+  sinh() {
+    return new _Complex(
+      Math.sinh(this.re) * Math.cos(this.im),
+      Math.cosh(this.re) * Math.sin(this.im)
+    );
+  }
+  /**
+   * Hyperbolic cosine: cosh(z) = (e^z + e^(-z)) / 2
+   */
+  cosh() {
+    return new _Complex(
+      Math.cosh(this.re) * Math.cos(this.im),
+      Math.sinh(this.re) * Math.sin(this.im)
+    );
+  }
+  /**
+   * Hyperbolic tangent: tanh(z) = sinh(z) / cosh(z)
+   */
+  tanh() {
+    return this.sinh().divide(this.cosh());
+  }
+  /**
+   * Hyperbolic cotangent: coth(z) = cosh(z) / sinh(z)
+   */
+  coth() {
+    return this.cosh().divide(this.sinh());
+  }
+  /**
+   * Hyperbolic secant: sech(z) = 1 / cosh(z)
+   */
+  sech() {
+    return this.cosh().inverse();
+  }
+  /**
+   * Hyperbolic cosecant: csch(z) = 1 / sinh(z)
+   */
+  csch() {
+    return this.sinh().inverse();
+  }
+  // ============================================================
+  // Inverse Trigonometric Functions
+  // ============================================================
+  /**
+   * Arc sine: asin(z) = -i·ln(iz + √(1 - z²))
+   */
+  asin() {
+    const iz = new _Complex(-this.im, this.re);
+    const one = new _Complex(1, 0);
+    const sqrt = one.subtract(this.multiply(this)).sqrt();
+    return iz.add(sqrt).log().multiply(new _Complex(0, -1));
+  }
+  /**
+   * Arc cosine: acos(z) = π/2 - asin(z)
+   */
+  acos() {
+    return new _Complex(Math.PI / 2, 0).subtract(this.asin());
+  }
+  /**
+   * Arc tangent: atan(z) = (i/2)·ln((i + z)/(i - z))
+   */
+  atan() {
+    const i = new _Complex(0, 1);
+    const iHalf = new _Complex(0, 0.5);
+    const num = i.add(this);
+    const denom = i.subtract(this);
+    return num.divide(denom).log().multiply(iHalf);
+  }
+  // ============================================================
+  // Inverse Hyperbolic Functions
+  // ============================================================
+  /**
+   * Inverse hyperbolic sine: asinh(z) = ln(z + √(z² + 1))
+   */
+  asinh() {
+    const one = new _Complex(1, 0);
+    return this.add(this.multiply(this).add(one).sqrt()).log();
+  }
+  /**
+   * Inverse hyperbolic cosine: acosh(z) = ln(z + √(z² - 1))
+   */
+  acosh() {
+    const one = new _Complex(1, 0);
+    return this.add(this.multiply(this).subtract(one).sqrt()).log();
+  }
+  /**
+   * Inverse hyperbolic tangent: atanh(z) = (1/2)·ln((1 + z)/(1 - z))
+   */
+  atanh() {
+    const one = new _Complex(1, 0);
+    const half = new _Complex(0.5, 0);
+    return one.add(this).divide(one.subtract(this)).log().multiply(half);
+  }
+  // ============================================================
+  // Utility Methods
+  // ============================================================
+  /**
+   * Check equality within tolerance
+   */
+  equals(other, epsilon = 1e-12) {
+    return Math.abs(this.re - other.re) < epsilon && Math.abs(this.im - other.im) < epsilon;
+  }
+  /**
+   * Check if this is a real number (im ≈ 0)
+   */
+  isReal(epsilon = 0) {
+    return Math.abs(this.im) <= epsilon;
+  }
+  /**
+   * Check if this is purely imaginary (re ≈ 0, im ≠ 0)
+   */
+  isImaginary(epsilon = 0) {
+    return Math.abs(this.re) <= epsilon && Math.abs(this.im) > epsilon;
+  }
+  /**
+   * Check if this is zero
+   */
+  isZero(epsilon = 0) {
+    return Math.abs(this.re) <= epsilon && Math.abs(this.im) <= epsilon;
+  }
+  /**
+   * Check if this is NaN
+   */
+  isNaN() {
+    return Number.isNaN(this.re) || Number.isNaN(this.im);
+  }
+  /**
+   * Check if this is infinite
+   */
+  isInfinite() {
+    return !this.isNaN() && (!Number.isFinite(this.re) || !Number.isFinite(this.im));
+  }
+  /**
+   * Clone this complex number
+   */
+  clone() {
+    return new _Complex(this.re, this.im);
+  }
+  /**
+   * Round real and imaginary parts to specified decimals
+   */
+  round(decimals = 0) {
+    const factor = Math.pow(10, decimals);
+    return new _Complex(
+      Math.round(this.re * factor) / factor,
+      Math.round(this.im * factor) / factor
+    );
+  }
+  /**
+   * Floor real and imaginary parts
+   */
+  floor() {
+    return new _Complex(Math.floor(this.re), Math.floor(this.im));
+  }
+  /**
+   * Ceil real and imaginary parts
+   */
+  ceil() {
+    return new _Complex(Math.ceil(this.re), Math.ceil(this.im));
+  }
+  /**
+   * Sign function: z / |z| (unit complex number in same direction)
+   */
+  sign() {
+    const r = this.abs();
+    if (r === 0) return new _Complex(0, 0);
+    return new _Complex(this.re / r, this.im / r);
+  }
+};
+var I = new Complex(0, 1);
+var COMPLEX_ZERO = new Complex(0, 0);
+var COMPLEX_ONE = new Complex(1, 0);
+var COMPLEX_NEG_ONE = new Complex(-1, 0);
+
+// src/types/fraction.ts
+function isFraction(value) {
+  return value instanceof Fraction;
+}
+function gcd(a, b) {
+  a = a < 0n ? -a : a;
+  b = b < 0n ? -b : b;
+  while (b !== 0n) {
+    const t = b;
+    b = a % b;
+    a = t;
+  }
+  return a;
+}
+var Fraction = class _Fraction {
+  type = "Fraction";
+  numerator;
+  denominator;
+  constructor(numerator, denominator = 1n) {
+    let num = typeof numerator === "bigint" ? numerator : BigInt(numerator);
+    let den = typeof denominator === "bigint" ? denominator : BigInt(denominator);
+    if (den === 0n) {
+      throw new Error("Fraction denominator cannot be zero");
+    }
+    if (den < 0n) {
+      num = -num;
+      den = -den;
+    }
+    const g = gcd(num, den);
+    this.numerator = num / g;
+    this.denominator = den / g;
+  }
+  // ============================================================
+  // Static Factory Methods
+  // ============================================================
+  /**
+   * Create a Fraction from a number (with optional precision)
+   */
+  static fromNumber(n, maxDenominator = 1000000n) {
+    if (!Number.isFinite(n)) {
+      throw new Error("Cannot create fraction from non-finite number");
+    }
+    if (Number.isInteger(n)) {
+      return new _Fraction(BigInt(n), 1n);
+    }
+    const sign = n < 0 ? -1n : 1n;
+    n = Math.abs(n);
+    let h1 = 1n, h2 = 0n;
+    let k1 = 0n, k2 = 1n;
+    let b = n;
+    do {
+      const a = BigInt(Math.floor(b));
+      let aux = h1;
+      h1 = a * h1 + h2;
+      h2 = aux;
+      aux = k1;
+      k1 = a * k1 + k2;
+      k2 = aux;
+      b = 1 / (b - Number(a));
+    } while (Math.abs(n - Number(h1) / Number(k1)) > Number.EPSILON && k1 < maxDenominator);
+    return new _Fraction(sign * h1, k1);
+  }
+  /**
+   * Create a Fraction from a decimal string
+   */
+  static fromDecimalString(str) {
+    str = str.trim();
+    const repeatingMatch = str.match(/^(-?\d*)\.(\d*)\((\d+)\)$/);
+    if (repeatingMatch) {
+      const sign2 = str.startsWith("-") ? -1n : 1n;
+      const intPart2 = repeatingMatch[1] === "-" ? "0" : repeatingMatch[1] || "0";
+      const nonRepeating = repeatingMatch[2] || "";
+      const repeating = repeatingMatch[3];
+      const fullDigits = intPart2 + nonRepeating + repeating;
+      const nonRepDigits = intPart2 + nonRepeating;
+      const fullNum = BigInt(fullDigits.replace("-", ""));
+      const nonRepNum = BigInt(nonRepDigits.replace("-", "") || "0");
+      const nines = BigInt("9".repeat(repeating.length));
+      const zeros = BigInt("1" + "0".repeat(nonRepeating.length));
+      const num2 = fullNum - nonRepNum;
+      const den2 = nines * zeros;
+      return new _Fraction(sign2 * num2, den2);
+    }
+    const [intPart, decPart = ""] = str.split(".");
+    const sign = str.startsWith("-") ? -1n : 1n;
+    const absInt = intPart.replace("-", "") || "0";
+    const combined = absInt + decPart;
+    const num = BigInt(combined);
+    const den = BigInt("1" + "0".repeat(decPart.length));
+    return new _Fraction(sign * num, den);
+  }
+  /**
+   * Parse a fraction from a string
+   * Supports formats: "3/4", "-3/4", "3", "3.14", "0.(3)"
+   */
+  static parse(str) {
+    str = str.trim();
+    if (str.includes("/")) {
+      const [numStr, denStr] = str.split("/");
+      return new _Fraction(BigInt(numStr.trim()), BigInt(denStr.trim()));
+    }
+    if (str.includes(".") || str.includes("(")) {
+      return _Fraction.fromDecimalString(str);
+    }
+    return new _Fraction(BigInt(str), 1n);
+  }
+  /**
+   * Create a Fraction from a JSON object
+   */
+  static fromJSON(json) {
+    if ("n" in json) {
+      return new _Fraction(BigInt(json.n), BigInt(json.d));
+    }
+    return new _Fraction(BigInt(json.numerator), BigInt(json.denominator));
+  }
+  /**
+   * Compare two fractions
+   * @returns -1, 0, or 1
+   */
+  static compare(a, b) {
+    const diff = a.numerator * b.denominator - b.numerator * a.denominator;
+    if (diff < 0n) return -1;
+    if (diff > 0n) return 1;
+    return 0;
+  }
+  // ============================================================
+  // Conversion Methods
+  // ============================================================
+  valueOf() {
+    return Number(this.numerator) / Number(this.denominator);
+  }
+  toString() {
+    if (this.denominator === 1n) {
+      return this.numerator.toString();
+    }
+    return `${this.numerator}/${this.denominator}`;
+  }
+  toJSON() {
+    return {
+      mathjs: "Fraction",
+      n: this.numerator.toString(),
+      d: this.denominator.toString()
+    };
+  }
+  /**
+   * Convert to number
+   */
+  toNumber() {
+    return this.valueOf();
+  }
+  /**
+   * Convert to decimal string with specified precision
+   */
+  toDecimal(precision = 10) {
+    const sign = this.numerator < 0n ? "-" : "";
+    let num = this.numerator < 0n ? -this.numerator : this.numerator;
+    const den = this.denominator;
+    const intPart = num / den;
+    num = num % den;
+    if (num === 0n || precision === 0) {
+      return sign + intPart.toString();
+    }
+    let decPart = "";
+    for (let i = 0; i < precision && num !== 0n; i++) {
+      num *= 10n;
+      decPart += (num / den).toString();
+      num = num % den;
+    }
+    return sign + intPart.toString() + "." + decPart;
+  }
+  /**
+   * Convert to LaTeX string
+   */
+  toLatex() {
+    if (this.denominator === 1n) {
+      return this.numerator.toString();
+    }
+    const sign = this.numerator < 0n ? "-" : "";
+    const absNum = this.numerator < 0n ? -this.numerator : this.numerator;
+    return `${sign}\\frac{${absNum}}{${this.denominator}}`;
+  }
+  /**
+   * Convert to mixed number representation
+   */
+  toMixed() {
+    const sign = this.numerator < 0n ? -1n : 1n;
+    const absNum = this.numerator < 0n ? -this.numerator : this.numerator;
+    const whole = sign * (absNum / this.denominator);
+    const remainder = absNum % this.denominator;
+    return {
+      whole,
+      numerator: remainder,
+      denominator: this.denominator
+    };
+  }
+  // ============================================================
+  // Arithmetic Operations (Scalar interface)
+  // ============================================================
+  /**
+   * Addition: a/b + c/d = (ad + bc) / bd
+   */
+  add(other) {
+    if (other instanceof _Fraction) {
+      const num = this.numerator * other.denominator + other.numerator * this.denominator;
+      const den = this.denominator * other.denominator;
+      return new _Fraction(num, den);
+    }
+    return this.add(_Fraction.fromNumber(Number(other.valueOf())));
+  }
+  /**
+   * Subtraction: a/b - c/d = (ad - bc) / bd
+   */
+  subtract(other) {
+    if (other instanceof _Fraction) {
+      const num = this.numerator * other.denominator - other.numerator * this.denominator;
+      const den = this.denominator * other.denominator;
+      return new _Fraction(num, den);
+    }
+    return this.subtract(_Fraction.fromNumber(Number(other.valueOf())));
+  }
+  /**
+   * Multiplication: a/b * c/d = ac / bd
+   */
+  multiply(other) {
+    if (other instanceof _Fraction) {
+      return new _Fraction(
+        this.numerator * other.numerator,
+        this.denominator * other.denominator
+      );
+    }
+    return this.multiply(_Fraction.fromNumber(Number(other.valueOf())));
+  }
+  /**
+   * Division: a/b ÷ c/d = ad / bc
+   */
+  divide(other) {
+    if (other instanceof _Fraction) {
+      if (other.numerator === 0n) {
+        throw new Error("Division by zero");
+      }
+      return new _Fraction(
+        this.numerator * other.denominator,
+        this.denominator * other.numerator
+      );
+    }
+    return this.divide(_Fraction.fromNumber(Number(other.valueOf())));
+  }
+  /**
+   * Negation: -(a/b) = -a/b
+   */
+  negate() {
+    return new _Fraction(-this.numerator, this.denominator);
+  }
+  /**
+   * Absolute value: |a/b|
+   */
+  abs() {
+    return new _Fraction(
+      this.numerator < 0n ? -this.numerator : this.numerator,
+      this.denominator
+    );
+  }
+  /**
+   * Reciprocal: b/a
+   */
+  inverse() {
+    if (this.numerator === 0n) {
+      throw new Error("Cannot invert zero");
+    }
+    return new _Fraction(this.denominator, this.numerator);
+  }
+  /**
+   * Power (integer exponent)
+   */
+  pow(n) {
+    const exp = typeof n === "bigint" ? n : BigInt(n);
+    if (exp === 0n) {
+      return new _Fraction(1n, 1n);
+    }
+    if (exp < 0n) {
+      return this.inverse().pow(-exp);
+    }
+    let result = new _Fraction(1n, 1n);
+    let base = this;
+    let e = exp;
+    while (e > 0n) {
+      if (e % 2n === 1n) {
+        result = result.multiply(base);
+      }
+      base = base.multiply(base);
+      e = e / 2n;
+    }
+    return result;
+  }
+  /**
+   * Modulo operation
+   */
+  mod(other) {
+    const quotient = this.divide(other);
+    const floorQuot = quotient.floor();
+    return this.subtract(other.multiply(floorQuot));
+  }
+  // ============================================================
+  // Comparison Methods
+  // ============================================================
+  /**
+   * Check equality
+   */
+  equals(other) {
+    return this.numerator === other.numerator && this.denominator === other.denominator;
+  }
+  /**
+   * Check if less than
+   */
+  lessThan(other) {
+    return _Fraction.compare(this, other) < 0;
+  }
+  /**
+   * Check if less than or equal
+   */
+  lessThanOrEqual(other) {
+    return _Fraction.compare(this, other) <= 0;
+  }
+  /**
+   * Check if greater than
+   */
+  greaterThan(other) {
+    return _Fraction.compare(this, other) > 0;
+  }
+  /**
+   * Check if greater than or equal
+   */
+  greaterThanOrEqual(other) {
+    return _Fraction.compare(this, other) >= 0;
+  }
+  /**
+   * Compare with another fraction
+   * @returns -1, 0, or 1
+   */
+  compareTo(other) {
+    return _Fraction.compare(this, other);
+  }
+  compare(other) {
+    return this.compareTo(other);
+  }
+  // ============================================================
+  // Utility Methods
+  // ============================================================
+  /**
+   * Return fraction already in lowest terms (no-op since constructor reduces)
+   */
+  simplify() {
+    return this;
+  }
+  /**
+   * Check if this is zero
+   */
+  isZero() {
+    return this.numerator === 0n;
+  }
+  /**
+   * Check if this is positive
+   */
+  isPositive() {
+    return this.numerator > 0n;
+  }
+  /**
+   * Check if this is negative
+   */
+  isNegative() {
+    return this.numerator < 0n;
+  }
+  /**
+   * Check if this is an integer
+   */
+  isInteger() {
+    return this.denominator === 1n;
+  }
+  /**
+   * Check if this is a unit fraction (1/n)
+   */
+  isUnit() {
+    return this.numerator === 1n || this.numerator === -1n;
+  }
+  /**
+   * Floor: largest integer ≤ this
+   */
+  floor() {
+    if (this.denominator === 1n) {
+      return this;
+    }
+    const quot = this.numerator / this.denominator;
+    if (this.numerator >= 0n || this.numerator % this.denominator === 0n) {
+      return new _Fraction(quot, 1n);
+    }
+    return new _Fraction(quot - 1n, 1n);
+  }
+  /**
+   * Ceiling: smallest integer ≥ this
+   */
+  ceil() {
+    if (this.denominator === 1n) {
+      return this;
+    }
+    const quot = this.numerator / this.denominator;
+    if (this.numerator <= 0n || this.numerator % this.denominator === 0n) {
+      return new _Fraction(quot, 1n);
+    }
+    return new _Fraction(quot + 1n, 1n);
+  }
+  /**
+   * Round to nearest integer
+   */
+  round() {
+    const floor = this.floor();
+    const diff = this.subtract(floor);
+    const half = new _Fraction(1n, 2n);
+    if (diff.greaterThanOrEqual(half)) {
+      return floor.add(new _Fraction(1n, 1n));
+    }
+    return floor;
+  }
+  /**
+   * Truncate (round toward zero)
+   */
+  trunc() {
+    return new _Fraction(this.numerator / this.denominator, 1n);
+  }
+  /**
+   * Get the sign: -1, 0, or 1
+   */
+  sign() {
+    if (this.numerator < 0n) return -1;
+    if (this.numerator > 0n) return 1;
+    return 0;
+  }
+  /**
+   * Clone this fraction
+   */
+  clone() {
+    return new _Fraction(this.numerator, this.denominator);
+  }
+  /**
+   * Get the GCD of numerator and denominator (always 1 since we reduce)
+   */
+  gcd() {
+    return 1n;
+  }
+  /**
+   * Get continued fraction representation
+   */
+  toContinuedFraction() {
+    const result = [];
+    let num = this.numerator < 0n ? -this.numerator : this.numerator;
+    let den = this.denominator;
+    while (den !== 0n) {
+      result.push(num / den);
+      const temp = num % den;
+      num = den;
+      den = temp;
+    }
+    if (this.numerator < 0n && result.length > 0) {
+      result[0] = -result[0];
+    }
+    return result;
+  }
+  /**
+   * Create fraction from continued fraction
+   */
+  static fromContinuedFraction(cf) {
+    if (cf.length === 0) {
+      return new _Fraction(0n, 1n);
+    }
+    let num = cf[cf.length - 1];
+    let den = 1n;
+    for (let i = cf.length - 2; i >= 0; i--) {
+      const temp = num;
+      num = cf[i] * num + den;
+      den = temp;
+    }
+    return new _Fraction(num, den);
+  }
+  /**
+   * Mediant of two fractions: (a+c)/(b+d)
+   * Used in Stern-Brocot tree and Farey sequences
+   */
+  mediant(other) {
+    return new _Fraction(
+      this.numerator + other.numerator,
+      this.denominator + other.denominator
+    );
+  }
+};
+var FRACTION_ZERO = new Fraction(0n, 1n);
+var FRACTION_ONE = new Fraction(1n, 1n);
+var FRACTION_NEG_ONE = new Fraction(-1n, 1n);
+var FRACTION_HALF = new Fraction(1n, 2n);
+var FRACTION_THIRD = new Fraction(1n, 3n);
+var FRACTION_QUARTER = new Fraction(1n, 4n);
+
+// src/types/bignumber.ts
+function isBigNumber(value) {
+  return value instanceof BigNumber;
+}
+var defaultConfig = {
+  precision: 64,
+  rounding: "halfUp",
+  minExponent: -1e9,
+  maxExponent: 1e9
+};
+var globalConfig = { ...defaultConfig };
+var BigNumber = class _BigNumber {
+  type = "BigNumber";
+  // Internal representation: sign * coefficient * 10^exponent
+  _sign;
+  _coefficient;
+  // Absolute value, normalized
+  _exponent;
+  // Power of 10
+  // Special values
+  _isNaN = false;
+  _isInfinite = false;
+  constructor(sign, coefficient, exponent, isNaN2 = false, isInfinite = false) {
+    this._sign = sign;
+    this._coefficient = coefficient;
+    this._exponent = exponent;
+    this._isNaN = isNaN2;
+    this._isInfinite = isInfinite;
+  }
+  // ============================================================
+  // Static Factory Methods
+  // ============================================================
+  /**
+   * Create a BigNumber from a number
+   */
+  static fromNumber(n) {
+    if (Number.isNaN(n)) {
+      return new _BigNumber(0, 0n, 0, true, false);
+    }
+    if (!Number.isFinite(n)) {
+      return new _BigNumber(n > 0 ? 1 : -1, 0n, 0, false, true);
+    }
+    if (n === 0) {
+      return new _BigNumber(0, 0n, 0);
+    }
+    return _BigNumber.parse(n.toString());
+  }
+  /**
+   * Create a BigNumber from a string
+   */
+  static parse(str) {
+    str = str.trim().toLowerCase();
+    if (str === "nan") {
+      return new _BigNumber(0, 0n, 0, true, false);
+    }
+    if (str === "infinity" || str === "+infinity") {
+      return new _BigNumber(1, 0n, 0, false, true);
+    }
+    if (str === "-infinity") {
+      return new _BigNumber(-1, 0n, 0, false, true);
+    }
+    let sign = 1;
+    if (str.startsWith("-")) {
+      sign = -1;
+      str = str.slice(1);
+    } else if (str.startsWith("+")) {
+      str = str.slice(1);
+    }
+    let exponentPart = 0;
+    const eIndex = str.indexOf("e");
+    if (eIndex !== -1) {
+      exponentPart = parseInt(str.slice(eIndex + 1), 10);
+      str = str.slice(0, eIndex);
+    }
+    const dotIndex = str.indexOf(".");
+    let coefficient;
+    let decimalPlaces = 0;
+    if (dotIndex !== -1) {
+      coefficient = str.slice(0, dotIndex) + str.slice(dotIndex + 1);
+      decimalPlaces = str.length - dotIndex - 1;
+    } else {
+      coefficient = str;
+    }
+    coefficient = coefficient.replace(/^0+/, "") || "0";
+    if (coefficient === "0") {
+      return new _BigNumber(0, 0n, 0);
+    }
+    let trailingZeros = 0;
+    for (let i = coefficient.length - 1; i >= 0; i--) {
+      if (coefficient[i] === "0") {
+        trailingZeros++;
+      } else {
+        break;
+      }
+    }
+    if (trailingZeros > 0) {
+      coefficient = coefficient.slice(0, -trailingZeros);
+    }
+    const finalExponent = exponentPart - decimalPlaces + trailingZeros;
+    return new _BigNumber(sign, BigInt(coefficient), finalExponent);
+  }
+  /**
+   * Create from bigint
+   */
+  static fromBigInt(n) {
+    if (n === 0n) {
+      return new _BigNumber(0, 0n, 0);
+    }
+    const sign = 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);
+    }
+    return new _BigNumber(sign, BigInt(str), trailingZeros);
+  }
+  /**
+   * Create a BigNumber from a JSON object
+   */
+  static fromJSON(json) {
+    return _BigNumber.parse(json.value);
+  }
+  /**
+   * Get/set global configuration
+   */
+  static config(newConfig) {
+    if (newConfig) {
+      globalConfig = { ...globalConfig, ...newConfig };
+    }
+    return { ...globalConfig };
+  }
+  /**
+   * Reset configuration to defaults
+   */
+  static resetConfig() {
+    globalConfig = { ...defaultConfig };
+  }
+  /**
+   * Compare two BigNumbers
+   * @returns -1, 0, or 1
+   */
+  static compare(a, b) {
+    if (a._isNaN || b._isNaN) return NaN;
+    if (a._isInfinite && b._isInfinite) {
+      if (a._sign === b._sign) return 0;
+      return a._sign > b._sign ? 1 : -1;
+    }
+    if (a._isInfinite) return a._sign;
+    if (b._isInfinite) return -b._sign;
+    if (a._sign === 0 && b._sign === 0) return 0;
+    if (a._sign === 0) return -b._sign;
+    if (b._sign === 0) return a._sign;
+    if (a._sign !== b._sign) return a._sign > b._sign ? 1 : -1;
+    const result = _BigNumber.compareMagnitude(a, b);
+    return a._sign === 1 ? result : -result;
+  }
+  static compareMagnitude(a, b) {
+    const aDigits = a._coefficient.toString();
+    const bDigits = b._coefficient.toString();
+    const aOrder = aDigits.length + a._exponent;
+    const bOrder = bDigits.length + b._exponent;
+    if (aOrder !== bOrder) {
+      return aOrder > bOrder ? 1 : -1;
+    }
+    const aFull = aDigits + "0".repeat(Math.max(0, a._exponent));
+    const bFull = bDigits + "0".repeat(Math.max(0, b._exponent));
+    if (aFull === bFull) return 0;
+    return aFull > bFull ? 1 : -1;
+  }
+  // ============================================================
+  // Conversion Methods
+  // ============================================================
+  valueOf() {
+    if (this._isNaN) return NaN;
+    if (this._isInfinite) return this._sign === 1 ? Infinity : -Infinity;
+    if (this._sign === 0) return 0;
+    const str = this.toString();
+    return parseFloat(str);
+  }
+  toString() {
+    if (this._isNaN) return "NaN";
+    if (this._isInfinite) return this._sign === 1 ? "Infinity" : "-Infinity";
+    if (this._sign === 0) return "0";
+    const sign = this._sign === -1 ? "-" : "";
+    const digits = this._coefficient.toString();
+    if (this._exponent >= 0) {
+      return sign + digits + "0".repeat(this._exponent);
+    } else if (-this._exponent < digits.length) {
+      const insertPos = digits.length + this._exponent;
+      return sign + digits.slice(0, insertPos) + "." + digits.slice(insertPos);
+    } else {
+      return sign + "0." + "0".repeat(-this._exponent - digits.length) + digits;
+    }
+  }
+  toJSON() {
+    return {
+      mathjs: "BigNumber",
+      value: this.toString()
+    };
+  }
+  /**
+   * Convert to fixed-point notation
+   */
+  toFixed(decimalPlaces = 0) {
+    return this.round(decimalPlaces).toFixedInternal(decimalPlaces);
+  }
+  toFixedInternal(decimalPlaces) {
+    if (this._isNaN) return "NaN";
+    if (this._isInfinite) return this._sign === 1 ? "Infinity" : "-Infinity";
+    if (this._sign === 0) return decimalPlaces > 0 ? "0." + "0".repeat(decimalPlaces) : "0";
+    const sign = this._sign === -1 ? "-" : "";
+    const digits = this._coefficient.toString();
+    if (this._exponent >= 0) {
+      const intPart = digits + "0".repeat(this._exponent);
+      return sign + intPart + (decimalPlaces > 0 ? "." + "0".repeat(decimalPlaces) : "");
+    } else if (-this._exponent <= digits.length) {
+      const insertPos = digits.length + this._exponent;
+      const intPart = digits.slice(0, insertPos) || "0";
+      let decPart = digits.slice(insertPos);
+      if (decPart.length < decimalPlaces) {
+        decPart += "0".repeat(decimalPlaces - decPart.length);
+      }
+      return sign + intPart + (decimalPlaces > 0 ? "." + decPart.slice(0, decimalPlaces) : "");
+    } else {
+      const leadingZeros = -this._exponent - digits.length;
+      let decPart = "0".repeat(leadingZeros) + digits;
+      if (decPart.length < decimalPlaces) {
+        decPart += "0".repeat(decimalPlaces - decPart.length);
+      }
+      return sign + "0" + (decimalPlaces > 0 ? "." + decPart.slice(0, decimalPlaces) : "");
+    }
+  }
+  /**
+   * Convert to exponential notation
+   */
+  toExponential(decimalPlaces) {
+    if (this._isNaN) return "NaN";
+    if (this._isInfinite) return this._sign === 1 ? "Infinity" : "-Infinity";
+    if (this._sign === 0) {
+      const dp = decimalPlaces ?? 0;
+      return dp > 0 ? "0." + "0".repeat(dp) + "e+0" : "0e+0";
+    }
+    const sign = this._sign === -1 ? "-" : "";
+    const digits = this._coefficient.toString();
+    const exp = digits.length - 1 + this._exponent;
+    const expSign = exp >= 0 ? "+" : "";
+    if (decimalPlaces === void 0) {
+      if (digits.length === 1) {
+        return `${sign}${digits}e${expSign}${exp}`;
+      }
+      return `${sign}${digits[0]}.${digits.slice(1)}e${expSign}${exp}`;
+    }
+    if (decimalPlaces === 0) {
+      return `${sign}${digits[0]}e${expSign}${exp}`;
+    }
+    let decPart = digits.slice(1);
+    if (decPart.length < decimalPlaces) {
+      decPart += "0".repeat(decimalPlaces - decPart.length);
+    } else {
+      decPart = decPart.slice(0, decimalPlaces);
+    }
+    return `${sign}${digits[0]}.${decPart}e${expSign}${exp}`;
+  }
+  /**
+   * Convert to precision
+   */
+  toPrecision(significantDigits) {
+    if (significantDigits === void 0) {
+      return this.toString();
+    }
+    if (this._isNaN) return "NaN";
+    if (this._isInfinite) return this._sign === 1 ? "Infinity" : "-Infinity";
+    if (this._sign === 0) {
+      return significantDigits > 1 ? "0." + "0".repeat(significantDigits - 1) : "0";
+    }
+    const digits = this._coefficient.toString();
+    const order = digits.length + this._exponent;
+    if (order > significantDigits || order < -6) {
+      return this.toExponential(significantDigits - 1);
+    }
+    return this.toFixed(significantDigits - order);
+  }
+  /**
+   * Convert to bigint (truncated)
+   */
+  toBigInt() {
+    if (this._isNaN || this._isInfinite) {
+      throw new Error("Cannot convert NaN or Infinity to bigint");
+    }
+    if (this._sign === 0) return 0n;
+    const digits = this._coefficient.toString();
+    if (this._exponent >= 0) {
+      return BigInt(this._sign) * BigInt(digits + "0".repeat(this._exponent));
+    } else if (-this._exponent < digits.length) {
+      return BigInt(this._sign) * BigInt(digits.slice(0, digits.length + this._exponent));
+    }
+    return 0n;
+  }
+  // ============================================================
+  // Arithmetic Operations
+  // ============================================================
+  /**
+   * Addition
+   */
+  add(other) {
+    const b = this.ensureBigNumber(other);
+    if (this._isNaN || b._isNaN) return new _BigNumber(0, 0n, 0, true);
+    if (this._isInfinite && b._isInfinite) {
+      if (this._sign === b._sign) return this;
+      return new _BigNumber(0, 0n, 0, true);
+    }
+    if (this._isInfinite) return this;
+    if (b._isInfinite) return b;
+    if (this._sign === 0) return b;
+    if (b._sign === 0) return this;
+    const [aCoef, bCoef, exp] = this.alignExponents(this, b);
+    if (this._sign === b._sign) {
+      return this.normalize(this._sign, aCoef + bCoef, exp);
+    } else {
+      if (aCoef >= bCoef) {
+        const diff = aCoef - bCoef;
+        return this.normalize(diff === 0n ? 0 : this._sign, diff, exp);
+      } else {
+        return this.normalize(b._sign, bCoef - aCoef, exp);
+      }
+    }
+  }
+  /**
+   * Subtraction
+   */
+  subtract(other) {
+    const b = this.ensureBigNumber(other);
+    return this.add(b.negate());
+  }
+  /**
+   * Multiplication
+   */
+  multiply(other) {
+    const b = this.ensureBigNumber(other);
+    if (this._isNaN || b._isNaN) return new _BigNumber(0, 0n, 0, true);
+    if (this._isInfinite || b._isInfinite) {
+      if (this._sign === 0 || b._sign === 0) return new _BigNumber(0, 0n, 0, true);
+      const sign2 = this._sign * b._sign;
+      return new _BigNumber(sign2, 0n, 0, false, true);
+    }
+    if (this._sign === 0 || b._sign === 0) return new _BigNumber(0, 0n, 0);
+    const sign = this._sign * b._sign;
+    const coefficient = this._coefficient * b._coefficient;
+    const exponent = this._exponent + b._exponent;
+    return this.normalize(sign, coefficient, exponent);
+  }
+  /**
+   * Division
+   */
+  divide(other) {
+    const b = this.ensureBigNumber(other);
+    if (this._isNaN || b._isNaN) return new _BigNumber(0, 0n, 0, true);
+    if (this._isInfinite && b._isInfinite) return new _BigNumber(0, 0n, 0, true);
+    if (b._sign === 0) {
+      if (this._sign === 0) return new _BigNumber(0, 0n, 0, true);
+      return new _BigNumber(this._sign, 0n, 0, false, true);
+    }
+    if (this._isInfinite) {
+      const sign2 = this._sign * b._sign;
+      return new _BigNumber(sign2, 0n, 0, false, true);
+    }
+    if (b._isInfinite) return new _BigNumber(0, 0n, 0);
+    if (this._sign === 0) return new _BigNumber(0, 0n, 0);
+    const sign = this._sign * b._sign;
+    const precision = globalConfig.precision;
+    const scale = BigInt(10) ** BigInt(precision + 10);
+    const scaledDividend = this._coefficient * scale;
+    const quotient = scaledDividend / b._coefficient;
+    const exponent = this._exponent - b._exponent - precision - 10;
+    return this.normalize(sign, quotient, exponent).roundToPrecision(precision);
+  }
+  /**
+   * Negation
+   */
+  negate() {
+    if (this._isNaN) return this;
+    if (this._sign === 0) return this;
+    const newSign = this._sign === 1 ? -1 : 1;
+    return new _BigNumber(newSign, this._coefficient, this._exponent, false, this._isInfinite);
+  }
+  /**
+   * Absolute value
+   */
+  abs() {
+    if (this._isNaN) return this;
+    if (this._sign === 0) return this;
+    return new _BigNumber(1, this._coefficient, this._exponent, false, this._isInfinite);
+  }
+  /**
+   * Power (integer exponent)
+   */
+  pow(n) {
+    const exp = typeof n === "bigint" ? Number(n) : n;
+    if (this._isNaN) return this;
+    if (exp === 0) return _BigNumber.fromNumber(1);
+    if (this._sign === 0) {
+      if (exp < 0) return new _BigNumber(1, 0n, 0, false, true);
+      return this;
+    }
+    if (exp < 0) {
+      return _BigNumber.fromNumber(1).divide(this.pow(-exp));
+    }
+    let result = _BigNumber.fromNumber(1);
+    let base = this;
+    let e = exp;
+    while (e > 0) {
+      if (e % 2 === 1) {
+        result = result.multiply(base);
+      }
+      base = base.multiply(base);
+      e = Math.floor(e / 2);
+    }
+    return result.roundToPrecision(globalConfig.precision);
+  }
+  /**
+   * Square root
+   */
+  sqrt() {
+    if (this._isNaN) return this;
+    if (this._sign === -1) return new _BigNumber(0, 0n, 0, true);
+    if (this._sign === 0) return this;
+    if (this._isInfinite) return this;
+    const precision = globalConfig.precision;
+    let guess = _BigNumber.fromNumber(Math.sqrt(this.valueOf()));
+    for (let i = 0; i < 100; i++) {
+      const newGuess = guess.add(this.divide(guess)).divide(_BigNumber.fromNumber(2));
+      if (guess.subtract(newGuess).abs().compareTo(guess.multiply(_BigNumber.parse("1e-" + (precision + 5)))) <= 0) {
+        return newGuess.roundToPrecision(precision);
+      }
+      guess = newGuess;
+    }
+    return guess.roundToPrecision(precision);
+  }
+  // ============================================================
+  // Comparison Methods
+  // ============================================================
+  equals(other) {
+    return _BigNumber.compare(this, other) === 0;
+  }
+  lessThan(other) {
+    return _BigNumber.compare(this, other) < 0;
+  }
+  lessThanOrEqual(other) {
+    return _BigNumber.compare(this, other) <= 0;
+  }
+  greaterThan(other) {
+    return _BigNumber.compare(this, other) > 0;
+  }
+  greaterThanOrEqual(other) {
+    return _BigNumber.compare(this, other) >= 0;
+  }
+  compareTo(other) {
+    return _BigNumber.compare(this, other);
+  }
+  compare(other) {
+    return this.compareTo(other);
+  }
+  // ============================================================
+  // Rounding Methods
+  // ============================================================
+  /**
+   * Round to specified decimal places
+   */
+  round(decimalPlaces = 0, mode = globalConfig.rounding) {
+    if (this._isNaN || this._isInfinite || this._sign === 0) return this;
+    const targetExp = -decimalPlaces;
+    if (this._exponent >= targetExp) return this;
+    const shift = targetExp - this._exponent;
+    const divisor = BigInt(10) ** BigInt(shift);
+    const quotient = this._coefficient / divisor;
+    const remainder = this._coefficient % divisor;
+    let rounded = quotient;
+    const halfDivisor = divisor / 2n;
+    const shouldRoundUp = this.shouldRound(remainder, halfDivisor, divisor, quotient, mode);
+    if (shouldRoundUp) {
+      rounded += 1n;
+    }
+    return this.normalize(rounded === 0n ? 0 : this._sign, rounded, targetExp);
+  }
+  shouldRound(remainder, halfDivisor, divisor, quotient, mode) {
+    const isPositive = this._sign === 1;
+    const isExactlyHalf = remainder === halfDivisor && divisor % 2n === 0n;
+    const isMoreThanHalf = remainder > halfDivisor;
+    switch (mode) {
+      case "up":
+        return remainder > 0n;
+      case "down":
+        return false;
+      case "ceil":
+        return isPositive && remainder > 0n;
+      case "floor":
+        return !isPositive && remainder > 0n;
+      case "halfUp":
+        return isMoreThanHalf || isExactlyHalf;
+      case "halfDown":
+        return isMoreThanHalf;
+      case "halfEven":
+        return isMoreThanHalf || isExactlyHalf && quotient % 2n !== 0n;
+      case "halfCeil":
+        return isMoreThanHalf || isExactlyHalf && isPositive;
+      case "halfFloor":
+        return isMoreThanHalf || isExactlyHalf && !isPositive;
+      default:
+        return isMoreThanHalf || isExactlyHalf;
+    }
+  }
+  /**
+   * Round to specified precision (significant digits)
+   */
+  roundToPrecision(precision, mode = globalConfig.rounding) {
+    if (this._isNaN || this._isInfinite || this._sign === 0) return this;
+    const digits = this._coefficient.toString();
+    if (digits.length <= precision) return this;
+    const digitsToRemove = digits.length - precision;
+    const divisor = BigInt(10) ** BigInt(digitsToRemove);
+    const quotient = this._coefficient / divisor;
+    const remainder = this._coefficient % divisor;
+    const halfDivisor = divisor / 2n;
+    let rounded = quotient;
+    const shouldRoundUp = this.shouldRound(remainder, halfDivisor, divisor, quotient, mode);
+    if (shouldRoundUp) {
+      rounded += 1n;
+    }
+    const newExponent = this._exponent + digitsToRemove;
+    return this.normalize(rounded === 0n ? 0 : this._sign, rounded, newExponent);
+  }
+  floor() {
+    return this.round(0, "floor");
+  }
+  ceil() {
+    return this.round(0, "ceil");
+  }
+  trunc() {
+    return this.round(0, "down");
+  }
+  // ============================================================
+  // Modular Arithmetic
+  // ============================================================
+  /**
+   * Modulo (remainder after division)
+   * Result has the same sign as the dividend (this).
+   */
+  mod(other) {
+    const b = this.ensureBigNumber(other);
+    if (this._isNaN || b._isNaN || b._sign === 0) return new _BigNumber(0, 0n, 0, true);
+    if (this._isInfinite) return new _BigNumber(0, 0n, 0, true);
+    if (b._isInfinite) return this;
+    if (this._sign === 0) return this;
+    const quotient = this.divide(b).trunc();
+    return this.subtract(b.multiply(quotient));
+  }
+  // ============================================================
+  // Trigonometric Functions
+  // ============================================================
+  /**
+   * Sine of this BigNumber (in radians)
+   * Uses Taylor series: sin(x) = x - x^3/3! + x^5/5! - ...
+   */
+  sin() {
+    if (this._isNaN) return this;
+    if (this._isInfinite) return new _BigNumber(0, 0n, 0, true);
+    if (this._sign === 0) return this;
+    const x = this._reduceAngle();
+    return x._sinTaylor();
+  }
+  /**
+   * Cosine of this BigNumber (in radians)
+   * Uses Taylor series: cos(x) = 1 - x^2/2! + x^4/4! - ...
+   */
+  cos() {
+    if (this._isNaN) return this;
+    if (this._isInfinite) return new _BigNumber(0, 0n, 0, true);
+    if (this._sign === 0) return _BigNumber.fromNumber(1);
+    const x = this._reduceAngle();
+    return x._cosTaylor();
+  }
+  /**
+   * Tangent of this BigNumber (in radians)
+   * tan(x) = sin(x) / cos(x)
+   */
+  tan() {
+    if (this._isNaN) return this;
+    if (this._isInfinite) return new _BigNumber(0, 0n, 0, true);
+    if (this._sign === 0) return this;
+    const x = this._reduceAngle();
+    return x._sinTaylor().divide(x._cosTaylor());
+  }
+  /**
+   * Arcsine of this BigNumber
+   * Returns value in [-PI/2, PI/2]
+   */
+  asin() {
+    if (this._isNaN) return this;
+    const one = _BigNumber.fromNumber(1);
+    if (this.abs().compareTo(one) > 0) return new _BigNumber(0, 0n, 0, true);
+    if (this._sign === 0) return this;
+    const xSquared = this.multiply(this);
+    const denominator = one.subtract(xSquared).sqrt();
+    if (denominator.isZero()) {
+      return this._sign === 1 ? BIGNUMBER_PI.divide(2) : BIGNUMBER_PI.divide(-2);
+    }
+    return this.divide(denominator).atan();
+  }
+  /**
+   * Arccosine of this BigNumber
+   * Returns value in [0, PI]
+   */
+  acos() {
+    if (this._isNaN) return this;
+    const one = _BigNumber.fromNumber(1);
+    if (this.abs().compareTo(one) > 0) return new _BigNumber(0, 0n, 0, true);
+    return BIGNUMBER_PI.divide(2).subtract(this.asin());
+  }
+  /**
+   * Arctangent of this BigNumber
+   * Returns value in (-PI/2, PI/2)
+   * Uses Taylor series with argument reduction for convergence.
+   */
+  atan() {
+    if (this._isNaN) return this;
+    if (this._sign === 0) return this;
+    if (this._isInfinite) {
+      return this._sign === 1 ? BIGNUMBER_PI.divide(2) : BIGNUMBER_PI.divide(-2);
+    }
+    const one = _BigNumber.fromNumber(1);
+    if (this.abs().compareTo(one) > 0) {
+      const reciprocal = one.divide(this);
+      const piHalf = BIGNUMBER_PI.divide(2);
+      return this._sign === 1 ? piHalf.subtract(reciprocal.atan()) : piHalf.negate().subtract(reciprocal.atan());
+    }
+    const half = _BigNumber.fromNumber(0.5);
+    if (this.abs().compareTo(half) > 0) {
+      const xSq = this.multiply(this);
+      const reduced = this.divide(one.add(one.add(xSq).sqrt()));
+      return reduced.atan().multiply(_BigNumber.fromNumber(2));
+    }
+    return this._atanTaylor();
+  }
+  /**
+   * Two-argument arctangent: atan2(y, x)
+   * this = y, argument = x
+   * Returns angle in (-PI, PI]
+   */
+  atan2(x) {
+    if (this._isNaN || x._isNaN) return new _BigNumber(0, 0n, 0, true);
+    if (this._sign === 0 && x._sign === 0) return _BigNumber.fromNumber(0);
+    if (x._sign === 0) {
+      return this._sign === 1 ? BIGNUMBER_PI.divide(2) : BIGNUMBER_PI.divide(-2);
+    }
+    const angle = this.divide(x).atan();
+    if (x.isPositive()) {
+      return angle;
+    } else if (this.isNegative()) {
+      return angle.subtract(BIGNUMBER_PI);
+    } else {
+      return angle.add(BIGNUMBER_PI);
+    }
+  }
+  // ============================================================
+  // Hyperbolic Functions
+  // ============================================================
+  /**
+   * Hyperbolic sine: sinh(x) = (e^x - e^(-x)) / 2
+   */
+  sinh() {
+    if (this._isNaN) return this;
+    if (this._isInfinite) return this;
+    if (this._sign === 0) return this;
+    const ex = this.exp();
+    const enx = this.negate().exp();
+    return ex.subtract(enx).divide(_BigNumber.fromNumber(2));
+  }
+  /**
+   * Hyperbolic cosine: cosh(x) = (e^x + e^(-x)) / 2
+   */
+  cosh() {
+    if (this._isNaN) return this;
+    if (this._isInfinite) return new _BigNumber(1, 0n, 0, false, true);
+    if (this._sign === 0) return _BigNumber.fromNumber(1);
+    const ex = this.exp();
+    const enx = this.negate().exp();
+    return ex.add(enx).divide(_BigNumber.fromNumber(2));
+  }
+  /**
+   * Hyperbolic tangent: tanh(x) = sinh(x) / cosh(x)
+   */
+  tanh() {
+    if (this._isNaN) return this;
+    if (this._sign === 0) return this;
+    if (this._isInfinite) return _BigNumber.fromNumber(this._sign);
+    const ex = this.exp();
+    const enx = this.negate().exp();
+    return ex.subtract(enx).divide(ex.add(enx));
+  }
+  /**
+   * Inverse hyperbolic sine: asinh(x) = ln(x + sqrt(x^2 + 1))
+   */
+  asinh() {
+    if (this._isNaN) return this;
+    if (this._isInfinite) return this;
+    if (this._sign === 0) return this;
+    const one = _BigNumber.fromNumber(1);
+    return this.add(this.multiply(this).add(one).sqrt()).ln();
+  }
+  /**
+   * Inverse hyperbolic cosine: acosh(x) = ln(x + sqrt(x^2 - 1))
+   * Domain: x >= 1
+   */
+  acosh() {
+    if (this._isNaN) return this;
+    const one = _BigNumber.fromNumber(1);
+    if (this.compareTo(one) < 0) return new _BigNumber(0, 0n, 0, true);
+    if (this._isInfinite) return this;
+    return this.add(this.multiply(this).subtract(one).sqrt()).ln();
+  }
+  /**
+   * Inverse hyperbolic tangent: atanh(x) = 0.5 * ln((1+x)/(1-x))
+   * Domain: -1 < x < 1
+   */
+  atanh() {
+    if (this._isNaN) return this;
+    const one = _BigNumber.fromNumber(1);
+    const absVal = this.abs();
+    if (absVal.compareTo(one) > 0) return new _BigNumber(0, 0n, 0, true);
+    if (absVal.equals(one)) {
+      return this._sign === 1 ? new _BigNumber(1, 0n, 0, false, true) : new _BigNumber(-1, 0n, 0, false, true);
+    }
+    if (this._sign === 0) return this;
+    const half = _BigNumber.fromNumber(0.5);
+    return one.add(this).divide(one.subtract(this)).ln().multiply(half);
+  }
+  // ============================================================
+  // Transcendental Functions
+  // ============================================================
+  /**
+   * Exponential function: e^x
+   * Uses Taylor series: e^x = 1 + x + x^2/2! + x^3/3! + ...
+   * With argument reduction: e^x = (e^(x/2^k))^(2^k) for faster convergence.
+   */
+  exp() {
+    if (this._isNaN) return this;
+    if (this._sign === 0) return _BigNumber.fromNumber(1);
+    if (this._isInfinite) {
+      return this._sign === 1 ? this : _BigNumber.fromNumber(0);
+    }
+    const precision = globalConfig.precision;
+    const val = Math.abs(this.valueOf());
+    let k = 0;
+    if (val > 0.5) {
+      k = Math.ceil(Math.log2(val * 2));
+    }
+    const divisor = _BigNumber.fromNumber(2 ** k);
+    const reduced = this.divide(divisor);
+    let sum = _BigNumber.fromNumber(1);
+    let term = _BigNumber.fromNumber(1);
+    const maxIter = precision + 20;
+    for (let n = 1; n <= maxIter; n++) {
+      term = term.multiply(reduced).divide(_BigNumber.fromNumber(n));
+      const newSum = sum.add(term);
+      if (sum.equals(newSum)) break;
+      sum = newSum;
+    }
+    for (let i = 0; i < k; i++) {
+      sum = sum.multiply(sum);
+    }
+    return sum.roundToPrecision(precision);
+  }
+  /**
+   * Natural logarithm: ln(x)
+   * Uses the AGM (arithmetic-geometric mean) method for fast convergence.
+   * Fallback: series ln((1+y)/(1-y)) = 2*(y + y^3/3 + y^5/5 + ...) where y = (x-1)/(x+1)
+   */
+  ln() {
+    if (this._isNaN) return this;
+    if (this._sign === -1) return new _BigNumber(0, 0n, 0, true);
+    if (this._sign === 0) return new _BigNumber(-1, 0n, 0, false, true);
+    if (this._isInfinite) return this;
+    const one = _BigNumber.fromNumber(1);
+    if (this.equals(one)) return _BigNumber.fromNumber(0);
+    const precision = globalConfig.precision;
+    let x = this.clone();
+    let k = 0;
+    const two = _BigNumber.fromNumber(2);
+    const half = _BigNumber.fromNumber(0.5);
+    while (x.compareTo(two) > 0) {
+      x = x.divide(two);
+      k++;
+    }
+    while (x.compareTo(half) < 0) {
+      x = x.multiply(two);
+      k--;
+    }
+    const y = x.subtract(one).divide(x.add(one));
+    const ySq = y.multiply(y);
+    let term = y;
+    let sum = y;
+    const maxIter = precision + 20;
+    for (let n = 1; n <= maxIter; n++) {
+      term = term.multiply(ySq);
+      const contribution = term.divide(_BigNumber.fromNumber(2 * n + 1));
+      const newSum = sum.add(contribution);
+      if (sum.equals(newSum)) break;
+      sum = newSum;
+    }
+    sum = sum.multiply(two);
+    if (k !== 0) {
+      sum = sum.add(BIGNUMBER_LN2.multiply(_BigNumber.fromNumber(k)));
+    }
+    return sum.roundToPrecision(precision);
+  }
+  /**
+   * Base-10 logarithm: log10(x) = ln(x) / ln(10)
+   */
+  log10() {
+    return this.ln().divide(BIGNUMBER_LN10);
+  }
+  /**
+   * Base-2 logarithm: log2(x) = ln(x) / ln(2)
+   */
+  log2() {
+    return this.ln().divide(BIGNUMBER_LN2);
+  }
+  /**
+   * Cube root
+   * Uses Newton-Raphson iteration.
+   */
+  cbrt() {
+    if (this._isNaN) return this;
+    if (this._sign === 0) return this;
+    if (this._isInfinite) return this;
+    if (this._sign === -1) {
+      return this.negate().cbrt().negate();
+    }
+    const precision = globalConfig.precision;
+    const three = _BigNumber.fromNumber(3);
+    let guess = _BigNumber.fromNumber(Math.cbrt(this.valueOf()));
+    for (let i = 0; i < 100; i++) {
+      const guessSquared = guess.multiply(guess);
+      const newGuess = guess.multiply(_BigNumber.fromNumber(2)).add(this.divide(guessSquared)).divide(three);
+      if (guess.subtract(newGuess).abs().compareTo(
+        guess.abs().multiply(_BigNumber.parse("1e-" + (precision + 5)))
+      ) <= 0) {
+        return newGuess.roundToPrecision(precision);
+      }
+      guess = newGuess;
+    }
+    return guess.roundToPrecision(precision);
+  }
+  /**
+   * e^x - 1 (more precise than exp(x) - 1 for small x)
+   * Uses Taylor series directly: expm1(x) = x + x^2/2! + x^3/3! + ...
+   */
+  expm1() {
+    if (this._isNaN) return this;
+    if (this._sign === 0) return this;
+    if (this._isInfinite) {
+      return this._sign === 1 ? this : _BigNumber.fromNumber(-1);
+    }
+    if (Math.abs(this.valueOf()) > 0.5) {
+      return this.exp().subtract(_BigNumber.fromNumber(1));
+    }
+    const precision = globalConfig.precision;
+    let term = this.clone();
+    let sum = this.clone();
+    const maxIter = precision + 20;
+    for (let n = 2; n <= maxIter; n++) {
+      term = term.multiply(this).divide(_BigNumber.fromNumber(n));
+      const newSum = sum.add(term);
+      if (sum.equals(newSum)) break;
+      sum = newSum;
+    }
+    return sum.roundToPrecision(precision);
+  }
+  /**
+   * ln(1 + x) (more precise than ln(1 + x) for small x)
+   */
+  log1p() {
+    if (this._isNaN) return this;
+    const one = _BigNumber.fromNumber(1);
+    const negOne = _BigNumber.fromNumber(-1);
+    if (this.compareTo(negOne) < 0) return new _BigNumber(0, 0n, 0, true);
+    if (this.equals(negOne)) return new _BigNumber(-1, 0n, 0, false, true);
+    if (this._sign === 0) return this;
+    return one.add(this).ln();
+  }
+  /**
+   * Hypotenuse: sqrt(this^2 + other^2)
+   */
+  hypot(other) {
+    if (this._isNaN || other._isNaN) return new _BigNumber(0, 0n, 0, true);
+    if (this._isInfinite || other._isInfinite) return new _BigNumber(1, 0n, 0, false, true);
+    return this.multiply(this).add(other.multiply(other)).sqrt();
+  }
+  // ============================================================
+  // Private Taylor Series Helpers
+  // ============================================================
+  /** Reduce angle to [-PI, PI] range */
+  _reduceAngle() {
+    const twoPi = BIGNUMBER_PI.multiply(_BigNumber.fromNumber(2));
+    if (this.abs().compareTo(BIGNUMBER_PI) <= 0) {
+      return this;
+    }
+    const quotient = this.divide(twoPi).round(0, "halfUp");
+    let reduced = this.subtract(twoPi.multiply(quotient));
+    if (reduced.compareTo(BIGNUMBER_PI) > 0) {
+      reduced = reduced.subtract(twoPi);
+    } else if (reduced.compareTo(BIGNUMBER_PI.negate()) < 0) {
+      reduced = reduced.add(twoPi);
+    }
+    return reduced;
+  }
+  /** Taylor series for sin(x), assumes x is in [-PI, PI] */
+  _sinTaylor() {
+    const precision = globalConfig.precision;
+    let term = this.clone();
+    let sum = this.clone();
+    const xSquared = this.multiply(this);
+    const maxIter = precision + 20;
+    for (let n = 1; n <= maxIter; n++) {
+      term = term.multiply(xSquared).divide(
+        _BigNumber.fromNumber(2 * n * (2 * n + 1))
+      ).negate();
+      const newSum = sum.add(term);
+      if (sum.equals(newSum)) break;
+      sum = newSum;
+    }
+    return sum.roundToPrecision(precision);
+  }
+  /** Taylor series for cos(x), assumes x is in [-PI, PI] */
+  _cosTaylor() {
+    const precision = globalConfig.precision;
+    let term = _BigNumber.fromNumber(1);
+    let sum = _BigNumber.fromNumber(1);
+    const xSquared = this.multiply(this);
+    const maxIter = precision + 20;
+    for (let n = 1; n <= maxIter; n++) {
+      term = term.multiply(xSquared).divide(
+        _BigNumber.fromNumber((2 * n - 1) * (2 * n))
+      ).negate();
+      const newSum = sum.add(term);
+      if (sum.equals(newSum)) break;
+      sum = newSum;
+    }
+    return sum.roundToPrecision(precision);
+  }
+  /** Taylor series for atan(x), assumes |x| <= 0.5 */
+  _atanTaylor() {
+    const precision = globalConfig.precision;
+    const xSquared = this.multiply(this);
+    let term = this.clone();
+    let sum = this.clone();
+    const maxIter = precision + 20;
+    for (let n = 1; n <= maxIter; n++) {
+      term = term.multiply(xSquared).negate();
+      const contribution = term.divide(_BigNumber.fromNumber(2 * n + 1));
+      const newSum = sum.add(contribution);
+      if (sum.equals(newSum)) break;
+      sum = newSum;
+    }
+    return sum.roundToPrecision(precision);
+  }
+  // ============================================================
+  // Utility Methods
+  // ============================================================
+  isNaN() {
+    return this._isNaN;
+  }
+  isFinite() {
+    return !this._isNaN && !this._isInfinite;
+  }
+  isInfinite() {
+    return this._isInfinite;
+  }
+  isZero() {
+    return this._sign === 0 && !this._isNaN;
+  }
+  isPositive() {
+    return this._sign === 1;
+  }
+  isNegative() {
+    return this._sign === -1;
+  }
+  isInteger() {
+    if (this._isNaN || this._isInfinite || this._sign === 0) return this._sign === 0;
+    return this._exponent >= 0;
+  }
+  sign() {
+    return this._sign;
+  }
+  clone() {
+    return new _BigNumber(this._sign, this._coefficient, this._exponent, this._isNaN, this._isInfinite);
+  }
+  // ============================================================
+  // Private Helper Methods
+  // ============================================================
+  ensureBigNumber(value) {
+    if (value instanceof _BigNumber) return value;
+    if (typeof value === "number") return _BigNumber.fromNumber(value);
+    if (typeof value === "string") return _BigNumber.parse(value);
+    return _BigNumber.fromNumber(Number(value.valueOf()));
+  }
+  alignExponents(a, b) {
+    const minExp = Math.min(a._exponent, b._exponent);
+    const aShift = a._exponent - minExp;
+    const bShift = b._exponent - minExp;
+    const aCoef = aShift > 0 ? a._coefficient * BigInt(10) ** BigInt(aShift) : a._coefficient;
+    const bCoef = bShift > 0 ? b._coefficient * BigInt(10) ** BigInt(bShift) : b._coefficient;
+    return [aCoef, bCoef, minExp];
+  }
+  normalize(sign, coefficient, exponent) {
+    if (coefficient === 0n) {
+      return new _BigNumber(0, 0n, 0);
+    }
+    let coef = coefficient;
+    let exp = exponent;
+    while (coef % 10n === 0n && coef !== 0n) {
+      coef = coef / 10n;
+      exp++;
+    }
+    return new _BigNumber(sign, coef, exp);
+  }
+};
+var BIGNUMBER_ZERO = BigNumber.fromNumber(0);
+var BIGNUMBER_ONE = BigNumber.fromNumber(1);
+var BIGNUMBER_NEG_ONE = BigNumber.fromNumber(-1);
+var BIGNUMBER_TEN = BigNumber.fromNumber(10);
+var BIGNUMBER_PI = BigNumber.parse("3.14159265358979323846264338327950288419716939937510");
+var BIGNUMBER_E = BigNumber.parse("2.71828182845904523536028747135266249775724709369995");
+var BIGNUMBER_LN2 = BigNumber.parse("0.69314718055994530941723212145817656807550013436026");
+var BIGNUMBER_LN10 = BigNumber.parse("2.30258509299404568401799145468436420760110148862877");
+
+// src/typed/mathts-typed.ts
+import typed, { create } from "typed-function";
+var wasmInitialized = false;
+var wasmAvailable = false;
+async function initTypedWasm(options = {}) {
+  if (wasmInitialized) return wasmAvailable;
+  try {
+    if (typeof typed.init === "function") {
+      await typed.init({ preferWasm: options.preferWasm ?? true });
+      wasmAvailable = typed.isWasmEnabled?.() ?? false;
+    }
+  } catch {
+    wasmAvailable = false;
+  }
+  wasmInitialized = true;
+  return wasmAvailable;
+}
+function isTypedWasmAvailable() {
+  return typed.isWasmEnabled?.() ?? wasmAvailable;
+}
+var isNumber = (x) => typeof x === "number";
+var isBoolean = (x) => typeof x === "boolean";
+var isString = (x) => typeof x === "string";
+var isBigInt = (x) => typeof x === "bigint";
+var isArray = (x) => Array.isArray(x);
+var isFunction = (x) => typeof x === "function";
+var isObject = (x) => typeof x === "object" && x !== null && !Array.isArray(x);
+var isNull = (x) => x === null;
+var isUndefined = (x) => x === void 0;
+var isFloat64Array = (x) => x instanceof Float64Array;
+var isFloat32Array = (x) => x instanceof Float32Array;
+var isInt32Array = (x) => x instanceof Int32Array;
+var isUint32Array = (x) => x instanceof Uint32Array;
+var isUint8Array = (x) => x instanceof Uint8Array;
+var isComplex2 = (x) => isComplex(x);
+var isFraction2 = (x) => isFraction(x);
+var isBigNumber2 = (x) => isBigNumber(x);
+var isMatrix = (x) => isObject(x) && "rows" in x && "cols" in x && "get" in x && typeof x.type === "string";
+var isDenseMatrix = (x) => isMatrix(x) && x.type === "DenseMatrix";
+var isSparseMatrix = (x) => isMatrix(x) && x.type === "SparseMatrix";
+var isUnit = (x) => isObject(x) && "value" in x && "unit" in x && typeof x.type === "string";
+var MATHTS_TYPES = [
+  // bigint is not built into typed-function
+  { name: "bigint", test: isBigInt },
+  // MathTS numeric types (ordered by specificity for conversion priority)
+  // WASM masks use typed.masks.OBJECT | typed.masks.custom(N) pattern
+  { name: "Complex", test: isComplex2 },
+  { name: "Fraction", test: isFraction2 },
+  { name: "BigNumber", test: isBigNumber2 },
+  // TypedArrays (for parallel-first WASM operations)
+  { name: "Float64Array", test: isFloat64Array },
+  { name: "Float32Array", test: isFloat32Array },
+  { name: "Int32Array", test: isInt32Array },
+  { name: "Uint32Array", test: isUint32Array },
+  { name: "Uint8Array", test: isUint8Array },
+  // Matrix types
+  { name: "DenseMatrix", test: isDenseMatrix },
+  { name: "SparseMatrix", test: isSparseMatrix },
+  { name: "Matrix", test: isMatrix },
+  // Other types
+  { name: "Unit", test: isUnit }
+];
+var MATHTS_CONVERSIONS = [
+  // -------------------------------------------------------------------------
+  // To Complex conversions
+  // -------------------------------------------------------------------------
+  {
+    from: "number",
+    to: "Complex",
+    convert: (n) => Complex.fromNumber(n)
+  },
+  {
+    from: "Fraction",
+    to: "Complex",
+    convert: (f) => Complex.fromNumber(f.toNumber())
+  },
+  {
+    from: "BigNumber",
+    to: "Complex",
+    convert: (bn) => Complex.fromNumber(bn.valueOf())
+  },
+  {
+    from: "string",
+    to: "Complex",
+    convert: (s) => Complex.parse(s)
+  },
+  // -------------------------------------------------------------------------
+  // To Fraction conversions
+  // -------------------------------------------------------------------------
+  {
+    from: "number",
+    to: "Fraction",
+    convert: (n) => Fraction.fromNumber(n)
+  },
+  {
+    from: "bigint",
+    to: "Fraction",
+    convert: (n) => new Fraction(n, 1n)
+  },
+  {
+    from: "string",
+    to: "Fraction",
+    convert: (s) => Fraction.parse(s)
+  },
+  // -------------------------------------------------------------------------
+  // To BigNumber conversions
+  // -------------------------------------------------------------------------
+  {
+    from: "number",
+    to: "BigNumber",
+    convert: (n) => BigNumber.fromNumber(n)
+  },
+  {
+    from: "bigint",
+    to: "BigNumber",
+    convert: (n) => BigNumber.fromBigInt(n)
+  },
+  {
+    from: "Fraction",
+    to: "BigNumber",
+    convert: (f) => BigNumber.fromNumber(f.toNumber())
+  },
+  {
+    from: "string",
+    to: "BigNumber",
+    convert: (s) => BigNumber.parse(s)
+  },
+  // -------------------------------------------------------------------------
+  // To number conversions
+  // -------------------------------------------------------------------------
+  {
+    from: "boolean",
+    to: "number",
+    convert: (b) => b ? 1 : 0
+  },
+  {
+    from: "string",
+    to: "number",
+    convert: (s) => {
+      const n = parseFloat(s);
+      if (isNaN(n)) throw new Error(`Cannot convert "${s}" to number`);
+      return n;
+    }
+  },
+  {
+    from: "bigint",
+    to: "number",
+    convert: (n) => Number(n)
+  },
+  {
+    from: "Fraction",
+    to: "number",
+    convert: (f) => f.toNumber()
+  },
+  {
+    from: "BigNumber",
+    to: "number",
+    convert: (bn) => bn.valueOf()
+  },
+  // -------------------------------------------------------------------------
+  // To bigint conversions
+  // -------------------------------------------------------------------------
+  {
+    from: "number",
+    to: "bigint",
+    convert: (n) => BigInt(Math.trunc(n))
+  },
+  {
+    from: "Fraction",
+    to: "bigint",
+    convert: (f) => f.trunc().numerator
+  },
+  {
+    from: "BigNumber",
+    to: "bigint",
+    convert: (bn) => bn.toBigInt()
+  },
+  {
+    from: "string",
+    to: "bigint",
+    convert: (s) => BigInt(s)
+  },
+  // -------------------------------------------------------------------------
+  // Matrix conversions (placeholder until Matrix is implemented)
+  // -------------------------------------------------------------------------
+  {
+    from: "Array",
+    to: "Matrix",
+    convert: (a) => {
+      const arr = a;
+      return {
+        rows: arr.length,
+        cols: arr[0]?.length ?? 0,
+        data: arr.flat(),
+        type: "DenseMatrix",
+        get: (r, c) => arr[r]?.[c]
+      };
+    }
+  },
+  {
+    from: "Matrix",
+    to: "Array",
+    convert: (m) => {
+      const matrix = m;
+      const result = [];
+      for (let i = 0; i < matrix.rows; i++) {
+        result[i] = [];
+        for (let j = 0; j < matrix.cols; j++) {
+          result[i][j] = matrix.get(i, j);
+        }
+      }
+      return result;
+    }
+  },
+  {
+    from: "DenseMatrix",
+    to: "SparseMatrix",
+    convert: (m) => {
+      return { ...m, type: "SparseMatrix" };
+    }
+  }
+];
+function createMathTSTyped() {
+  const instance = create();
+  if (typeof instance.addType === "function") {
+    for (const typeDef of MATHTS_TYPES) {
+      instance.addType(typeDef);
+    }
+  } else {
+    instance.addTypes(MATHTS_TYPES, "any");
+  }
+  instance.addConversions(MATHTS_CONVERSIONS);
+  return instance;
+}
+var mathTyped = createMathTSTyped();
+var TypeRegistry = class {
+  types = /* @__PURE__ */ new Map();
+  conversions = /* @__PURE__ */ new Map();
+  instance = null;
+  /**
+   * Register a new type
+   */
+  registerType(name, test) {
+    this.types.set(name, { name, test });
+    this.instance = null;
+    return this;
+  }
+  /**
+   * Register a type conversion
+   */
+  registerConversion(from, to, convert) {
+    const key = `${from}->${to}`;
+    this.conversions.set(key, {
+      from,
+      to,
+      convert
+    });
+    this.instance = null;
+    return this;
+  }
+  /**
+   * Check if a type is registered
+   */
+  hasType(name) {
+    return this.types.has(name);
+  }
+  /**
+   * Check if a conversion is registered
+   */
+  hasConversion(from, to) {
+    return this.conversions.has(`${from}->${to}`);
+  }
+  /**
+   * Get all registered type names
+   */
+  getTypeNames() {
+    return Array.from(this.types.keys());
+  }
+  /**
+   * Build a typed-function instance from the registry
+   */
+  build() {
+    if (!this.instance) {
+      const inst = create();
+      inst.addTypes(Array.from(this.types.values()), "any");
+      inst.addConversions(Array.from(this.conversions.values()));
+      this.instance = inst;
+    }
+    return this.instance;
+  }
+  /**
+   * Clear all registered types and conversions
+   */
+  clear() {
+    this.types.clear();
+    this.conversions.clear();
+    this.instance = null;
+  }
+};
+function createTypedFunction(name, signatures, typedInstance = mathTyped) {
+  return typedInstance(name, signatures);
+}
+
+// src/typed/type-bridge.ts
+var registered = false;
+function registerNativeTypes() {
+  if (registered) return;
+  registered = true;
+  if (!("isComplex" in Complex.prototype)) {
+    Object.defineProperty(Complex.prototype, "isComplex", {
+      value: true,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  if (!("type" in Complex.prototype)) {
+    Object.defineProperty(Complex.prototype, "type", {
+      value: "Complex",
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  if (!("isFraction" in Fraction.prototype)) {
+    Object.defineProperty(Fraction.prototype, "isFraction", {
+      value: true,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  if (!("type" in Fraction.prototype)) {
+    Object.defineProperty(Fraction.prototype, "type", {
+      value: "Fraction",
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  if (!("isBigNumber" in BigNumber.prototype)) {
+    Object.defineProperty(BigNumber.prototype, "isBigNumber", {
+      value: true,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  if (!("type" in BigNumber.prototype)) {
+    Object.defineProperty(BigNumber.prototype, "type", {
+      value: "BigNumber",
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+}
+
+// src/factory/factory.ts
+var DEFAULT_CONFIG = {
+  precision: 64,
+  matrix: "Matrix",
+  number: "number",
+  randomSeed: null,
+  epsilon: 1e-12,
+  preferredBackend: "auto",
+  wasmThreshold: 1e3,
+  gpuThreshold: 1e5,
+  parallelEnabled: true,
+  parallelThreshold: 5e4
+};
+var FunctionRegistry = class {
+  factories = /* @__PURE__ */ new Map();
+  instances = /* @__PURE__ */ new Map();
+  dependencies;
+  creating = /* @__PURE__ */ new Set();
+  constructor(config = {}, typed2 = mathTyped) {
+    this.dependencies = {
+      config: { ...DEFAULT_CONFIG, ...config },
+      typed: typed2
+    };
+  }
+  /**
+   * Register a factory function
+   */
+  register(factory) {
+    this.factories.set(factory.name, factory);
+  }
+  /**
+   * Register multiple factory functions
+   */
+  registerAll(factories) {
+    for (const factory of factories) {
+      this.register(factory);
+    }
+  }
+  /**
+   * Get or create a function by name
+   */
+  get(name) {
+    const existing = this.instances.get(name);
+    if (existing) return existing;
+    if (this.creating.has(name)) {
+      throw new Error(`Circular dependency detected: ${name}`);
+    }
+    const factory = this.factories.get(name);
+    if (!factory) {
+      throw new Error(`Unknown function: ${name}`);
+    }
+    this.creating.add(name);
+    try {
+      const deps = { ...this.dependencies };
+      for (const depName of factory.dependencies) {
+        if (depName === "config" || depName === "typed") continue;
+        deps[depName] = this.get(depName);
+      }
+      const fn = factory.factory(deps);
+      this.instances.set(name, fn);
+      this.dependencies[name] = fn;
+      return fn;
+    } finally {
+      this.creating.delete(name);
+    }
+  }
+  /**
+   * Check if a function is registered
+   */
+  has(name) {
+    return this.factories.has(name);
+  }
+  /**
+   * Get all registered function names
+   */
+  names() {
+    return Array.from(this.factories.keys());
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(config) {
+    this.dependencies.config = { ...this.dependencies.config, ...config };
+    this.instances.clear();
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.dependencies.config };
+  }
+};
+function createFactory(name, dependencies, factory) {
+  return { name, dependencies, factory };
+}
+var registry = new FunctionRegistry();
+var math = {
+  /**
+   * Get a registered function
+   */
+  get: (name) => registry.get(name),
+  /**
+   * Register a factory function
+   */
+  register: (factory) => registry.register(factory),
+  /**
+   * Get configuration
+   */
+  config: () => registry.getConfig(),
+  /**
+   * Update configuration
+   */
+  configure: (config) => registry.updateConfig(config)
+};
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  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,
+  FRACTION_HALF,
+  FRACTION_NEG_ONE,
+  FRACTION_ONE,
+  FRACTION_QUARTER,
+  FRACTION_THIRD,
+  FRACTION_ZERO,
+  Fraction,
+  FunctionRegistry,
+  I,
+  MATHTS_CONVERSIONS,
+  MATHTS_TYPES,
+  TypeRegistry,
+  VERSION,
+  create,
+  createFactory,
+  createMathTSTyped,
+  createTypedFunction,
+  initTypedWasm,
+  isArray,
+  isBigInt,
+  isBigNumber,
+  isBoolean,
+  isComplex,
+  isDenseMatrix,
+  isFraction,
+  isFunction,
+  isMatrix,
+  isNull,
+  isNumber,
+  isObject,
+  isSparseMatrix,
+  isString,
+  isTypedWasmAvailable,
+  isUndefined,
+  isUnit,
+  math,
+  mathTyped,
+  registerNativeTypes,
+  registry,
+  typed
+};