@danielsimonjr/mathts-core 0.5.0 → 0.6.0

package/dist/{chunk-BDNTTHO4.js → chunk-AMOHH5MP.js}

@@ -553,2631 +553,2631 @@ 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;
+// src/is.ts
+function hasPrototypeFlag(x, flag) {
+  return !!x && x.constructor.prototype[flag] === true;
 }
-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;
+function hasOwnAndPrototypeFlag(x, ownFlag, protoFlag) {
+  return !!x && x[ownFlag] === true && x.constructor.prototype[protoFlag] === true;
 }
-var Fraction = class _Fraction {
-  type = "Fraction";
-  numerator;
-  denominator;
-  constructor(numerator, denominator = 1n) {
-    const toRatio = (x) => {
-      if (isFraction(x)) {
-        return [x.numerator, x.denominator];
-      }
-      if (typeof x === "number" && !Number.isInteger(x)) {
-        const f = _Fraction.fromNumber(x);
-        return [f.numerator, f.denominator];
-      }
-      return [typeof x === "bigint" ? x : BigInt(x), 1n];
-    };
-    const [pn, qn] = toRatio(numerator);
-    const [pd, qd] = toRatio(denominator);
-    let num = pn * qd;
-    let den = qn * pd;
-    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 sign2 = 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(sign2 * h1, k1);
+function isNumber(x) {
+  return typeof x === "number";
+}
+function isBigNumber(x) {
+  if (!x || typeof x !== "object" || typeof x.constructor !== "function") {
+    return false;
   }
-  /**
-   * Create a Fraction from a decimal string
-   */
-  static fromDecimalString(str) {
-    str = str.trim();
-    const repeatingMatch = str.match(/^(-?\d*)\.(\d*)\((\d+)\)$/);
-    if (repeatingMatch) {
-      const sign3 = 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 zeros2 = BigInt("1" + "0".repeat(nonRepeating.length));
-      const num2 = fullNum - nonRepNum;
-      const den2 = nines * zeros2;
-      return new _Fraction(sign3 * num2, den2);
-    }
-    const [intPart, decPart = ""] = str.split(".");
-    const sign2 = 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(sign2 * num, den);
+  const obj = x;
+  if (obj.isBigNumber === true && typeof obj.constructor.prototype === "object" && obj.constructor.prototype.isBigNumber === true) {
+    return true;
   }
-  /**
-   * 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);
+  if (typeof obj.constructor.isDecimal === "function" && obj.constructor.isDecimal(obj) === true) {
+    return true;
   }
-  /**
-   * 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));
+  return false;
+}
+function isBigInt(x) {
+  return typeof x === "bigint";
+}
+function isComplex2(x) {
+  return !!(x && typeof x === "object" && Object.getPrototypeOf(x).isComplex === true);
+}
+function isFraction(x) {
+  return !!(x && typeof x === "object" && Object.getPrototypeOf(x).isFraction === true);
+}
+function isUnit(x) {
+  return hasPrototypeFlag(x, "isUnit");
+}
+function isString(x) {
+  return typeof x === "string";
+}
+var isArray = Array.isArray;
+function isMatrix(x) {
+  return hasPrototypeFlag(x, "isMatrix");
+}
+function isCollection(x) {
+  return Array.isArray(x) || isMatrix(x);
+}
+function isDenseMatrix(x) {
+  return hasOwnAndPrototypeFlag(x, "isDenseMatrix", "isMatrix");
+}
+function isSparseMatrix(x) {
+  return hasOwnAndPrototypeFlag(x, "isSparseMatrix", "isMatrix");
+}
+function isRange(x) {
+  return hasPrototypeFlag(x, "isRange");
+}
+function isIndex(x) {
+  return hasPrototypeFlag(x, "isIndex");
+}
+function isBoolean(x) {
+  return typeof x === "boolean";
+}
+function isFunction(x) {
+  return typeof x === "function";
+}
+function isDate(x) {
+  return x instanceof Date;
+}
+function isRegExp(x) {
+  return x instanceof RegExp;
+}
+function isObject(x) {
+  return !!(x && typeof x === "object" && x.constructor === Object && !isComplex2(x) && !isFraction(x));
+}
+function isMap(object) {
+  if (!object) {
+    return false;
   }
-  /**
-   * 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;
+  const o = object;
+  return object instanceof Map || typeof o.set === "function" && typeof o.get === "function" && typeof o.keys === "function" && typeof o.has === "function";
+}
+function isNull(x) {
+  return x === null;
+}
+function isUndefined(x) {
+  return x === void 0;
+}
+function typeOf(x) {
+  const t = typeof x;
+  if (t === "object") {
+    if (x === null) return "null";
+    if (isBigNumber(x)) return "BigNumber";
+    if (isComplex2(x)) return "Complex";
+    if (isFraction(x)) return "Fraction";
+    const ctor = x.constructor;
+    if (ctor && ctor.name) return ctor.name;
+    return "Object";
   }
-  // ============================================================
-  // Conversion Methods
-  // ============================================================
-  valueOf() {
-    return Number(this.numerator) / Number(this.denominator);
+  return t;
+}
+
+// src/number.ts
+function isInteger(value) {
+  if (typeof value === "boolean") {
+    return true;
   }
-  toString() {
-    if (this.denominator === 1n) {
-      return this.numerator.toString();
+  return isFinite(value) ? value === Math.round(value) : false;
+}
+function safeNumberType(numberStr, config2) {
+  if (config2.number === "bigint") {
+    try {
+      BigInt(numberStr);
+    } catch {
+      return config2.numberFallback;
     }
-    return `${this.numerator}/${this.denominator}`;
   }
-  toJSON() {
-    return {
-      mathjs: "Fraction",
-      n: this.numerator.toString(),
-      d: this.denominator.toString()
-    };
+  return config2.number;
+}
+var sign = Math.sign || function(x) {
+  if (x > 0) {
+    return 1;
+  } else if (x < 0) {
+    return -1;
+  } else {
+    return 0;
   }
-  /**
-   * Convert to number
-   */
-  toNumber() {
-    return this.valueOf();
+};
+var log2 = Math.log2 || function log22(x) {
+  return Math.log(x) / Math.LN2;
+};
+var log10 = Math.log10 || function log102(x) {
+  return Math.log(x) / Math.LN10;
+};
+var log1p = Math.log1p || function(x) {
+  return Math.log(x + 1);
+};
+var cbrt = Math.cbrt || function cbrt2(x) {
+  if (x === 0) {
+    return x;
   }
-  /**
-   * Convert to decimal string with specified precision
-   */
-  toDecimal(precision = 10) {
-    const sign2 = 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 sign2 + intPart.toString();
+  const negate = x < 0;
+  let result;
+  if (negate) {
+    x = -x;
+  }
+  if (isFinite(x)) {
+    result = Math.exp(Math.log(x) / 3);
+    result = (x / (result * result) + 2 * result) / 3;
+  } else {
+    result = x;
+  }
+  return negate ? -result : result;
+};
+var expm1 = Math.expm1 || function expm12(x) {
+  return x >= 2e-4 || x <= -2e-4 ? Math.exp(x) - 1 : x + x * x / 2 + x * x * x / 6;
+};
+function formatNumberToBase(n, base, size) {
+  const prefixes = { 2: "0b", 8: "0o", 16: "0x" };
+  const prefix = prefixes[base];
+  let suffix = "";
+  if (size) {
+    if (size < 1) {
+      throw new Error("size must be in greater than 0");
     }
-    let decPart = "";
-    for (let i = 0; i < precision && num !== 0n; i++) {
-      num *= 10n;
-      decPart += (num / den).toString();
-      num = num % den;
+    if (!isInteger(size)) {
+      throw new Error("size must be an integer");
     }
-    return sign2 + intPart.toString() + "." + decPart;
-  }
-  /**
-   * Convert to LaTeX string
-   */
-  toLatex() {
-    if (this.denominator === 1n) {
-      return this.numerator.toString();
+    if (n > 2 ** (size - 1) - 1 || n < -(2 ** (size - 1))) {
+      throw new Error(`Value must be in range [-2^${size - 1}, 2^${size - 1}-1]`);
     }
-    const sign2 = this.numerator < 0n ? "-" : "";
-    const absNum = this.numerator < 0n ? -this.numerator : this.numerator;
-    return `${sign2}\\frac{${absNum}}{${this.denominator}}`;
+    if (!isInteger(n)) {
+      throw new Error("Value must be an integer");
+    }
+    if (n < 0) {
+      n = n + 2 ** size;
+    }
+    suffix = `i${size}`;
   }
-  /**
-   * Convert to mixed number representation
-   */
-  toMixed() {
-    const sign2 = this.numerator < 0n ? -1n : 1n;
-    const absNum = this.numerator < 0n ? -this.numerator : this.numerator;
-    const whole = sign2 * (absNum / this.denominator);
-    const remainder = absNum % this.denominator;
-    return {
-      whole,
-      numerator: remainder,
-      denominator: this.denominator
-    };
+  let sign2 = "";
+  if (n < 0) {
+    n = -n;
+    sign2 = "-";
   }
-  // ============================================================
-  // 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())));
+  return `${sign2}${prefix}${n.toString(base)}${suffix}`;
+}
+function format(value, options) {
+  if (typeof options === "function") {
+    return options(value);
   }
-  /**
-   * 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())));
+  if (value === Infinity) {
+    return "Infinity";
+  } else if (value === -Infinity) {
+    return "-Infinity";
+  } else if (isNaN(value)) {
+    return "NaN";
   }
-  /**
-   * 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())));
+  const { notation, precision, wordSize } = normalizeFormatOptions(options);
+  switch (notation) {
+    case "fixed":
+      return toFixed(value, precision);
+    case "exponential":
+      return toExponential(value, precision);
+    case "engineering":
+      return toEngineering(value, precision);
+    case "bin":
+      return formatNumberToBase(value, 2, wordSize);
+    case "oct":
+      return formatNumberToBase(value, 8, wordSize);
+    case "hex":
+      return formatNumberToBase(value, 16, wordSize);
+    case "auto":
+      return toPrecision(value, precision, options).replace(
+        /((\.\d*?)(0+))($|e)/,
+        function(_match, _all, digits2, _zeros, e) {
+          return digits2 !== "." ? digits2 + e : e;
+        }
+      );
+    default:
+      throw new Error(
+        'Unknown notation "' + notation + '". Choose "auto", "exponential", "fixed", "bin", "oct", or "hex.'
+      );
   }
-  /**
-   * Division: a/b ÷ c/d = ad / bc
-   */
-  divide(other) {
-    if (other instanceof _Fraction) {
-      if (other.numerator === 0n) {
-        throw new Error("Division by zero");
+}
+function normalizeFormatOptions(options) {
+  let notation = "auto";
+  let precision;
+  let wordSize;
+  if (options !== void 0) {
+    if (isNumber(options)) {
+      precision = options;
+    } else if (isBigNumber(options)) {
+      precision = options.toNumber();
+    } else if (isObject(options)) {
+      if (options.precision !== void 0) {
+        precision = _toNumberOrThrow(options.precision, () => {
+          throw new Error('Option "precision" must be a number or BigNumber');
+        });
       }
-      return new _Fraction(this.numerator * other.denominator, this.denominator * other.numerator);
+      if (options.wordSize !== void 0) {
+        wordSize = _toNumberOrThrow(options.wordSize, () => {
+          throw new Error('Option "wordSize" must be a number or BigNumber');
+        });
+      }
+      if (options.notation) {
+        notation = options.notation;
+      }
+    } else {
+      throw new Error("Unsupported type of options, number, BigNumber, or object expected");
     }
-    return this.divide(_Fraction.fromNumber(Number(other.valueOf())));
   }
-  // Short-name aliases (mathjs Fraction API). Ported mathjs functions such as
-  // multiplyScalar/subtractScalar/divideScalar call x.mul/x.sub/x.div; without
-  // these, mixed number/Fraction dispatch (e.g. affine unit conversion like
-  // celsius→fahrenheit) threw "x.mul is not a function".
-  mul(other) {
-    return this.multiply(other);
+  return { notation, precision, wordSize };
+}
+function splitNumber(value) {
+  const match = String(value).toLowerCase().match(/^(-?)(\d+\.?\d*)(e([+-]?\d+))?$/);
+  if (!match) {
+    throw new SyntaxError("Invalid number " + value);
   }
-  sub(other) {
-    return this.subtract(other);
+  const sign2 = match[1];
+  const digits2 = match[2];
+  let exponent = parseFloat(match[4] || "0");
+  const dot = digits2.indexOf(".");
+  exponent += dot !== -1 ? dot - 1 : digits2.length - 1;
+  const coefficients = digits2.replace(".", "").replace(/^0*/, function(zeros2) {
+    exponent -= zeros2.length;
+    return "";
+  }).replace(/0*$/, "").split("").map(function(d) {
+    return parseInt(d);
+  });
+  if (coefficients.length === 0) {
+    coefficients.push(0);
+    exponent++;
   }
-  div(other) {
-    return this.divide(other);
+  return { sign: sign2, coefficients, exponent };
+}
+function toEngineering(value, precision) {
+  if (isNaN(value) || !isFinite(value)) {
+    return String(value);
   }
-  /**
-   * Negation: -(a/b) = -a/b
-   */
-  negate() {
-    return new _Fraction(-this.numerator, this.denominator);
+  const split = splitNumber(value);
+  const rounded = roundDigits(split, precision);
+  const e = rounded.exponent;
+  const c = rounded.coefficients;
+  const newExp = e % 3 === 0 ? e : e < 0 ? e - 3 - e % 3 : e - e % 3;
+  if (isNumber(precision)) {
+    while (precision > c.length || e - newExp + 1 > c.length) {
+      c.push(0);
+    }
+  } else {
+    const missingZeros = Math.abs(e - newExp) - (c.length - 1);
+    for (let i = 0; i < missingZeros; i++) {
+      c.push(0);
+    }
   }
-  /**
-   * Absolute value: |a/b|
-   */
-  abs() {
-    return new _Fraction(this.numerator < 0n ? -this.numerator : this.numerator, this.denominator);
+  let expDiff = Math.abs(e - newExp);
+  let decimalIdx = 1;
+  while (expDiff > 0) {
+    decimalIdx++;
+    expDiff--;
   }
-  /**
-   * Reciprocal: b/a
-   */
-  inverse() {
-    if (this.numerator === 0n) {
-      throw new Error("Cannot invert zero");
-    }
-    return new _Fraction(this.denominator, this.numerator);
+  const decimals = c.slice(decimalIdx).join("");
+  const decimalVal = isNumber(precision) && decimals.length || decimals.match(/[1-9]/) ? "." + decimals : "";
+  const str = c.slice(0, decimalIdx).join("") + decimalVal + "e" + (e >= 0 ? "+" : "") + newExp.toString();
+  return rounded.sign + str;
+}
+function toFixed(value, precision) {
+  if (isNaN(value) || !isFinite(value)) {
+    return String(value);
   }
-  /**
-   * 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.clone();
-    let e = exp;
-    while (e > 0n) {
-      if (e % 2n === 1n) {
-        result = result.multiply(base);
-      }
-      base = base.multiply(base);
-      e = e / 2n;
-    }
-    return result;
+  const splitValue = splitNumber(value);
+  const rounded = typeof precision === "number" ? roundDigits(splitValue, splitValue.exponent + 1 + precision) : splitValue;
+  let c = rounded.coefficients;
+  let p = rounded.exponent + 1;
+  const pp = p + (precision || 0);
+  if (c.length < pp) {
+    c = c.concat(zeros(pp - c.length));
   }
-  /**
-   * Modulo operation
-   */
-  mod(other) {
-    const quotient = this.divide(other);
-    const floorQuot = quotient.floor();
-    return this.subtract(other.multiply(floorQuot));
+  if (p < 0) {
+    c = zeros(-p + 1).concat(c);
+    p = 1;
   }
-  // ============================================================
-  // Comparison Methods
-  // ============================================================
-  /**
-   * Check equality
-   */
-  equals(other) {
-    return this.numerator === other.numerator && this.denominator === other.denominator;
+  if (p < c.length) {
+    c.splice(p, 0, p === 0 ? "0." : ".");
   }
-  /**
-   * Check if less than
-   */
-  lessThan(other) {
-    return _Fraction.compare(this, other) < 0;
+  return rounded.sign + c.join("");
+}
+function toExponential(value, precision) {
+  if (isNaN(value) || !isFinite(value)) {
+    return String(value);
   }
-  /**
-   * Check if less than or equal
-   */
-  lessThanOrEqual(other) {
-    return _Fraction.compare(this, other) <= 0;
+  const split = splitNumber(value);
+  const rounded = precision ? roundDigits(split, precision) : split;
+  let c = rounded.coefficients;
+  const e = rounded.exponent;
+  if (precision && c.length < precision) {
+    c = c.concat(zeros(precision - c.length));
   }
-  /**
-   * Check if greater than
-   */
-  greaterThan(other) {
-    return _Fraction.compare(this, other) > 0;
+  const first = c.shift();
+  return rounded.sign + first + (c.length > 0 ? "." + c.join("") : "") + "e" + (e >= 0 ? "+" : "") + e;
+}
+function toPrecision(value, precision, options) {
+  if (isNaN(value) || !isFinite(value)) {
+    return String(value);
   }
-  /**
-   * Check if greater than or equal
-   */
-  greaterThanOrEqual(other) {
-    return _Fraction.compare(this, other) >= 0;
+  const lowerExp = _toNumberOrDefault(options?.lowerExp, -3);
+  const upperExp = _toNumberOrDefault(options?.upperExp, 5);
+  const split = splitNumber(value);
+  const rounded = precision ? roundDigits(split, precision) : split;
+  if (rounded.exponent < lowerExp || rounded.exponent >= upperExp) {
+    return toExponential(value, precision);
+  } else {
+    let c = rounded.coefficients;
+    const e = rounded.exponent;
+    if (precision && c.length < precision) {
+      c = c.concat(zeros(precision - c.length));
+    }
+    c = c.concat(
+      zeros(e - c.length + 1 + (precision && c.length < precision ? precision - c.length : 0))
+    );
+    c = zeros(-e).concat(c);
+    const dot = e > 0 ? e : 0;
+    if (dot < c.length - 1) {
+      c.splice(dot + 1, 0, ".");
+    }
+    return rounded.sign + c.join("");
   }
-  /**
-   * Compare with another fraction
-   * @returns -1, 0, or 1
-   */
-  compareTo(other) {
-    return _Fraction.compare(this, other);
+}
+function roundDigits(split, precision) {
+  const rounded = {
+    sign: split.sign,
+    coefficients: split.coefficients.slice(),
+    exponent: split.exponent
+  };
+  const c = rounded.coefficients;
+  if (precision !== void 0) {
+    while (precision <= 0) {
+      c.unshift(0);
+      rounded.exponent++;
+      precision++;
+    }
+    if (c.length > precision) {
+      const removed = c.splice(precision, c.length - precision);
+      if (removed[0] >= 5) {
+        let i = precision - 1;
+        c[i]++;
+        while (c[i] === 10) {
+          c.pop();
+          if (i === 0) {
+            c.unshift(0);
+            rounded.exponent++;
+            i++;
+          }
+          i--;
+          c[i]++;
+        }
+      }
+    }
   }
-  compare(other) {
-    return this.compareTo(other);
+  return rounded;
+}
+function zeros(length) {
+  const arr = [];
+  for (let i = 0; i < length; i++) {
+    arr.push(0);
   }
-  // ============================================================
-  // Utility Methods
-  // ============================================================
-  /**
-   * Return fraction already in lowest terms (no-op since constructor reduces)
-   */
-  simplify() {
-    return this;
+  return arr;
+}
+function digits(value) {
+  return value.toExponential().replace(/e.*$/, "").replace(/^0\.?0*|\./, "").length;
+}
+function nearlyEqual(a, b, relTol = 1e-8, absTol = 0) {
+  if (relTol <= 0) {
+    throw new Error("Relative tolerance must be greater than 0");
   }
-  /**
-   * Check if this is zero
-   */
-  isZero() {
-    return this.numerator === 0n;
+  if (absTol < 0) {
+    throw new Error("Absolute tolerance must be at least 0");
   }
-  /**
-   * Check if this is positive
-   */
-  isPositive() {
-    return this.numerator > 0n;
+  if (isNaN(a) || isNaN(b)) {
+    return false;
   }
-  /**
-   * Check if this is negative
-   */
-  isNegative() {
-    return this.numerator < 0n;
+  if (!isFinite(a) || !isFinite(b)) {
+    return a === b;
   }
-  /**
-   * Check if this is an integer
-   */
-  isInteger() {
-    return this.denominator === 1n;
+  if (a === b) {
+    return true;
   }
-  /**
-   * Check if this is a unit fraction (1/n)
-   */
-  isUnit() {
-    return this.numerator === 1n || this.numerator === -1n;
+  return Math.abs(a - b) <= Math.max(relTol * Math.max(Math.abs(a), Math.abs(b)), absTol);
+}
+var acosh = Math.acosh || function(x) {
+  return Math.log(Math.sqrt(x * x - 1) + x);
+};
+var asinh = Math.asinh || function(x) {
+  return Math.log(Math.sqrt(x * x + 1) + x);
+};
+var atanh = Math.atanh || function(x) {
+  return Math.log((1 + x) / (1 - x)) / 2;
+};
+var cosh = Math.cosh || function(x) {
+  return (Math.exp(x) + Math.exp(-x)) / 2;
+};
+var sinh = Math.sinh || function(x) {
+  return (Math.exp(x) - Math.exp(-x)) / 2;
+};
+var tanh = Math.tanh || function(x) {
+  const e = Math.exp(2 * x);
+  return (e - 1) / (e + 1);
+};
+function copysign(x, y) {
+  const signx = x > 0 ? true : x < 0 ? false : 1 / x === Infinity;
+  const signy = y > 0 ? true : y < 0 ? false : 1 / y === Infinity;
+  return signx !== signy ? -x : x;
+}
+function isPowZeroAtInfinity(x, y) {
+  return x * x < 1 && y === Infinity || x * x > 1 && y === -Infinity;
+}
+function _toNumberOrThrow(value, onError) {
+  if (isNumber(value)) {
+    return value;
+  } else if (isBigNumber(value)) {
+    return value.toNumber();
+  } else {
+    onError();
+    return 0;
   }
-  /**
-   * 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);
+}
+function _toNumberOrDefault(value, defaultValue) {
+  if (isNumber(value)) {
+    return value;
+  } else if (isBigNumber(value)) {
+    return value.toNumber();
+  } else {
+    return defaultValue;
   }
-  /**
-   * Ceiling: smallest integer ≥ this
-   */
-  ceil() {
-    if (this.denominator === 1n) {
-      return this;
+}
+
+// src/shared.ts
+function hasOwnProperty(object, property) {
+  return !!object && Object.hasOwnProperty.call(object, property);
+}
+function endsWith(text, search) {
+  const start = text.length - search.length;
+  return text.substring(start, text.length) === search;
+}
+var warnOnce = /* @__PURE__ */ (() => {
+  const seen = {};
+  return function warnOnce2(...args) {
+    const message = args.join(", ");
+    if (!seen[message]) {
+      seen[message] = true;
+      console.warn("Warning:", ...args);
     }
-    const quot = this.numerator / this.denominator;
-    if (this.numerator <= 0n || this.numerator % this.denominator === 0n) {
-      return new _Fraction(quot, 1n);
+  };
+})();
+function memoize(fn, { hasher, limit } = {}) {
+  const hash = hasher ?? ((args) => JSON.stringify(args));
+  const maxSize = limit == null ? Number.POSITIVE_INFINITY : limit;
+  const memoized = function(...args) {
+    if (!(memoized.cache instanceof Map)) {
+      memoized.cache = /* @__PURE__ */ new Map();
     }
-    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));
+    const cache = memoized.cache;
+    const key = hash(args);
+    if (cache.has(key)) {
+      const value2 = cache.get(key);
+      cache.delete(key);
+      cache.set(key, value2);
+      return value2;
     }
-    return floor;
+    const value = fn.apply(fn, args);
+    cache.set(key, value);
+    if (cache.size > maxSize) {
+      cache.delete(cache.keys().next().value);
+    }
+    return value;
+  };
+  return memoized;
+}
+
+// src/object.ts
+function clone(x) {
+  const type = typeof x;
+  if (type === "number" || type === "bigint" || type === "string" || type === "boolean" || x === null || x === void 0) {
+    return x;
   }
-  /**
-   * Truncate (round toward zero)
-   */
-  trunc() {
-    return new _Fraction(this.numerator / this.denominator, 1n);
+  const cloneable = x;
+  if (typeof cloneable.clone === "function") {
+    return cloneable.clone();
   }
-  /**
-   * Get the sign: -1, 0, or 1
-   */
-  sign() {
-    if (this.numerator < 0n) return -1;
-    if (this.numerator > 0n) return 1;
-    return 0;
+  if (Array.isArray(x)) {
+    return x.map((value) => clone(value));
   }
-  /**
-   * Clone this fraction
-   */
-  clone() {
-    return new _Fraction(this.numerator, this.denominator);
+  if (x instanceof Date) return new Date(x.valueOf());
+  if (isBigNumber(x)) return x;
+  if (isObject(x)) {
+    return mapObject(x, clone);
   }
-  /**
-   * Get the GCD of numerator and denominator (always 1 since we reduce)
-   */
-  gcd() {
-    return 1n;
+  if (type === "function") {
+    return x;
   }
-  /**
-   * 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];
+  throw new TypeError(`Cannot clone: unknown type of value (value: ${x})`);
+}
+function mapObject(object, callback) {
+  const clone2 = {};
+  for (const key in object) {
+    if (hasOwnProperty(object, key)) {
+      clone2[key] = callback(object[key]);
     }
-    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 clone2;
+}
+function extend(a, b) {
+  const target = a;
+  for (const prop in b) {
+    if (hasOwnProperty(b, prop)) {
+      target[prop] = b[prop];
     }
-    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;
+  return a;
 }
-var defaultConfig = {
-  precision: 64,
-  rounding: "halfUp",
-  minExponent: -1e9,
-  maxExponent: 1e9
-};
-var globalConfig = { ...defaultConfig };
-var BigNumber = class _BigNumber {
-  type = "BigNumber";
-  /**
-   * Duck-typing marker for Decimal.js / mathjs formatter compatibility.
-   * Allows external code that checks `obj.isBigNumber === true` to identify
-   * this class without an `instanceof` check.
-   */
-  isBigNumber = true;
-  // Internal representation: sign * coefficient * 10^exponent
-  _sign;
-  _coefficient;
-  // Absolute value, normalized
-  _exponent;
-  // Power of 10
-  // Special values
-  _isNaN = false;
-  _isInfinite = false;
-  constructor(sign2, coefficient, exponent, isNaN2 = false, isInfinite = false) {
-    this._sign = sign2;
-    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);
+function deepExtend(a, b) {
+  if (Array.isArray(b)) {
+    if (!Array.isArray(a)) {
+      throw new TypeError("Cannot extend an object with an array");
     }
-    if (n === 0) {
-      return new _BigNumber(0, 0n, 0);
+    for (let i = 0; i < b.length; i++) {
+      const bValue = b[i];
+      if (bValue && bValue.constructor === Object) {
+        if (a[i] === void 0) {
+          a[i] = {};
+        }
+        if (a[i] && a[i].constructor === Object) {
+          deepExtend(a[i], bValue);
+        } else {
+          a[i] = bValue;
+        }
+      } else if (Array.isArray(bValue)) {
+        if (a[i] === void 0) {
+          a[i] = [];
+        }
+        if (Array.isArray(a[i])) {
+          deepExtend(a[i], bValue);
+        } else {
+          a[i] = clone(bValue);
+        }
+      } else {
+        a[i] = bValue;
+      }
     }
-    return _BigNumber.parse(n.toString());
+    return a;
   }
-  /**
-   * 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);
+  for (const prop in b) {
+    if (hasOwnProperty(b, prop) && !(prop in Object.prototype) && !(prop in Function.prototype)) {
+      const bValue = b[prop];
+      const aValue = a[prop];
+      if (bValue && bValue.constructor === Object) {
+        if (aValue === void 0) {
+          a[prop] = {};
+        }
+        if (aValue && aValue.constructor === Object) {
+          deepExtend(aValue, bValue);
+        } else {
+          a[prop] = bValue;
+        }
+      } else if (Array.isArray(bValue)) {
+        if (aValue === void 0) {
+          a[prop] = [];
+        }
+        if (Array.isArray(aValue)) {
+          deepExtend(aValue, bValue);
+        } else {
+          a[prop] = clone(bValue);
+        }
+      } else {
+        a[prop] = bValue;
+      }
     }
-    let sign2 = 1;
-    if (str.startsWith("-")) {
-      sign2 = -1;
-      str = str.slice(1);
-    } else if (str.startsWith("+")) {
-      str = str.slice(1);
+  }
+  return a;
+}
+function deepStrictEqual(a, b) {
+  let prop;
+  let i;
+  let len;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b)) {
+      return false;
     }
-    let exponentPart = 0;
-    const eIndex = str.indexOf("e");
-    if (eIndex !== -1) {
-      exponentPart = parseInt(str.slice(eIndex + 1), 10);
-      str = str.slice(0, eIndex);
+    if (a.length !== b.length) {
+      return false;
     }
-    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;
+    for (i = 0, len = a.length; i < len; i++) {
+      if (!deepStrictEqual(a[i], b[i])) {
+        return false;
+      }
     }
-    coefficient = coefficient.replace(/^0+/, "") || "0";
-    if (coefficient === "0") {
-      return new _BigNumber(0, 0n, 0);
+    return true;
+  } else if (typeof a === "function") {
+    return a === b;
+  } else if (a instanceof Object) {
+    if (Array.isArray(b) || !(b instanceof Object)) {
+      return false;
     }
-    let trailingZeros = 0;
-    for (let i = coefficient.length - 1; i >= 0; i--) {
-      if (coefficient[i] === "0") {
-        trailingZeros++;
-      } else {
-        break;
+    const aObj = a;
+    const bObj = b;
+    for (prop in aObj) {
+      if (!(prop in bObj) || !deepStrictEqual(aObj[prop], bObj[prop])) {
+        return false;
       }
     }
-    if (trailingZeros > 0) {
-      coefficient = coefficient.slice(0, -trailingZeros);
+    for (prop in bObj) {
+      if (!(prop in aObj)) {
+        return false;
+      }
     }
-    const finalExponent = exponentPart - decimalPlaces + trailingZeros;
-    return new _BigNumber(sign2, BigInt(coefficient), finalExponent);
+    return true;
+  } else {
+    return a === b;
   }
-  /**
-   * Create from bigint
-   */
-  static fromBigInt(n) {
-    if (n === 0n) {
-      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++;
+}
+function deepFlatten(nestedObject) {
+  const flattenedObject = {};
+  _deepFlatten(nestedObject, flattenedObject);
+  return flattenedObject;
+}
+function _deepFlatten(nestedObject, flattenedObject) {
+  for (const prop in nestedObject) {
+    if (hasOwnProperty(nestedObject, prop)) {
+      const value = nestedObject[prop];
+      if (typeof value === "object" && value !== null) {
+        _deepFlatten(value, flattenedObject);
       } else {
-        break;
+        flattenedObject[prop] = value;
       }
     }
-    if (trailingZeros > 0) {
-      str = str.slice(0, -trailingZeros);
+  }
+}
+function canDefineProperty() {
+  try {
+    if (Object.defineProperty) {
+      Object.defineProperty({}, "x", {
+        get: function() {
+          return null;
+        }
+      });
+      return true;
     }
-    return new _BigNumber(sign2, BigInt(str), trailingZeros);
+  } catch {
   }
-  /**
-   * Create a BigNumber from a JSON object
-   */
-  static fromJSON(json) {
-    return _BigNumber.parse(json.value);
+  return false;
+}
+function lazy(object, prop, valueResolver) {
+  let _uninitialized = true;
+  let _value;
+  Object.defineProperty(object, prop, {
+    get: function() {
+      if (_uninitialized) {
+        _value = valueResolver();
+        _uninitialized = false;
+      }
+      return _value;
+    },
+    set: function(value) {
+      _value = value;
+      _uninitialized = false;
+    },
+    configurable: true,
+    enumerable: true
+  });
+}
+function traverse(object, path) {
+  if (path && typeof path === "string") {
+    return traverse(object, path.split("."));
   }
-  /**
-   * Get/set global configuration
-   */
-  static config(newConfig) {
-    if (newConfig) {
-      globalConfig = { ...globalConfig, ...newConfig };
+  let obj = object;
+  if (path) {
+    for (let i = 0; i < path.length; i++) {
+      const key = path[i];
+      if (!(key in obj)) {
+        obj[key] = {};
+      }
+      obj = obj[key];
     }
-    return { ...globalConfig };
   }
-  /**
-   * Reset configuration to defaults
-   */
-  static resetConfig() {
-    globalConfig = { ...defaultConfig };
+  return obj;
+}
+function isLegacyFactory(object) {
+  return !!object && typeof object.factory === "function";
+}
+function get(object, path) {
+  if (typeof path === "string") {
+    if (isPath(path)) {
+      return get(object, path.split("."));
+    } else {
+      return object[path];
+    }
   }
-  /**
-   * 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;
+  let child = object;
+  for (let i = 0; i < path.length; i++) {
+    const key = path[i];
+    child = child ? child[key] : void 0;
+  }
+  return child;
+}
+function set(object, path, value) {
+  if (typeof path === "string") {
+    if (isPath(path)) {
+      return set(object, path.split("."), value);
+    } else {
+      object[path] = value;
+      return object;
     }
-    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;
+  let child = object;
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i];
+    if (child[key] === void 0) {
+      child[key] = {};
     }
-    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;
+    child = child[key];
   }
-  // ============================================================
-  // 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);
-  }
-  /**
-   * Convert to a JS number.
-   * Alias for `valueOf()` — provided for Decimal.js / mathjs formatter
-   * duck-typing compatibility.
-   */
-  toNumber() {
-    return this.valueOf();
+  if (path.length > 0) {
+    const lastKey = path[path.length - 1];
+    child[lastKey] = value;
   }
-  toString() {
-    if (this._isNaN) return "NaN";
-    if (this._isInfinite) return this._sign === 1 ? "Infinity" : "-Infinity";
-    if (this._sign === 0) return "0";
-    const sign2 = this._sign === -1 ? "-" : "";
-    const digits2 = this._coefficient.toString();
-    if (this._exponent >= 0) {
-      return sign2 + digits2 + "0".repeat(this._exponent);
-    } else if (-this._exponent < digits2.length) {
-      const insertPos = digits2.length + this._exponent;
-      return sign2 + digits2.slice(0, insertPos) + "." + digits2.slice(insertPos);
-    } else {
-      return sign2 + "0." + "0".repeat(-this._exponent - digits2.length) + digits2;
+  return object;
+}
+function pick(object, properties, transform) {
+  const copy = {};
+  for (let i = 0; i < properties.length; i++) {
+    const key = properties[i];
+    const value = get(object, key);
+    if (value !== void 0) {
+      set(copy, key, transform ? transform(value, key) : value);
     }
   }
-  toJSON() {
-    return {
-      mathjs: "BigNumber",
-      value: this.toString()
-    };
-  }
-  /**
-   * Convert to fixed-point notation.
-   *
-   * When called with no argument (or `undefined`) returns the full fixed-point
-   * string representation without rounding — matching Decimal.js semantics where
-   * `toFixed()` is equivalent to a lossless fixed-point stringify.
-   * When called with a non-negative integer `decimalPlaces`, rounds and formats
-   * to exactly that many digits after the decimal point.
-   */
-  toFixed(decimalPlaces) {
-    if (decimalPlaces === void 0) {
-      return this.toFixedInternal(void 0);
+  return copy;
+}
+function pickShallow(object, properties) {
+  const copy = {};
+  for (let i = 0; i < properties.length; i++) {
+    const key = properties[i];
+    const value = object[key];
+    if (value !== void 0) {
+      copy[key] = value;
     }
-    return this.round(decimalPlaces).toFixedInternal(decimalPlaces);
   }
-  toFixedInternal(decimalPlaces) {
-    if (this._isNaN) return "NaN";
-    if (this._isInfinite) return this._sign === 1 ? "Infinity" : "-Infinity";
-    const dp = decimalPlaces ?? -1;
-    const allDigits = dp < 0;
-    if (this._sign === 0) return allDigits ? "0" : dp > 0 ? "0." + "0".repeat(dp) : "0";
-    const sign2 = this._sign === -1 ? "-" : "";
-    const digits2 = this._coefficient.toString();
-    if (this._exponent >= 0) {
-      const intPart = digits2 + "0".repeat(this._exponent);
-      if (allDigits) return sign2 + intPart;
-      return sign2 + intPart + (dp > 0 ? "." + "0".repeat(dp) : "");
-    } else if (-this._exponent <= digits2.length) {
-      const insertPos = digits2.length + this._exponent;
-      const intPart = digits2.slice(0, insertPos) || "0";
-      const decPart = digits2.slice(insertPos);
-      if (allDigits) {
-        return sign2 + intPart + (decPart.length > 0 ? "." + decPart : "");
-      }
-      let paddedDec = decPart;
-      if (paddedDec.length < dp) {
-        paddedDec += "0".repeat(dp - paddedDec.length);
-      }
-      return sign2 + intPart + (dp > 0 ? "." + paddedDec.slice(0, dp) : "");
-    } else {
-      const leadingZeros = -this._exponent - digits2.length;
-      const decPart = "0".repeat(leadingZeros) + digits2;
-      if (allDigits) {
-        return sign2 + "0." + decPart;
+  return copy;
+}
+function isPath(str) {
+  return str.includes(".");
+}
+
+// src/types/fraction.ts
+function isFraction2(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) {
+    const toRatio = (x) => {
+      if (isFraction2(x)) {
+        return [x.numerator, x.denominator];
       }
-      let paddedDec = decPart;
-      if (paddedDec.length < dp) {
-        paddedDec += "0".repeat(dp - paddedDec.length);
+      if (typeof x === "number" && !Number.isInteger(x)) {
+        const f = _Fraction.fromNumber(x);
+        return [f.numerator, f.denominator];
       }
-      return sign2 + "0" + (dp > 0 ? "." + paddedDec.slice(0, dp) : "");
+      return [typeof x === "bigint" ? x : BigInt(x), 1n];
+    };
+    const [pn, qn] = toRatio(numerator);
+    const [pd, qd] = toRatio(denominator);
+    let num = pn * qd;
+    let den = qn * pd;
+    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
+  // ============================================================
   /**
-   * Convert to exponential notation
+   * Create a Fraction from a number (with optional precision)
    */
-  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 sign2 = this._sign === -1 ? "-" : "";
-    const digits2 = this._coefficient.toString();
-    const exp = digits2.length - 1 + this._exponent;
-    const expSign = exp >= 0 ? "+" : "";
-    if (decimalPlaces === void 0) {
-      if (digits2.length === 1) {
-        return `${sign2}${digits2}e${expSign}${exp}`;
-      }
-      return `${sign2}${digits2[0]}.${digits2.slice(1)}e${expSign}${exp}`;
-    }
-    if (decimalPlaces === 0) {
-      return `${sign2}${digits2[0]}e${expSign}${exp}`;
+  static fromNumber(n, maxDenominator = 1000000n) {
+    if (!Number.isFinite(n)) {
+      throw new Error("Cannot create fraction from non-finite number");
     }
-    let decPart = digits2.slice(1);
-    if (decPart.length < decimalPlaces) {
-      decPart += "0".repeat(decimalPlaces - decPart.length);
-    } else {
-      decPart = decPart.slice(0, decimalPlaces);
+    if (Number.isInteger(n)) {
+      return new _Fraction(BigInt(n), 1n);
     }
-    return `${sign2}${digits2[0]}.${decPart}e${expSign}${exp}`;
+    const sign2 = 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(sign2 * h1, k1);
   }
   /**
-   * Convert to precision
+   * Create a Fraction from a decimal string
    */
-  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 digits2 = this._coefficient.toString();
-    const order = digits2.length + this._exponent;
-    if (order > significantDigits || order < -6) {
-      return this.toExponential(significantDigits - 1);
+  static fromDecimalString(str) {
+    str = str.trim();
+    const repeatingMatch = str.match(/^(-?\d*)\.(\d*)\((\d+)\)$/);
+    if (repeatingMatch) {
+      const sign3 = 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 zeros2 = BigInt("1" + "0".repeat(nonRepeating.length));
+      const num2 = fullNum - nonRepNum;
+      const den2 = nines * zeros2;
+      return new _Fraction(sign3 * num2, den2);
     }
-    return this.toFixed(significantDigits - order);
+    const [intPart, decPart = ""] = str.split(".");
+    const sign2 = 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(sign2 * num, den);
   }
   /**
-   * Convert to bigint (truncated)
+   * Parse a fraction from a string
+   * Supports formats: "3/4", "-3/4", "3", "3.14", "0.(3)"
    */
-  toBigInt() {
-    if (this._isNaN || this._isInfinite) {
-      throw new Error("Cannot convert NaN or Infinity to bigint");
+  static parse(str) {
+    str = str.trim();
+    if (str.includes("/")) {
+      const [numStr, denStr] = str.split("/");
+      return new _Fraction(BigInt(numStr.trim()), BigInt(denStr.trim()));
     }
-    if (this._sign === 0) return 0n;
-    const digits2 = this._coefficient.toString();
-    if (this._exponent >= 0) {
-      return BigInt(this._sign) * BigInt(digits2 + "0".repeat(this._exponent));
-    } else if (-this._exponent < digits2.length) {
-      return BigInt(this._sign) * BigInt(digits2.slice(0, digits2.length + this._exponent));
+    if (str.includes(".") || str.includes("(")) {
+      return _Fraction.fromDecimalString(str);
     }
-    return 0n;
+    return new _Fraction(BigInt(str), 1n);
   }
   /**
-   * Binary string representation, e.g. `255 -> '0b11111111'`, `0.5 -> '0b0.1'`.
-   * Mirrors Decimal.js `toBinary()`. Negatives carry a leading `-`.
+   * Create a Fraction from a JSON object
    */
-  toBinary() {
-    return this.toRadixString(2, "0b");
+  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));
   }
   /**
-   * Octal string representation, e.g. `8 -> '0o10'`.
-   * Mirrors Decimal.js `toOctal()`.
+   * Compare two fractions
+   * @returns -1, 0, or 1
    */
-  toOctal() {
-    return this.toRadixString(8, "0o");
+  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;
   }
-  /**
-   * Hexadecimal string representation, e.g. `255 -> '0xff'`, `10.5 -> '0xa.8'`.
-   * Mirrors Decimal.js `toHexadecimal()`.
-   */
-  toHexadecimal() {
-    return this.toRadixString(16, "0x");
+  // ============================================================
+  // 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()
+    };
   }
   /**
-   * Shared radix formatter for {@link toBinary}/{@link toOctal}/{@link toHexadecimal}.
-   * Integers and terminating fractions are exact; a non-terminating fraction is
-   * truncated at `maxFractionDigits` radix digits (a safety bound — the common
-   * use is integer formatting).
+   * Convert to number
    */
-  toRadixString(radix, prefix, maxFractionDigits = 1100) {
-    if (this._isNaN) return "NaN";
-    if (this._isInfinite) return (this._sign < 0 ? "-" : "") + "Infinity";
-    if (this._sign === 0) return prefix + "0";
-    const negative = this._sign < 0;
-    const absVal = this.abs();
-    const intPart = absVal.toBigInt();
-    let out = prefix + intPart.toString(radix);
-    let frac = absVal.subtract(_BigNumber.fromBigInt(intPart));
-    if (!frac.isZero()) {
-      const radixBN = _BigNumber.fromNumber(radix);
-      let digits2 = "";
-      for (let i = 0; i < maxFractionDigits && !frac.isZero(); i++) {
-        frac = frac.multiply(radixBN);
-        const digit = frac.toBigInt();
-        digits2 += Number(digit).toString(radix);
-        frac = frac.subtract(_BigNumber.fromBigInt(digit));
-      }
-      out += "." + digits2;
-    }
-    return (negative ? "-" : "") + out;
+  toNumber() {
+    return this.valueOf();
   }
-  // ============================================================
-  // Arithmetic Operations
-  // ============================================================
   /**
-   * Addition
+   * Convert to decimal string with specified precision
    */
-  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);
+  toDecimal(precision = 10) {
+    const sign2 = 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 sign2 + intPart.toString();
     }
-    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);
-      }
+    let decPart = "";
+    for (let i = 0; i < precision && num !== 0n; i++) {
+      num *= 10n;
+      decPart += (num / den).toString();
+      num = num % den;
     }
+    return sign2 + intPart.toString() + "." + decPart;
   }
   /**
-   * Subtraction
+   * Convert to LaTeX string
    */
-  subtract(other) {
-    const b = this.ensureBigNumber(other);
-    return this.add(b.negate());
+  toLatex() {
+    if (this.denominator === 1n) {
+      return this.numerator.toString();
+    }
+    const sign2 = this.numerator < 0n ? "-" : "";
+    const absNum = this.numerator < 0n ? -this.numerator : this.numerator;
+    return `${sign2}\\frac{${absNum}}{${this.denominator}}`;
   }
   /**
-   * Alias for subtract — mathjs / Decimal.js compatibility.
+   * Convert to mixed number representation
    */
-  sub(other) {
-    return this.subtract(other);
+  toMixed() {
+    const sign2 = this.numerator < 0n ? -1n : 1n;
+    const absNum = this.numerator < 0n ? -this.numerator : this.numerator;
+    const whole = sign2 * (absNum / this.denominator);
+    const remainder = absNum % this.denominator;
+    return {
+      whole,
+      numerator: remainder,
+      denominator: this.denominator
+    };
   }
+  // ============================================================
+  // Arithmetic Operations (Scalar interface)
+  // ============================================================
   /**
-   * Multiplication
+   * Addition: a/b + c/d = (ad + bc) / bd
    */
-  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 sign3 = this._sign * b._sign;
-      return new _BigNumber(sign3, 0n, 0, false, true);
+  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);
     }
-    if (this._sign === 0 || b._sign === 0) return new _BigNumber(0, 0n, 0);
-    const sign2 = this._sign * b._sign;
-    const coefficient = this._coefficient * b._coefficient;
-    const exponent = this._exponent + b._exponent;
-    return this.normalize(sign2, coefficient, exponent);
+    return this.add(_Fraction.fromNumber(Number(other.valueOf())));
   }
   /**
-   * Alias for multiply — mathjs / Decimal.js compatibility.
+   * Subtraction: a/b - c/d = (ad - bc) / bd
    */
-  mul(other) {
-    return this.multiply(other);
+  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())));
   }
   /**
-   * Alias for multiply — Decimal.js calling convention (used by the Unit).
+   * Multiplication: a/b * c/d = ac / bd
    */
-  times(other) {
-    return this.multiply(other);
+  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
+   * Division: a/b ÷ c/d = ad / bc
    */
   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 sign3 = this._sign * b._sign;
-      return new _BigNumber(sign3, 0n, 0, false, true);
+    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);
     }
-    if (b._isInfinite) return new _BigNumber(0, 0n, 0);
-    if (this._sign === 0) return new _BigNumber(0, 0n, 0);
-    const sign2 = 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(sign2, quotient, exponent).roundToPrecision(precision);
+    return this.divide(_Fraction.fromNumber(Number(other.valueOf())));
+  }
+  // Short-name aliases (mathjs Fraction API). Ported mathjs functions such as
+  // multiplyScalar/subtractScalar/divideScalar call x.mul/x.sub/x.div; without
+  // these, mixed number/Fraction dispatch (e.g. affine unit conversion like
+  // celsius→fahrenheit) threw "x.mul is not a function".
+  mul(other) {
+    return this.multiply(other);
+  }
+  sub(other) {
+    return this.subtract(other);
   }
-  /**
-   * Alias for divide — Decimal.js calling convention (used by the Unit).
-   */
   div(other) {
     return this.divide(other);
   }
   /**
-   * Negation
+   * Negation: -(a/b) = -a/b
    */
   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);
+    return new _Fraction(-this.numerator, this.denominator);
   }
   /**
-   * Absolute value
+   * Absolute value: |a/b|
    */
   abs() {
-    if (this._isNaN) return this;
-    if (this._sign === 0) return this;
-    return new _BigNumber(1, this._coefficient, this._exponent, false, this._isInfinite);
+    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" ? 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;
+    const exp = typeof n === "bigint" ? n : BigInt(n);
+    if (exp === 0n) {
+      return new _Fraction(1n, 1n);
     }
-    if (exp < 0) {
-      return _BigNumber.fromNumber(1).divide(this.pow(-exp));
+    if (exp < 0n) {
+      return this.inverse().pow(-exp);
     }
-    let result = _BigNumber.fromNumber(1);
+    let result = new _Fraction(1n, 1n);
     let base = this.clone();
     let e = exp;
-    while (e > 0) {
-      if (e % 2 === 1) {
+    while (e > 0n) {
+      if (e % 2n === 1n) {
         result = result.multiply(base);
       }
       base = base.multiply(base);
-      e = Math.floor(e / 2);
+      e = e / 2n;
     }
-    return result.roundToPrecision(globalConfig.precision);
+    return result;
   }
   /**
-   * Square root
+   * Modulo operation
    */
-  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);
+  mod(other) {
+    const quotient = this.divide(other);
+    const floorQuot = quotient.floor();
+    return this.subtract(other.multiply(floorQuot));
   }
   // ============================================================
   // Comparison Methods
   // ============================================================
+  /**
+   * Check equality
+   */
   equals(other) {
-    return _BigNumber.compare(this, other) === 0;
+    return this.numerator === other.numerator && this.denominator === other.denominator;
   }
+  /**
+   * Check if less than
+   */
   lessThan(other) {
-    return _BigNumber.compare(this, other) < 0;
+    return _Fraction.compare(this, other) < 0;
   }
+  /**
+   * Check if less than or equal
+   */
   lessThanOrEqual(other) {
-    return _BigNumber.compare(this, other) <= 0;
+    return _Fraction.compare(this, other) <= 0;
   }
+  /**
+   * Check if greater than
+   */
   greaterThan(other) {
-    return _BigNumber.compare(this, other) > 0;
+    return _Fraction.compare(this, other) > 0;
   }
+  /**
+   * Check if greater than or equal
+   */
   greaterThanOrEqual(other) {
-    return _BigNumber.compare(this, other) >= 0;
+    return _Fraction.compare(this, other) >= 0;
   }
+  /**
+   * Compare with another fraction
+   * @returns -1, 0, or 1
+   */
   compareTo(other) {
-    return _BigNumber.compare(this, other);
+    return _Fraction.compare(this, other);
   }
   compare(other) {
     return this.compareTo(other);
   }
-  /**
-   * Returns true iff this > other.
-   * Accepts the same argument types as `add`/`multiply` (BigNumber, number, or string).
-   * Named `gt` for Decimal.js / mathjs formatter compatibility.
-   */
-  gt(other) {
-    return this.greaterThan(this.ensureBigNumber(other));
-  }
   // ============================================================
-  // Rounding Methods
+  // Utility Methods
   // ============================================================
   /**
-   * Round to specified decimal places
+   * Return fraction already in lowest terms (no-op since constructor reduces)
    */
-  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;
-    }
+  simplify() {
+    return this;
   }
   /**
-   * Round to specified precision (significant digits)
+   * Check if this is zero
    */
-  roundToPrecision(precision, mode = globalConfig.rounding) {
-    if (this._isNaN || this._isInfinite || this._sign === 0) return this;
-    const digits2 = this._coefficient.toString();
-    if (digits2.length <= precision) return this;
-    const digitsToRemove = digits2.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");
+  isZero() {
+    return this.numerator === 0n;
   }
-  trunc() {
-    return this.round(0, "down");
+  /**
+   * Check if this is positive
+   */
+  isPositive() {
+    return this.numerator > 0n;
   }
   /**
-   * Round to `n` significant decimal digits and return a new BigNumber.
-   * Delegates to `roundToPrecision`, using the global rounding mode unless
-   * an explicit `roundingMode` is supplied.
-   *
-   * Named `toSignificantDigits` for Decimal.js / mathjs formatter compatibility.
-   * When `n` is undefined the value is returned unchanged (no rounding).
+   * Check if this is negative
    */
-  toSignificantDigits(n, roundingMode) {
-    if (n === void 0) return this.clone();
-    return this.roundToPrecision(n, roundingMode ?? globalConfig.rounding);
+  isNegative() {
+    return this.numerator < 0n;
   }
   /**
-   * The decimal exponent of this number: `floor(log10(|x|))`.
-   *
-   * Matches Decimal.js semantics:
-   *   - `12345` → `4`   (5 digits → the most-significant place is 10^4)
-   *   - `0.0123` → `-2`  (first significant digit is at 10^-2)
-   *   - `100` → `2`
-   *   - `0.01` → `-2`
-   *   - `0` → `0`        (by convention; `isZero()` can be used to distinguish)
-   *
-   * For special values (NaN, ±Infinity) returns 0 — callers check
-   * `isFinite()` / `isNaN()` before using `.e`.
+   * Check if this is an integer
    */
-  get e() {
-    if (this._isNaN || this._isInfinite || this._sign === 0) return 0;
-    const d = this._coefficient.toString().length;
-    return d - 1 + this._exponent;
+  isInteger() {
+    return this.denominator === 1n;
   }
-  // ============================================================
-  // Modular Arithmetic
-  // ============================================================
   /**
-   * Modulo (remainder after division)
-   * Result has the same sign as the dividend (this).
+   * Check if this is a unit fraction (1/n)
    */
-  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));
+  isUnit() {
+    return this.numerator === 1n || this.numerator === -1n;
   }
-  // ============================================================
-  // Trigonometric Functions
-  // ============================================================
   /**
-   * Sine of this BigNumber (in radians)
-   * Uses Taylor series: sin(x) = x - x^3/3! + x^5/5! - ...
+   * Floor: largest integer ≤ this
    */
-  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();
+  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);
   }
   /**
-   * Cosine of this BigNumber (in radians)
-   * Uses Taylor series: cos(x) = 1 - x^2/2! + x^4/4! - ...
+   * Ceiling: smallest integer ≥ this
    */
-  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();
+  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);
   }
   /**
-   * Tangent of this BigNumber (in radians)
-   * tan(x) = sin(x) / cos(x)
+   * Round to nearest integer
    */
-  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());
+  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;
   }
   /**
-   * Arcsine of this BigNumber
-   * Returns value in [-PI/2, PI/2]
+   * Truncate (round toward zero)
    */
-  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();
+  trunc() {
+    return new _Fraction(this.numerator / this.denominator, 1n);
   }
   /**
-   * Two-argument arctangent: atan2(y, x)
-   * this = y, argument = x
-   * Returns angle in (-PI, PI]
+   * Get the sign: -1, 0, or 1
    */
-  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);
-    }
+  sign() {
+    if (this.numerator < 0n) return -1;
+    if (this.numerator > 0n) return 1;
+    return 0;
   }
-  // ============================================================
-  // Hyperbolic Functions
-  // ============================================================
   /**
-   * Hyperbolic sine: sinh(x) = (e^x - e^(-x)) / 2
+   * Clone this fraction
    */
-  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));
+  clone() {
+    return new _Fraction(this.numerator, this.denominator);
   }
   /**
-   * Hyperbolic cosine: cosh(x) = (e^x + e^(-x)) / 2
+   * Get the GCD of numerator and denominator (always 1 since we reduce)
    */
-  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));
+  gcd() {
+    return 1n;
   }
   /**
-   * Hyperbolic tangent: tanh(x) = sinh(x) / cosh(x)
+   * Get continued fraction representation
    */
-  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));
+  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;
   }
   /**
-   * Inverse hyperbolic sine: asinh(x) = ln(x + sqrt(x^2 + 1))
+   * Create fraction from continued fraction
    */
-  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();
+  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);
   }
   /**
-   * Inverse hyperbolic cosine: acosh(x) = ln(x + sqrt(x^2 - 1))
-   * Domain: x >= 1
+   * Mediant of two fractions: (a+c)/(b+d)
+   * Used in Stern-Brocot tree and Farey sequences
    */
-  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();
+  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 isBigNumber2(value) {
+  return value instanceof BigNumber;
+}
+var defaultConfig = {
+  precision: 64,
+  rounding: "halfUp",
+  minExponent: -1e9,
+  maxExponent: 1e9
+};
+var globalConfig = { ...defaultConfig };
+var BigNumber = class _BigNumber {
+  type = "BigNumber";
   /**
-   * Inverse hyperbolic tangent: atanh(x) = 0.5 * ln((1+x)/(1-x))
-   * Domain: -1 < x < 1
+   * Duck-typing marker for Decimal.js / mathjs formatter compatibility.
+   * Allows external code that checks `obj.isBigNumber === true` to identify
+   * this class without an `instanceof` check.
    */
-  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);
+  isBigNumber = true;
+  // Internal representation: sign * coefficient * 10^exponent
+  _sign;
+  _coefficient;
+  // Absolute value, normalized
+  _exponent;
+  // Power of 10
+  // Special values
+  _isNaN = false;
+  _isInfinite = false;
+  constructor(sign2, coefficient, exponent, isNaN2 = false, isInfinite = false) {
+    this._sign = sign2;
+    this._coefficient = coefficient;
+    this._exponent = exponent;
+    this._isNaN = isNaN2;
+    this._isInfinite = isInfinite;
   }
   // ============================================================
-  // Transcendental Functions
+  // Static Factory Methods
   // ============================================================
   /**
-   * 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.
+   * Create a BigNumber from a number
    */
-  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));
+  static fromNumber(n) {
+    if (Number.isNaN(n)) {
+      return new _BigNumber(0, 0n, 0, true, false);
     }
-    const divisor = _BigNumber.fromNumber(2).pow(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;
+    if (!Number.isFinite(n)) {
+      return new _BigNumber(n > 0 ? 1 : -1, 0n, 0, false, true);
     }
-    for (let i = 0; i < k; i++) {
-      sum = sum.multiply(sum);
+    if (n === 0) {
+      return new _BigNumber(0, 0n, 0);
     }
-    return sum.roundToPrecision(precision);
+    return _BigNumber.parse(n.toString());
   }
   /**
-   * 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)
+   * Create a BigNumber from a string
    */
-  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++;
+  static parse(str) {
+    str = str.trim().toLowerCase();
+    if (str === "nan") {
+      return new _BigNumber(0, 0n, 0, true, false);
     }
-    while (x.compareTo(half) < 0) {
-      x = x.multiply(two);
-      k--;
+    if (str === "infinity" || str === "+infinity") {
+      return new _BigNumber(1, 0n, 0, false, true);
     }
-    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;
+    if (str === "-infinity") {
+      return new _BigNumber(-1, 0n, 0, false, true);
     }
-    sum = sum.multiply(two);
-    if (k !== 0) {
-      sum = sum.add(BIGNUMBER_LN2.multiply(_BigNumber.fromNumber(k)));
+    let sign2 = 1;
+    if (str.startsWith("-")) {
+      sign2 = -1;
+      str = str.slice(1);
+    } else if (str.startsWith("+")) {
+      str = str.slice(1);
     }
-    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();
+    let exponentPart = 0;
+    const eIndex = str.indexOf("e");
+    if (eIndex !== -1) {
+      exponentPart = parseInt(str.slice(eIndex + 1), 10);
+      str = str.slice(0, eIndex);
     }
-    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);
+    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;
       }
-      guess = newGuess;
     }
-    return guess.roundToPrecision(precision);
+    if (trailingZeros > 0) {
+      coefficient = coefficient.slice(0, -trailingZeros);
+    }
+    const finalExponent = exponentPart - decimalPlaces + trailingZeros;
+    return new _BigNumber(sign2, BigInt(coefficient), finalExponent);
   }
   /**
-   * 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! + ...
+   * Create from bigint
    */
-  expm1() {
-    if (this._isNaN) return this;
-    if (this._sign === 0) return this;
-    if (this._isInfinite) {
-      return this._sign === 1 ? this : _BigNumber.fromNumber(-1);
+  static fromBigInt(n) {
+    if (n === 0n) {
+      return new _BigNumber(0, 0n, 0);
     }
-    if (Math.abs(this.valueOf()) > 0.5) {
-      return this.exp().subtract(_BigNumber.fromNumber(1));
+    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;
+      }
     }
-    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;
+    if (trailingZeros > 0) {
+      str = str.slice(0, -trailingZeros);
     }
-    return sum.roundToPrecision(precision);
+    return new _BigNumber(sign2, BigInt(str), trailingZeros);
   }
   /**
-   * ln(1 + x) (more precise than ln(1 + x) for small x)
+   * Create a BigNumber from a JSON object
    */
-  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();
+  static fromJSON(json) {
+    return _BigNumber.parse(json.value);
   }
   /**
-   * Hypotenuse: sqrt(this^2 + other^2)
+   * Get/set global configuration
    */
-  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);
+  static config(newConfig) {
+    if (newConfig) {
+      globalConfig = { ...globalConfig, ...newConfig };
     }
-    return reduced;
+    return { ...globalConfig };
   }
-  /** 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);
+  /**
+   * Reset configuration to defaults
+   */
+  static resetConfig() {
+    globalConfig = { ...defaultConfig };
   }
-  /** 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;
+  /**
+   * 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;
     }
-    return sum.roundToPrecision(precision);
+    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;
   }
-  /** 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;
+  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;
     }
-    return sum.roundToPrecision(precision);
+    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;
   }
   // ============================================================
-  // Utility Methods
+  // Conversion Methods
   // ============================================================
-  isNaN() {
-    return this._isNaN;
-  }
-  isFinite() {
-    return !this._isNaN && !this._isInfinite;
+  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);
   }
-  isInfinite() {
-    return this._isInfinite;
-  }
-  isZero() {
-    return this._sign === 0 && !this._isNaN;
-  }
-  isPositive() {
-    return this._sign === 1;
+  /**
+   * Convert to a JS number.
+   * Alias for `valueOf()` — provided for Decimal.js / mathjs formatter
+   * duck-typing compatibility.
+   */
+  toNumber() {
+    return this.valueOf();
   }
-  isNegative() {
-    return this._sign === -1;
+  toString() {
+    if (this._isNaN) return "NaN";
+    if (this._isInfinite) return this._sign === 1 ? "Infinity" : "-Infinity";
+    if (this._sign === 0) return "0";
+    const sign2 = this._sign === -1 ? "-" : "";
+    const digits2 = this._coefficient.toString();
+    if (this._exponent >= 0) {
+      return sign2 + digits2 + "0".repeat(this._exponent);
+    } else if (-this._exponent < digits2.length) {
+      const insertPos = digits2.length + this._exponent;
+      return sign2 + digits2.slice(0, insertPos) + "." + digits2.slice(insertPos);
+    } else {
+      return sign2 + "0." + "0".repeat(-this._exponent - digits2.length) + digits2;
+    }
   }
-  isInteger() {
-    if (this._isNaN || this._isInfinite || this._sign === 0) return this._sign === 0;
-    return this._exponent >= 0;
+  toJSON() {
+    return {
+      mathjs: "BigNumber",
+      value: this.toString()
+    };
   }
-  sign() {
-    return this._sign;
+  /**
+   * Convert to fixed-point notation.
+   *
+   * When called with no argument (or `undefined`) returns the full fixed-point
+   * string representation without rounding — matching Decimal.js semantics where
+   * `toFixed()` is equivalent to a lossless fixed-point stringify.
+   * When called with a non-negative integer `decimalPlaces`, rounds and formats
+   * to exactly that many digits after the decimal point.
+   */
+  toFixed(decimalPlaces) {
+    if (decimalPlaces === void 0) {
+      return this.toFixedInternal(void 0);
+    }
+    return this.round(decimalPlaces).toFixedInternal(decimalPlaces);
   }
-  clone() {
-    return new _BigNumber(
-      this._sign,
-      this._coefficient,
-      this._exponent,
-      this._isNaN,
-      this._isInfinite
-    );
+  toFixedInternal(decimalPlaces) {
+    if (this._isNaN) return "NaN";
+    if (this._isInfinite) return this._sign === 1 ? "Infinity" : "-Infinity";
+    const dp = decimalPlaces ?? -1;
+    const allDigits = dp < 0;
+    if (this._sign === 0) return allDigits ? "0" : dp > 0 ? "0." + "0".repeat(dp) : "0";
+    const sign2 = this._sign === -1 ? "-" : "";
+    const digits2 = this._coefficient.toString();
+    if (this._exponent >= 0) {
+      const intPart = digits2 + "0".repeat(this._exponent);
+      if (allDigits) return sign2 + intPart;
+      return sign2 + intPart + (dp > 0 ? "." + "0".repeat(dp) : "");
+    } else if (-this._exponent <= digits2.length) {
+      const insertPos = digits2.length + this._exponent;
+      const intPart = digits2.slice(0, insertPos) || "0";
+      const decPart = digits2.slice(insertPos);
+      if (allDigits) {
+        return sign2 + intPart + (decPart.length > 0 ? "." + decPart : "");
+      }
+      let paddedDec = decPart;
+      if (paddedDec.length < dp) {
+        paddedDec += "0".repeat(dp - paddedDec.length);
+      }
+      return sign2 + intPart + (dp > 0 ? "." + paddedDec.slice(0, dp) : "");
+    } else {
+      const leadingZeros = -this._exponent - digits2.length;
+      const decPart = "0".repeat(leadingZeros) + digits2;
+      if (allDigits) {
+        return sign2 + "0." + decPart;
+      }
+      let paddedDec = decPart;
+      if (paddedDec.length < dp) {
+        paddedDec += "0".repeat(dp - paddedDec.length);
+      }
+      return sign2 + "0" + (dp > 0 ? "." + paddedDec.slice(0, dp) : "");
+    }
   }
-  // ============================================================
-  // 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()));
+  /**
+   * 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 sign2 = this._sign === -1 ? "-" : "";
+    const digits2 = this._coefficient.toString();
+    const exp = digits2.length - 1 + this._exponent;
+    const expSign = exp >= 0 ? "+" : "";
+    if (decimalPlaces === void 0) {
+      if (digits2.length === 1) {
+        return `${sign2}${digits2}e${expSign}${exp}`;
+      }
+      return `${sign2}${digits2[0]}.${digits2.slice(1)}e${expSign}${exp}`;
+    }
+    if (decimalPlaces === 0) {
+      return `${sign2}${digits2[0]}e${expSign}${exp}`;
+    }
+    let decPart = digits2.slice(1);
+    if (decPart.length < decimalPlaces) {
+      decPart += "0".repeat(decimalPlaces - decPart.length);
+    } else {
+      decPart = decPart.slice(0, decimalPlaces);
+    }
+    return `${sign2}${digits2[0]}.${decPart}e${expSign}${exp}`;
   }
-  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];
+  /**
+   * 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 digits2 = this._coefficient.toString();
+    const order = digits2.length + this._exponent;
+    if (order > significantDigits || order < -6) {
+      return this.toExponential(significantDigits - 1);
+    }
+    return this.toFixed(significantDigits - order);
   }
-  normalize(sign2, coefficient, exponent) {
-    if (coefficient === 0n) {
-      return new _BigNumber(0, 0n, 0);
+  /**
+   * Convert to bigint (truncated)
+   */
+  toBigInt() {
+    if (this._isNaN || this._isInfinite) {
+      throw new Error("Cannot convert NaN or Infinity to bigint");
     }
-    let coef = coefficient;
-    let exp = exponent;
-    while (coef % 10n === 0n && coef !== 0n) {
-      coef = coef / 10n;
-      exp++;
+    if (this._sign === 0) return 0n;
+    const digits2 = this._coefficient.toString();
+    if (this._exponent >= 0) {
+      return BigInt(this._sign) * BigInt(digits2 + "0".repeat(this._exponent));
+    } else if (-this._exponent < digits2.length) {
+      return BigInt(this._sign) * BigInt(digits2.slice(0, digits2.length + this._exponent));
     }
-    return new _BigNumber(sign2, coef, exp);
+    return 0n;
   }
-};
-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/is.ts
-function hasPrototypeFlag(x, flag) {
-  return !!x && x.constructor.prototype[flag] === true;
-}
-function hasOwnAndPrototypeFlag(x, ownFlag, protoFlag) {
-  return !!x && x[ownFlag] === true && x.constructor.prototype[protoFlag] === true;
-}
-function isNumber(x) {
-  return typeof x === "number";
-}
-function isBigNumber2(x) {
-  if (!x || typeof x !== "object" || typeof x.constructor !== "function") {
-    return false;
+  /**
+   * Binary string representation, e.g. `255 -> '0b11111111'`, `0.5 -> '0b0.1'`.
+   * Mirrors Decimal.js `toBinary()`. Negatives carry a leading `-`.
+   */
+  toBinary() {
+    return this.toRadixString(2, "0b");
   }
-  const obj = x;
-  if (obj.isBigNumber === true && typeof obj.constructor.prototype === "object" && obj.constructor.prototype.isBigNumber === true) {
-    return true;
+  /**
+   * Octal string representation, e.g. `8 -> '0o10'`.
+   * Mirrors Decimal.js `toOctal()`.
+   */
+  toOctal() {
+    return this.toRadixString(8, "0o");
   }
-  if (typeof obj.constructor.isDecimal === "function" && obj.constructor.isDecimal(obj) === true) {
-    return true;
+  /**
+   * Hexadecimal string representation, e.g. `255 -> '0xff'`, `10.5 -> '0xa.8'`.
+   * Mirrors Decimal.js `toHexadecimal()`.
+   */
+  toHexadecimal() {
+    return this.toRadixString(16, "0x");
   }
-  return false;
-}
-function isBigInt(x) {
-  return typeof x === "bigint";
-}
-function isComplex2(x) {
-  return !!(x && typeof x === "object" && Object.getPrototypeOf(x).isComplex === true);
-}
-function isFraction2(x) {
-  return !!(x && typeof x === "object" && Object.getPrototypeOf(x).isFraction === true);
-}
-function isUnit(x) {
-  return hasPrototypeFlag(x, "isUnit");
-}
-function isString(x) {
-  return typeof x === "string";
-}
-var isArray = Array.isArray;
-function isMatrix(x) {
-  return hasPrototypeFlag(x, "isMatrix");
-}
-function isCollection(x) {
-  return Array.isArray(x) || isMatrix(x);
-}
-function isDenseMatrix(x) {
-  return hasOwnAndPrototypeFlag(x, "isDenseMatrix", "isMatrix");
-}
-function isSparseMatrix(x) {
-  return hasOwnAndPrototypeFlag(x, "isSparseMatrix", "isMatrix");
-}
-function isRange(x) {
-  return hasPrototypeFlag(x, "isRange");
-}
-function isIndex(x) {
-  return hasPrototypeFlag(x, "isIndex");
-}
-function isBoolean(x) {
-  return typeof x === "boolean";
-}
-function isFunction(x) {
-  return typeof x === "function";
-}
-function isDate(x) {
-  return x instanceof Date;
-}
-function isRegExp(x) {
-  return x instanceof RegExp;
-}
-function isObject(x) {
-  return !!(x && typeof x === "object" && x.constructor === Object && !isComplex2(x) && !isFraction2(x));
-}
-function isMap(object) {
-  if (!object) {
-    return false;
-  }
-  const o = object;
-  return object instanceof Map || typeof o.set === "function" && typeof o.get === "function" && typeof o.keys === "function" && typeof o.has === "function";
-}
-function isNull(x) {
-  return x === null;
-}
-function isUndefined(x) {
-  return x === void 0;
-}
-function typeOf(x) {
-  const t = typeof x;
-  if (t === "object") {
-    if (x === null) return "null";
-    if (isBigNumber2(x)) return "BigNumber";
-    if (isComplex2(x)) return "Complex";
-    if (isFraction2(x)) return "Fraction";
-    const ctor = x.constructor;
-    if (ctor && ctor.name) return ctor.name;
-    return "Object";
-  }
-  return t;
-}
-
-// src/number.ts
-function isInteger(value) {
-  if (typeof value === "boolean") {
-    return true;
+  /**
+   * Shared radix formatter for {@link toBinary}/{@link toOctal}/{@link toHexadecimal}.
+   * Integers and terminating fractions are exact; a non-terminating fraction is
+   * truncated at `maxFractionDigits` radix digits (a safety bound — the common
+   * use is integer formatting).
+   */
+  toRadixString(radix, prefix, maxFractionDigits = 1100) {
+    if (this._isNaN) return "NaN";
+    if (this._isInfinite) return (this._sign < 0 ? "-" : "") + "Infinity";
+    if (this._sign === 0) return prefix + "0";
+    const negative = this._sign < 0;
+    const absVal = this.abs();
+    const intPart = absVal.toBigInt();
+    let out = prefix + intPart.toString(radix);
+    let frac = absVal.subtract(_BigNumber.fromBigInt(intPart));
+    if (!frac.isZero()) {
+      const radixBN = _BigNumber.fromNumber(radix);
+      let digits2 = "";
+      for (let i = 0; i < maxFractionDigits && !frac.isZero(); i++) {
+        frac = frac.multiply(radixBN);
+        const digit = frac.toBigInt();
+        digits2 += Number(digit).toString(radix);
+        frac = frac.subtract(_BigNumber.fromBigInt(digit));
+      }
+      out += "." + digits2;
+    }
+    return (negative ? "-" : "") + out;
   }
-  return isFinite(value) ? value === Math.round(value) : false;
-}
-function safeNumberType(numberStr, config2) {
-  if (config2.number === "bigint") {
-    try {
-      BigInt(numberStr);
-    } catch {
-      return config2.numberFallback;
+  // ============================================================
+  // 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);
+      }
     }
   }
-  return config2.number;
-}
-var sign = Math.sign || function(x) {
-  if (x > 0) {
-    return 1;
-  } else if (x < 0) {
-    return -1;
-  } else {
-    return 0;
+  /**
+   * Subtraction
+   */
+  subtract(other) {
+    const b = this.ensureBigNumber(other);
+    return this.add(b.negate());
   }
-};
-var log2 = Math.log2 || function log22(x) {
-  return Math.log(x) / Math.LN2;
-};
-var log10 = Math.log10 || function log102(x) {
-  return Math.log(x) / Math.LN10;
-};
-var log1p = Math.log1p || function(x) {
-  return Math.log(x + 1);
-};
-var cbrt = Math.cbrt || function cbrt2(x) {
-  if (x === 0) {
-    return x;
+  /**
+   * Alias for subtract — mathjs / Decimal.js compatibility.
+   */
+  sub(other) {
+    return this.subtract(other);
   }
-  const negate = x < 0;
-  let result;
-  if (negate) {
-    x = -x;
+  /**
+   * 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 sign3 = this._sign * b._sign;
+      return new _BigNumber(sign3, 0n, 0, false, true);
+    }
+    if (this._sign === 0 || b._sign === 0) return new _BigNumber(0, 0n, 0);
+    const sign2 = this._sign * b._sign;
+    const coefficient = this._coefficient * b._coefficient;
+    const exponent = this._exponent + b._exponent;
+    return this.normalize(sign2, coefficient, exponent);
   }
-  if (isFinite(x)) {
-    result = Math.exp(Math.log(x) / 3);
-    result = (x / (result * result) + 2 * result) / 3;
-  } else {
-    result = x;
+  /**
+   * Alias for multiply — mathjs / Decimal.js compatibility.
+   */
+  mul(other) {
+    return this.multiply(other);
   }
-  return negate ? -result : result;
-};
-var expm1 = Math.expm1 || function expm12(x) {
-  return x >= 2e-4 || x <= -2e-4 ? Math.exp(x) - 1 : x + x * x / 2 + x * x * x / 6;
-};
-function formatNumberToBase(n, base, size) {
-  const prefixes = { 2: "0b", 8: "0o", 16: "0x" };
-  const prefix = prefixes[base];
-  let suffix = "";
-  if (size) {
-    if (size < 1) {
-      throw new Error("size must be in greater than 0");
-    }
-    if (!isInteger(size)) {
-      throw new Error("size must be an integer");
-    }
-    if (n > 2 ** (size - 1) - 1 || n < -(2 ** (size - 1))) {
-      throw new Error(`Value must be in range [-2^${size - 1}, 2^${size - 1}-1]`);
-    }
-    if (!isInteger(n)) {
-      throw new Error("Value must be an integer");
+  /**
+   * Alias for multiply — Decimal.js calling convention (used by the Unit).
+   */
+  times(other) {
+    return this.multiply(other);
+  }
+  /**
+   * 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 (n < 0) {
-      n = n + 2 ** size;
+    if (this._isInfinite) {
+      const sign3 = this._sign * b._sign;
+      return new _BigNumber(sign3, 0n, 0, false, true);
     }
-    suffix = `i${size}`;
+    if (b._isInfinite) return new _BigNumber(0, 0n, 0);
+    if (this._sign === 0) return new _BigNumber(0, 0n, 0);
+    const sign2 = 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(sign2, quotient, exponent).roundToPrecision(precision);
   }
-  let sign2 = "";
-  if (n < 0) {
-    n = -n;
-    sign2 = "-";
+  /**
+   * Alias for divide — Decimal.js calling convention (used by the Unit).
+   */
+  div(other) {
+    return this.divide(other);
   }
-  return `${sign2}${prefix}${n.toString(base)}${suffix}`;
-}
-function format(value, options) {
-  if (typeof options === "function") {
-    return options(value);
+  /**
+   * 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);
   }
-  if (value === Infinity) {
-    return "Infinity";
-  } else if (value === -Infinity) {
-    return "-Infinity";
-  } else if (isNaN(value)) {
-    return "NaN";
-  }
-  const { notation, precision, wordSize } = normalizeFormatOptions(options);
-  switch (notation) {
-    case "fixed":
-      return toFixed(value, precision);
-    case "exponential":
-      return toExponential(value, precision);
-    case "engineering":
-      return toEngineering(value, precision);
-    case "bin":
-      return formatNumberToBase(value, 2, wordSize);
-    case "oct":
-      return formatNumberToBase(value, 8, wordSize);
-    case "hex":
-      return formatNumberToBase(value, 16, wordSize);
-    case "auto":
-      return toPrecision(value, precision, options).replace(
-        /((\.\d*?)(0+))($|e)/,
-        function(_match, _all, digits2, _zeros, e) {
-          return digits2 !== "." ? digits2 + e : e;
-        }
-      );
-    default:
-      throw new Error(
-        'Unknown notation "' + notation + '". Choose "auto", "exponential", "fixed", "bin", "oct", or "hex.'
-      );
+  /**
+   * 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);
   }
-}
-function normalizeFormatOptions(options) {
-  let notation = "auto";
-  let precision;
-  let wordSize;
-  if (options !== void 0) {
-    if (isNumber(options)) {
-      precision = options;
-    } else if (isBigNumber2(options)) {
-      precision = options.toNumber();
-    } else if (isObject(options)) {
-      if (options.precision !== void 0) {
-        precision = _toNumberOrThrow(options.precision, () => {
-          throw new Error('Option "precision" must be a number or BigNumber');
-        });
-      }
-      if (options.wordSize !== void 0) {
-        wordSize = _toNumberOrThrow(options.wordSize, () => {
-          throw new Error('Option "wordSize" must be a number or BigNumber');
-        });
-      }
-      if (options.notation) {
-        notation = options.notation;
+  /**
+   * 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.clone();
+    let e = exp;
+    while (e > 0) {
+      if (e % 2 === 1) {
+        result = result.multiply(base);
       }
-    } else {
-      throw new Error("Unsupported type of options, number, BigNumber, or object expected");
+      base = base.multiply(base);
+      e = Math.floor(e / 2);
     }
+    return result.roundToPrecision(globalConfig.precision);
   }
-  return { notation, precision, wordSize };
-}
-function splitNumber(value) {
-  const match = String(value).toLowerCase().match(/^(-?)(\d+\.?\d*)(e([+-]?\d+))?$/);
-  if (!match) {
-    throw new SyntaxError("Invalid number " + value);
-  }
-  const sign2 = match[1];
-  const digits2 = match[2];
-  let exponent = parseFloat(match[4] || "0");
-  const dot = digits2.indexOf(".");
-  exponent += dot !== -1 ? dot - 1 : digits2.length - 1;
-  const coefficients = digits2.replace(".", "").replace(/^0*/, function(zeros2) {
-    exponent -= zeros2.length;
-    return "";
-  }).replace(/0*$/, "").split("").map(function(d) {
-    return parseInt(d);
-  });
-  if (coefficients.length === 0) {
-    coefficients.push(0);
-    exponent++;
-  }
-  return { sign: sign2, coefficients, exponent };
-}
-function toEngineering(value, precision) {
-  if (isNaN(value) || !isFinite(value)) {
-    return String(value);
-  }
-  const split = splitNumber(value);
-  const rounded = roundDigits(split, precision);
-  const e = rounded.exponent;
-  const c = rounded.coefficients;
-  const newExp = e % 3 === 0 ? e : e < 0 ? e - 3 - e % 3 : e - e % 3;
-  if (isNumber(precision)) {
-    while (precision > c.length || e - newExp + 1 > c.length) {
-      c.push(0);
-    }
-  } else {
-    const missingZeros = Math.abs(e - newExp) - (c.length - 1);
-    for (let i = 0; i < missingZeros; i++) {
-      c.push(0);
+  /**
+   * 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);
   }
-  let expDiff = Math.abs(e - newExp);
-  let decimalIdx = 1;
-  while (expDiff > 0) {
-    decimalIdx++;
-    expDiff--;
+  // ============================================================
+  // Comparison Methods
+  // ============================================================
+  equals(other) {
+    return _BigNumber.compare(this, other) === 0;
   }
-  const decimals = c.slice(decimalIdx).join("");
-  const decimalVal = isNumber(precision) && decimals.length || decimals.match(/[1-9]/) ? "." + decimals : "";
-  const str = c.slice(0, decimalIdx).join("") + decimalVal + "e" + (e >= 0 ? "+" : "") + newExp.toString();
-  return rounded.sign + str;
-}
-function toFixed(value, precision) {
-  if (isNaN(value) || !isFinite(value)) {
-    return String(value);
+  lessThan(other) {
+    return _BigNumber.compare(this, other) < 0;
   }
-  const splitValue = splitNumber(value);
-  const rounded = typeof precision === "number" ? roundDigits(splitValue, splitValue.exponent + 1 + precision) : splitValue;
-  let c = rounded.coefficients;
-  let p = rounded.exponent + 1;
-  const pp = p + (precision || 0);
-  if (c.length < pp) {
-    c = c.concat(zeros(pp - c.length));
+  lessThanOrEqual(other) {
+    return _BigNumber.compare(this, other) <= 0;
   }
-  if (p < 0) {
-    c = zeros(-p + 1).concat(c);
-    p = 1;
+  greaterThan(other) {
+    return _BigNumber.compare(this, other) > 0;
   }
-  if (p < c.length) {
-    c.splice(p, 0, p === 0 ? "0." : ".");
+  greaterThanOrEqual(other) {
+    return _BigNumber.compare(this, other) >= 0;
   }
-  return rounded.sign + c.join("");
-}
-function toExponential(value, precision) {
-  if (isNaN(value) || !isFinite(value)) {
-    return String(value);
+  compareTo(other) {
+    return _BigNumber.compare(this, other);
   }
-  const split = splitNumber(value);
-  const rounded = precision ? roundDigits(split, precision) : split;
-  let c = rounded.coefficients;
-  const e = rounded.exponent;
-  if (precision && c.length < precision) {
-    c = c.concat(zeros(precision - c.length));
+  compare(other) {
+    return this.compareTo(other);
   }
-  const first = c.shift();
-  return rounded.sign + first + (c.length > 0 ? "." + c.join("") : "") + "e" + (e >= 0 ? "+" : "") + e;
-}
-function toPrecision(value, precision, options) {
-  if (isNaN(value) || !isFinite(value)) {
-    return String(value);
+  /**
+   * Returns true iff this > other.
+   * Accepts the same argument types as `add`/`multiply` (BigNumber, number, or string).
+   * Named `gt` for Decimal.js / mathjs formatter compatibility.
+   */
+  gt(other) {
+    return this.greaterThan(this.ensureBigNumber(other));
   }
-  const lowerExp = _toNumberOrDefault(options?.lowerExp, -3);
-  const upperExp = _toNumberOrDefault(options?.upperExp, 5);
-  const split = splitNumber(value);
-  const rounded = precision ? roundDigits(split, precision) : split;
-  if (rounded.exponent < lowerExp || rounded.exponent >= upperExp) {
-    return toExponential(value, precision);
-  } else {
-    let c = rounded.coefficients;
-    const e = rounded.exponent;
-    if (precision && c.length < precision) {
-      c = c.concat(zeros(precision - c.length));
-    }
-    c = c.concat(
-      zeros(e - c.length + 1 + (precision && c.length < precision ? precision - c.length : 0))
-    );
-    c = zeros(-e).concat(c);
-    const dot = e > 0 ? e : 0;
-    if (dot < c.length - 1) {
-      c.splice(dot + 1, 0, ".");
+  // ============================================================
+  // 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 rounded.sign + c.join("");
+    return this.normalize(rounded === 0n ? 0 : this._sign, rounded, targetExp);
   }
-}
-function roundDigits(split, precision) {
-  const rounded = {
-    sign: split.sign,
-    coefficients: split.coefficients.slice(),
-    exponent: split.exponent
-  };
-  const c = rounded.coefficients;
-  if (precision !== void 0) {
-    while (precision <= 0) {
-      c.unshift(0);
-      rounded.exponent++;
-      precision++;
+  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;
     }
-    if (c.length > precision) {
-      const removed = c.splice(precision, c.length - precision);
-      if (removed[0] >= 5) {
-        let i = precision - 1;
-        c[i]++;
-        while (c[i] === 10) {
-          c.pop();
-          if (i === 0) {
-            c.unshift(0);
-            rounded.exponent++;
-            i++;
-          }
-          i--;
-          c[i]++;
-        }
-      }
+  }
+  /**
+   * Round to specified precision (significant digits)
+   */
+  roundToPrecision(precision, mode = globalConfig.rounding) {
+    if (this._isNaN || this._isInfinite || this._sign === 0) return this;
+    const digits2 = this._coefficient.toString();
+    if (digits2.length <= precision) return this;
+    const digitsToRemove = digits2.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);
   }
-  return rounded;
-}
-function zeros(length) {
-  const arr = [];
-  for (let i = 0; i < length; i++) {
-    arr.push(0);
+  floor() {
+    return this.round(0, "floor");
   }
-  return arr;
-}
-function digits(value) {
-  return value.toExponential().replace(/e.*$/, "").replace(/^0\.?0*|\./, "").length;
-}
-function nearlyEqual(a, b, relTol = 1e-8, absTol = 0) {
-  if (relTol <= 0) {
-    throw new Error("Relative tolerance must be greater than 0");
+  ceil() {
+    return this.round(0, "ceil");
   }
-  if (absTol < 0) {
-    throw new Error("Absolute tolerance must be at least 0");
+  trunc() {
+    return this.round(0, "down");
   }
-  if (isNaN(a) || isNaN(b)) {
-    return false;
+  /**
+   * Round to `n` significant decimal digits and return a new BigNumber.
+   * Delegates to `roundToPrecision`, using the global rounding mode unless
+   * an explicit `roundingMode` is supplied.
+   *
+   * Named `toSignificantDigits` for Decimal.js / mathjs formatter compatibility.
+   * When `n` is undefined the value is returned unchanged (no rounding).
+   */
+  toSignificantDigits(n, roundingMode) {
+    if (n === void 0) return this.clone();
+    return this.roundToPrecision(n, roundingMode ?? globalConfig.rounding);
   }
-  if (!isFinite(a) || !isFinite(b)) {
-    return a === b;
+  /**
+   * The decimal exponent of this number: `floor(log10(|x|))`.
+   *
+   * Matches Decimal.js semantics:
+   *   - `12345` → `4`   (5 digits → the most-significant place is 10^4)
+   *   - `0.0123` → `-2`  (first significant digit is at 10^-2)
+   *   - `100` → `2`
+   *   - `0.01` → `-2`
+   *   - `0` → `0`        (by convention; `isZero()` can be used to distinguish)
+   *
+   * For special values (NaN, ±Infinity) returns 0 — callers check
+   * `isFinite()` / `isNaN()` before using `.e`.
+   */
+  get e() {
+    if (this._isNaN || this._isInfinite || this._sign === 0) return 0;
+    const d = this._coefficient.toString().length;
+    return d - 1 + this._exponent;
   }
-  if (a === b) {
-    return true;
+  // ============================================================
+  // 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));
   }
-  return Math.abs(a - b) <= Math.max(relTol * Math.max(Math.abs(a), Math.abs(b)), absTol);
-}
-var acosh = Math.acosh || function(x) {
-  return Math.log(Math.sqrt(x * x - 1) + x);
-};
-var asinh = Math.asinh || function(x) {
-  return Math.log(Math.sqrt(x * x + 1) + x);
-};
-var atanh = Math.atanh || function(x) {
-  return Math.log((1 + x) / (1 - x)) / 2;
-};
-var cosh = Math.cosh || function(x) {
-  return (Math.exp(x) + Math.exp(-x)) / 2;
-};
-var sinh = Math.sinh || function(x) {
-  return (Math.exp(x) - Math.exp(-x)) / 2;
-};
-var tanh = Math.tanh || function(x) {
-  const e = Math.exp(2 * x);
-  return (e - 1) / (e + 1);
-};
-function copysign(x, y) {
-  const signx = x > 0 ? true : x < 0 ? false : 1 / x === Infinity;
-  const signy = y > 0 ? true : y < 0 ? false : 1 / y === Infinity;
-  return signx !== signy ? -x : x;
-}
-function isPowZeroAtInfinity(x, y) {
-  return x * x < 1 && y === Infinity || x * x > 1 && y === -Infinity;
-}
-function _toNumberOrThrow(value, onError) {
-  if (isNumber(value)) {
-    return value;
-  } else if (isBigNumber2(value)) {
-    return value.toNumber();
-  } else {
-    onError();
-    return 0;
+  // ============================================================
+  // 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();
   }
-}
-function _toNumberOrDefault(value, defaultValue) {
-  if (isNumber(value)) {
-    return value;
-  } else if (isBigNumber2(value)) {
-    return value.toNumber();
-  } else {
-    return defaultValue;
+  /**
+   * 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();
   }
-}
-
-// src/config.ts
-var DEFAULT_CONFIG = {
-  // minimum relative difference between two compared values,
-  // used by all comparison functions
-  relTol: 1e-12,
-  // minimum absolute difference between two compared values,
-  // used by all comparison functions
-  absTol: 1e-15,
-  // type of default matrix output. Choose 'matrix' (default) or 'array'
-  matrix: "Matrix",
-  // type of default number output. Choose 'number' (default) 'BigNumber', 'bigint', or 'Fraction'
-  number: "number",
-  // type of fallback used for config { number: 'bigint' } when a value cannot be represented
-  // in the configured numeric type. Choose 'number' (default) or 'BigNumber'.
-  numberFallback: "number",
-  // number of significant digits in BigNumbers
-  precision: 64,
-  // predictable output type of functions. When true, output type depends only
-  // on the input types. When false (default), output type can vary depending
-  // on input values. For example `math.sqrt(-4)` returns `complex('2i')` when
-  // predictable is false, and returns `NaN` when true.
-  predictable: false,
-  // random seed for seeded pseudo random number generation
-  // null = randomly seed
-  randomSeed: null,
-  // legacy behavior for matrix subset. When true, the subset function
-  // returns a matrix or array with the same size as the index (except for scalars).
-  // When false, it returns a matrix or array with a size depending on the type of index.
-  legacySubset: false
-};
-
-// src/arithmetic/scalar.ts
-function isPrimitive(v) {
-  return typeof v === "number" || typeof v === "bigint";
-}
-function asComplex(v) {
-  return v instanceof Complex ? v : new Complex(number(v), 0);
-}
-function asBigNumber(v) {
-  if (v instanceof BigNumber) return v;
-  if (typeof v === "bigint") return BigNumber.fromBigInt(v);
-  return BigNumber.fromNumber(number(v));
-}
-function asFraction(v) {
-  if (v instanceof Fraction) return v;
-  if (typeof v === "number" || typeof v === "bigint") return new Fraction(v);
-  return new Fraction(number(v));
-}
-function addScalar(x, y) {
-  if (typeof x === "number" && typeof y === "number") return x + y;
-  if (typeof x === "bigint" && typeof y === "bigint") return x + y;
-  if (isPrimitive(x) && isPrimitive(y)) return Number(x) + Number(y);
-  if (x instanceof Complex || y instanceof Complex) return asComplex(x).add(asComplex(y));
-  if (x instanceof BigNumber || y instanceof BigNumber) return asBigNumber(x).add(asBigNumber(y));
-  return asFraction(x).add(asFraction(y));
-}
-function subtractScalar(x, y) {
-  if (typeof x === "number" && typeof y === "number") return x - y;
-  if (typeof x === "bigint" && typeof y === "bigint") return x - y;
-  if (isPrimitive(x) && isPrimitive(y)) return Number(x) - Number(y);
-  if (x instanceof Complex || y instanceof Complex) return asComplex(x).subtract(asComplex(y));
-  if (x instanceof BigNumber || y instanceof BigNumber)
-    return asBigNumber(x).subtract(asBigNumber(y));
-  return asFraction(x).subtract(asFraction(y));
-}
-function multiplyScalar(x, y) {
-  if (typeof x === "number" && typeof y === "number") return x * y;
-  if (typeof x === "bigint" && typeof y === "bigint") return x * y;
-  if (isPrimitive(x) && isPrimitive(y)) return Number(x) * Number(y);
-  if (x instanceof Complex || y instanceof Complex) return asComplex(x).multiply(asComplex(y));
-  if (x instanceof BigNumber || y instanceof BigNumber)
-    return asBigNumber(x).multiply(asBigNumber(y));
-  return asFraction(x).multiply(asFraction(y));
-}
-function divideScalar(x, y) {
-  if (typeof x === "number" && typeof y === "number") return x / y;
-  if (typeof x === "bigint" && typeof y === "bigint") return x / y;
-  if (isPrimitive(x) && isPrimitive(y)) return Number(x) / Number(y);
-  if (x instanceof Complex || y instanceof Complex) return asComplex(x).divide(asComplex(y));
-  if (x instanceof BigNumber || y instanceof BigNumber)
-    return asBigNumber(x).divide(asBigNumber(y));
-  return asFraction(x).divide(asFraction(y));
-}
-function pow(base, exp) {
-  if (base instanceof Complex) return base.pow(exp instanceof Complex ? exp : number(exp));
-  if (base instanceof BigNumber || base instanceof Fraction) {
-    const n = typeof exp === "bigint" ? exp : number(exp);
-    if (typeof n === "bigint" || Number.isInteger(n)) return base.pow(n);
-    return Math.pow(number(base), n);
+  /**
+   * 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());
   }
-  if (typeof base === "bigint" && typeof exp === "bigint") return base ** exp;
-  return Math.pow(number(base), number(exp));
-}
-function abs(x) {
-  if (typeof x === "number") return Math.abs(x);
-  if (typeof x === "bigint") return x < 0n ? -x : x;
-  return x.abs();
-}
-function fix(x) {
-  if (typeof x === "number") return Math.trunc(x);
-  if (typeof x === "bigint") return x;
-  if (x instanceof Complex) return new Complex(Math.trunc(x.re), Math.trunc(x.im));
-  return x.sign() >= 0 ? x.floor() : x.ceil();
-}
-function round(x) {
-  if (typeof x === "number") return Math.round(x);
-  if (typeof x === "bigint") return x;
-  if (x instanceof Complex) return new Complex(Math.round(x.re), Math.round(x.im));
-  if (x instanceof BigNumber) return x.round(0, "halfCeil");
-  return x.round();
-}
-function equal(x, y, relTol = DEFAULT_CONFIG.relTol, absTol = DEFAULT_CONFIG.absTol) {
-  if (typeof x === "bigint" && typeof y === "bigint") return x === y;
-  if (isPrimitive(x) && isPrimitive(y)) return nearlyEqual(Number(x), Number(y), relTol, absTol);
-  if (x instanceof Complex || y instanceof Complex) return asComplex(x).equals(asComplex(y));
-  if (x instanceof Fraction && y instanceof Fraction) return x.equals(y);
-  if (x instanceof BigNumber && y instanceof BigNumber) return x.equals(y);
-  return nearlyEqual(number(x), number(y), relTol, absTol);
-}
-function isNumeric(x) {
-  return typeof x === "number" || typeof x === "bigint" || typeof x === "boolean" || x instanceof Fraction || x instanceof BigNumber;
-}
-function number(x) {
-  if (typeof x === "number") return x;
-  if (typeof x === "bigint") return Number(x);
-  if (x instanceof Fraction) return x.toNumber();
-  if (x instanceof BigNumber) return x.toNumber();
-  if (x.im !== 0) {
-    throw new TypeError(`Cannot convert ${x.toString()} to a number: imaginary part is nonzero`);
+  /**
+   * 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();
   }
-  return x.re;
-}
-
-// src/shared.ts
-function hasOwnProperty(object, property) {
-  return !!object && Object.hasOwnProperty.call(object, property);
-}
-function endsWith(text, search) {
-  const start = text.length - search.length;
-  return text.substring(start, text.length) === search;
-}
-var warnOnce = /* @__PURE__ */ (() => {
-  const seen = {};
-  return function warnOnce2(...args) {
-    const message = args.join(", ");
-    if (!seen[message]) {
-      seen[message] = true;
-      console.warn("Warning:", ...args);
+  /**
+   * 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);
     }
-  };
-})();
-function memoize(fn, { hasher, limit } = {}) {
-  const hash = hasher ?? ((args) => JSON.stringify(args));
-  const maxSize = limit == null ? Number.POSITIVE_INFINITY : limit;
-  const memoized = function(...args) {
-    if (!(memoized.cache instanceof Map)) {
-      memoized.cache = /* @__PURE__ */ new Map();
+    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 cache = memoized.cache;
-    const key = hash(args);
-    if (cache.has(key)) {
-      const value2 = cache.get(key);
-      cache.delete(key);
-      cache.set(key, value2);
-      return value2;
+    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));
     }
-    const value = fn.apply(fn, args);
-    cache.set(key, value);
-    if (cache.size > maxSize) {
-      cache.delete(cache.keys().next().value);
+    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).pow(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 value;
-  };
-  return memoized;
-}
-
-// src/object.ts
-function clone(x) {
-  const type = typeof x;
-  if (type === "number" || type === "bigint" || type === "string" || type === "boolean" || x === null || x === void 0) {
-    return x;
+    return sum.roundToPrecision(precision);
   }
-  const cloneable = x;
-  if (typeof cloneable.clone === "function") {
-    return cloneable.clone();
+  // ============================================================
+  // Utility Methods
+  // ============================================================
+  isNaN() {
+    return this._isNaN;
   }
-  if (Array.isArray(x)) {
-    return x.map((value) => clone(value));
+  isFinite() {
+    return !this._isNaN && !this._isInfinite;
   }
-  if (x instanceof Date) return new Date(x.valueOf());
-  if (isBigNumber2(x)) return x;
-  if (isObject(x)) {
-    return mapObject(x, clone);
+  isInfinite() {
+    return this._isInfinite;
   }
-  if (type === "function") {
-    return x;
+  isZero() {
+    return this._sign === 0 && !this._isNaN;
   }
-  throw new TypeError(`Cannot clone: unknown type of value (value: ${x})`);
-}
-function mapObject(object, callback) {
-  const clone2 = {};
-  for (const key in object) {
-    if (hasOwnProperty(object, key)) {
-      clone2[key] = callback(object[key]);
-    }
+  isPositive() {
+    return this._sign === 1;
   }
-  return clone2;
-}
-function extend(a, b) {
-  const target = a;
-  for (const prop in b) {
-    if (hasOwnProperty(b, prop)) {
-      target[prop] = b[prop];
-    }
+  isNegative() {
+    return this._sign === -1;
   }
-  return a;
-}
-function deepExtend(a, b) {
-  if (Array.isArray(b)) {
-    if (!Array.isArray(a)) {
-      throw new TypeError("Cannot extend an object with an array");
-    }
-    for (let i = 0; i < b.length; i++) {
-      const bValue = b[i];
-      if (bValue && bValue.constructor === Object) {
-        if (a[i] === void 0) {
-          a[i] = {};
-        }
-        if (a[i] && a[i].constructor === Object) {
-          deepExtend(a[i], bValue);
-        } else {
-          a[i] = bValue;
-        }
-      } else if (Array.isArray(bValue)) {
-        if (a[i] === void 0) {
-          a[i] = [];
-        }
-        if (Array.isArray(a[i])) {
-          deepExtend(a[i], bValue);
-        } else {
-          a[i] = clone(bValue);
-        }
-      } else {
-        a[i] = bValue;
-      }
-    }
-    return a;
+  isInteger() {
+    if (this._isNaN || this._isInfinite || this._sign === 0) return this._sign === 0;
+    return this._exponent >= 0;
   }
-  for (const prop in b) {
-    if (hasOwnProperty(b, prop) && !(prop in Object.prototype) && !(prop in Function.prototype)) {
-      const bValue = b[prop];
-      const aValue = a[prop];
-      if (bValue && bValue.constructor === Object) {
-        if (aValue === void 0) {
-          a[prop] = {};
-        }
-        if (aValue && aValue.constructor === Object) {
-          deepExtend(aValue, bValue);
-        } else {
-          a[prop] = bValue;
-        }
-      } else if (Array.isArray(bValue)) {
-        if (aValue === void 0) {
-          a[prop] = [];
-        }
-        if (Array.isArray(aValue)) {
-          deepExtend(aValue, bValue);
-        } else {
-          a[prop] = clone(bValue);
-        }
-      } else {
-        a[prop] = bValue;
-      }
-    }
+  sign() {
+    return this._sign;
   }
-  return a;
-}
-function deepStrictEqual(a, b) {
-  let prop;
-  let i;
-  let len;
-  if (Array.isArray(a)) {
-    if (!Array.isArray(b)) {
-      return false;
-    }
-    if (a.length !== b.length) {
-      return false;
-    }
-    for (i = 0, len = a.length; i < len; i++) {
-      if (!deepStrictEqual(a[i], b[i])) {
-        return false;
-      }
-    }
-    return true;
-  } else if (typeof a === "function") {
-    return a === b;
-  } else if (a instanceof Object) {
-    if (Array.isArray(b) || !(b instanceof Object)) {
-      return false;
-    }
-    const aObj = a;
-    const bObj = b;
-    for (prop in aObj) {
-      if (!(prop in bObj) || !deepStrictEqual(aObj[prop], bObj[prop])) {
-        return false;
-      }
+  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(sign2, coefficient, exponent) {
+    if (coefficient === 0n) {
+      return new _BigNumber(0, 0n, 0);
     }
-    for (prop in bObj) {
-      if (!(prop in aObj)) {
-        return false;
-      }
+    let coef = coefficient;
+    let exp = exponent;
+    while (coef % 10n === 0n && coef !== 0n) {
+      coef = coef / 10n;
+      exp++;
     }
-    return true;
-  } else {
-    return a === b;
+    return new _BigNumber(sign2, 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/config.ts
+var DEFAULT_CONFIG = {
+  // minimum relative difference between two compared values,
+  // used by all comparison functions
+  relTol: 1e-12,
+  // minimum absolute difference between two compared values,
+  // used by all comparison functions
+  absTol: 1e-15,
+  // type of default matrix output. Choose 'matrix' (default) or 'array'
+  matrix: "Matrix",
+  // type of default number output. Choose 'number' (default) 'BigNumber', 'bigint', or 'Fraction'
+  number: "number",
+  // type of fallback used for config { number: 'bigint' } when a value cannot be represented
+  // in the configured numeric type. Choose 'number' (default) or 'BigNumber'.
+  numberFallback: "number",
+  // number of significant digits in BigNumbers
+  precision: 64,
+  // predictable output type of functions. When true, output type depends only
+  // on the input types. When false (default), output type can vary depending
+  // on input values. For example `math.sqrt(-4)` returns `complex('2i')` when
+  // predictable is false, and returns `NaN` when true.
+  predictable: false,
+  // random seed for seeded pseudo random number generation
+  // null = randomly seed
+  randomSeed: null,
+  // legacy behavior for matrix subset. When true, the subset function
+  // returns a matrix or array with the same size as the index (except for scalars).
+  // When false, it returns a matrix or array with a size depending on the type of index.
+  legacySubset: false
+};
+
+// src/arithmetic/scalar.ts
+function isPrimitive(v) {
+  return typeof v === "number" || typeof v === "bigint";
+}
+function asComplex(v) {
+  return v instanceof Complex ? v : new Complex(number(v), 0);
+}
+function asBigNumber(v) {
+  if (v instanceof BigNumber) return v;
+  if (typeof v === "bigint") return BigNumber.fromBigInt(v);
+  return BigNumber.fromNumber(number(v));
+}
+function asFraction(v) {
+  if (v instanceof Fraction) return v;
+  if (typeof v === "number" || typeof v === "bigint") return new Fraction(v);
+  return new Fraction(number(v));
 }
-function deepFlatten(nestedObject) {
-  const flattenedObject = {};
-  _deepFlatten(nestedObject, flattenedObject);
-  return flattenedObject;
+function addScalar(x, y) {
+  if (typeof x === "number" && typeof y === "number") return x + y;
+  if (typeof x === "bigint" && typeof y === "bigint") return x + y;
+  if (isPrimitive(x) && isPrimitive(y)) return Number(x) + Number(y);
+  if (x instanceof Complex || y instanceof Complex) return asComplex(x).add(asComplex(y));
+  if (x instanceof BigNumber || y instanceof BigNumber) return asBigNumber(x).add(asBigNumber(y));
+  return asFraction(x).add(asFraction(y));
 }
-function _deepFlatten(nestedObject, flattenedObject) {
-  for (const prop in nestedObject) {
-    if (hasOwnProperty(nestedObject, prop)) {
-      const value = nestedObject[prop];
-      if (typeof value === "object" && value !== null) {
-        _deepFlatten(value, flattenedObject);
-      } else {
-        flattenedObject[prop] = value;
-      }
-    }
-  }
+function subtractScalar(x, y) {
+  if (typeof x === "number" && typeof y === "number") return x - y;
+  if (typeof x === "bigint" && typeof y === "bigint") return x - y;
+  if (isPrimitive(x) && isPrimitive(y)) return Number(x) - Number(y);
+  if (x instanceof Complex || y instanceof Complex) return asComplex(x).subtract(asComplex(y));
+  if (x instanceof BigNumber || y instanceof BigNumber)
+    return asBigNumber(x).subtract(asBigNumber(y));
+  return asFraction(x).subtract(asFraction(y));
 }
-function canDefineProperty() {
-  try {
-    if (Object.defineProperty) {
-      Object.defineProperty({}, "x", {
-        get: function() {
-          return null;
-        }
-      });
-      return true;
-    }
-  } catch {
-  }
-  return false;
+function multiplyScalar(x, y) {
+  if (typeof x === "number" && typeof y === "number") return x * y;
+  if (typeof x === "bigint" && typeof y === "bigint") return x * y;
+  if (isPrimitive(x) && isPrimitive(y)) return Number(x) * Number(y);
+  if (x instanceof Complex || y instanceof Complex) return asComplex(x).multiply(asComplex(y));
+  if (x instanceof BigNumber || y instanceof BigNumber)
+    return asBigNumber(x).multiply(asBigNumber(y));
+  return asFraction(x).multiply(asFraction(y));
 }
-function lazy(object, prop, valueResolver) {
-  let _uninitialized = true;
-  let _value;
-  Object.defineProperty(object, prop, {
-    get: function() {
-      if (_uninitialized) {
-        _value = valueResolver();
-        _uninitialized = false;
-      }
-      return _value;
-    },
-    set: function(value) {
-      _value = value;
-      _uninitialized = false;
-    },
-    configurable: true,
-    enumerable: true
-  });
+function divideScalar(x, y) {
+  if (typeof x === "number" && typeof y === "number") return x / y;
+  if (typeof x === "bigint" && typeof y === "bigint") return x / y;
+  if (isPrimitive(x) && isPrimitive(y)) return Number(x) / Number(y);
+  if (x instanceof Complex || y instanceof Complex) return asComplex(x).divide(asComplex(y));
+  if (x instanceof BigNumber || y instanceof BigNumber)
+    return asBigNumber(x).divide(asBigNumber(y));
+  return asFraction(x).divide(asFraction(y));
 }
-function traverse(object, path) {
-  if (path && typeof path === "string") {
-    return traverse(object, path.split("."));
-  }
-  let obj = object;
-  if (path) {
-    for (let i = 0; i < path.length; i++) {
-      const key = path[i];
-      if (!(key in obj)) {
-        obj[key] = {};
-      }
-      obj = obj[key];
-    }
+function pow(base, exp) {
+  if (base instanceof Complex) return base.pow(exp instanceof Complex ? exp : number(exp));
+  if (base instanceof BigNumber || base instanceof Fraction) {
+    const n = typeof exp === "bigint" ? exp : number(exp);
+    if (typeof n === "bigint" || Number.isInteger(n)) return base.pow(n);
+    return Math.pow(number(base), n);
   }
-  return obj;
+  if (typeof base === "bigint" && typeof exp === "bigint") return base ** exp;
+  return Math.pow(number(base), number(exp));
 }
-function isLegacyFactory(object) {
-  return !!object && typeof object.factory === "function";
+function abs(x) {
+  if (typeof x === "number") return Math.abs(x);
+  if (typeof x === "bigint") return x < 0n ? -x : x;
+  return x.abs();
 }
-function get(object, path) {
-  if (typeof path === "string") {
-    if (isPath(path)) {
-      return get(object, path.split("."));
-    } else {
-      return object[path];
-    }
-  }
-  let child = object;
-  for (let i = 0; i < path.length; i++) {
-    const key = path[i];
-    child = child ? child[key] : void 0;
-  }
-  return child;
+function fix(x) {
+  if (typeof x === "number") return Math.trunc(x);
+  if (typeof x === "bigint") return x;
+  if (x instanceof Complex) return new Complex(Math.trunc(x.re), Math.trunc(x.im));
+  return x.sign() >= 0 ? x.floor() : x.ceil();
 }
-function set(object, path, value) {
-  if (typeof path === "string") {
-    if (isPath(path)) {
-      return set(object, path.split("."), value);
-    } else {
-      object[path] = value;
-      return object;
-    }
-  }
-  let child = object;
-  for (let i = 0; i < path.length - 1; i++) {
-    const key = path[i];
-    if (child[key] === void 0) {
-      child[key] = {};
-    }
-    child = child[key];
-  }
-  if (path.length > 0) {
-    const lastKey = path[path.length - 1];
-    child[lastKey] = value;
-  }
-  return object;
+function round(x) {
+  if (typeof x === "number") return Math.round(x);
+  if (typeof x === "bigint") return x;
+  if (x instanceof Complex) return new Complex(Math.round(x.re), Math.round(x.im));
+  if (x instanceof BigNumber) return x.round(0, "halfCeil");
+  return x.round();
 }
-function pick(object, properties, transform) {
-  const copy = {};
-  for (let i = 0; i < properties.length; i++) {
-    const key = properties[i];
-    const value = get(object, key);
-    if (value !== void 0) {
-      set(copy, key, transform ? transform(value, key) : value);
-    }
-  }
-  return copy;
+function equal(x, y, relTol = DEFAULT_CONFIG.relTol, absTol = DEFAULT_CONFIG.absTol) {
+  if (typeof x === "bigint" && typeof y === "bigint") return x === y;
+  if (isPrimitive(x) && isPrimitive(y)) return nearlyEqual(Number(x), Number(y), relTol, absTol);
+  if (x instanceof Complex || y instanceof Complex) return asComplex(x).equals(asComplex(y));
+  if (x instanceof Fraction && y instanceof Fraction) return x.equals(y);
+  if (x instanceof BigNumber && y instanceof BigNumber) return x.equals(y);
+  return nearlyEqual(number(x), number(y), relTol, absTol);
 }
-function pickShallow(object, properties) {
-  const copy = {};
-  for (let i = 0; i < properties.length; i++) {
-    const key = properties[i];
-    const value = object[key];
-    if (value !== void 0) {
-      copy[key] = value;
-    }
-  }
-  return copy;
+function isNumeric(x) {
+  return typeof x === "number" || typeof x === "bigint" || typeof x === "boolean" || x instanceof Fraction || x instanceof BigNumber;
 }
-function isPath(str) {
-  return str.includes(".");
+function number(x) {
+  if (typeof x === "number") return x;
+  if (typeof x === "bigint") return Number(x);
+  if (x instanceof Fraction) return x.toNumber();
+  if (x instanceof BigNumber) return x.toNumber();
+  if (x.im !== 0) {
+    throw new TypeError(`Cannot convert ${x.toString()} to a number: imaginary part is nonzero`);
+  }
+  return x.re;
 }
 
 // src/types/unit/errors.ts
@@ -6263,29 +6263,11 @@ export {
   COMPLEX_ZERO,
   COMPLEX_ONE,
   COMPLEX_NEG_ONE,
-  isFraction,
-  Fraction,
-  FRACTION_ZERO,
-  FRACTION_ONE,
-  FRACTION_NEG_ONE,
-  FRACTION_HALF,
-  FRACTION_THIRD,
-  FRACTION_QUARTER,
-  isBigNumber,
-  BigNumber,
-  BIGNUMBER_ZERO,
-  BIGNUMBER_ONE,
-  BIGNUMBER_NEG_ONE,
-  BIGNUMBER_TEN,
-  BIGNUMBER_PI,
-  BIGNUMBER_E,
-  BIGNUMBER_LN2,
-  BIGNUMBER_LN10,
   isNumber,
-  isBigNumber2,
+  isBigNumber,
   isBigInt,
   isComplex2,
-  isFraction2,
+  isFraction,
   isUnit,
   isString,
   isArray,
@@ -6330,17 +6312,6 @@ export {
   tanh,
   copysign,
   isPowZeroAtInfinity,
-  addScalar,
-  subtractScalar,
-  multiplyScalar,
-  divideScalar,
-  pow,
-  abs,
-  fix,
-  round,
-  equal,
-  isNumeric,
-  number,
   hasOwnProperty,
   endsWith,
   warnOnce,
@@ -6359,6 +6330,36 @@ export {
   set,
   pick,
   pickShallow,
+  factory,
+  isFraction2,
+  Fraction,
+  FRACTION_ZERO,
+  FRACTION_ONE,
+  FRACTION_NEG_ONE,
+  FRACTION_HALF,
+  FRACTION_THIRD,
+  FRACTION_QUARTER,
+  isBigNumber2,
+  BigNumber,
+  BIGNUMBER_ZERO,
+  BIGNUMBER_ONE,
+  BIGNUMBER_NEG_ONE,
+  BIGNUMBER_TEN,
+  BIGNUMBER_PI,
+  BIGNUMBER_E,
+  BIGNUMBER_LN2,
+  BIGNUMBER_LN10,
+  addScalar,
+  subtractScalar,
+  multiplyScalar,
+  divideScalar,
+  pow,
+  abs,
+  fix,
+  round,
+  equal,
+  isNumeric,
+  number,
   UnitParseError,
   DimensionMismatchError,
   createUnitClass,