solve-engine 1.0.1 → 1.1.0

package/dist/{chunk-UM6BVY2S.cjs → chunk-HIQ5HSZL.cjs}

@@ -1,7 +1,125 @@
 'use strict';
 
-var chunkJMXUNXQS_cjs = require('./chunk-JMXUNXQS.cjs');
-var chunk5KMIY374_cjs = require('./chunk-5KMIY374.cjs');
+var chunk2TZKENDH_cjs = require('./chunk-2TZKENDH.cjs');
+var chunkB4HBEFTB_cjs = require('./chunk-B4HBEFTB.cjs');
+
+// src/decimal/Decimal.ts
+var DEFAULT_DIVISION_SCALE = 20;
+var POW10 = [1n];
+function pow10(n) {
+  if (n < 0) {
+    throw chunkB4HBEFTB_cjs.ErrorFactory.internal("DECIMAL_NEGATIVE_POWER", `pow10 needs a non-negative exponent, got ${n}`, { exponent: n });
+  }
+  for (let i = POW10.length; i <= n; i++) POW10[i] = POW10[i - 1] * 10n;
+  return POW10[n];
+}
+function decimalFromInteger(n) {
+  return { coef: typeof n === "bigint" ? n : BigInt(n), scale: 0 };
+}
+function decimalFromNumberIfExact(n) {
+  if (!Number.isFinite(n) || !Number.isInteger(n)) return null;
+  return decimalFromInteger(BigInt(n));
+}
+function decimalFromLiteral(text) {
+  let s = text;
+  let negative = false;
+  if (s.startsWith("-")) {
+    negative = true;
+    s = s.slice(1);
+  } else if (s.startsWith("+")) {
+    s = s.slice(1);
+  }
+  const dot = s.indexOf(".");
+  const intPart = dot < 0 ? s : s.slice(0, dot);
+  const fracPart = dot < 0 ? "" : s.slice(dot + 1);
+  const digits = intPart + fracPart || "0";
+  if (!/^[0-9]+$/.test(digits)) {
+    throw chunkB4HBEFTB_cjs.ErrorFactory.parsing("INVALID_DECIMAL_LITERAL", `Not a decimal literal: "${text}"`, { raw: text });
+  }
+  let coef = BigInt(digits);
+  if (negative) coef = -coef;
+  return { coef, scale: fracPart.length };
+}
+function align(a, b) {
+  if (a.scale === b.scale) return { ca: a.coef, cb: b.coef, scale: a.scale };
+  if (a.scale > b.scale) return { ca: a.coef, cb: b.coef * pow10(a.scale - b.scale), scale: a.scale };
+  return { ca: a.coef * pow10(b.scale - a.scale), cb: b.coef, scale: b.scale };
+}
+function decimalAdd(a, b) {
+  const { ca, cb, scale } = align(a, b);
+  return { coef: ca + cb, scale };
+}
+function decimalSubtract(a, b) {
+  const { ca, cb, scale } = align(a, b);
+  return { coef: ca - cb, scale };
+}
+function decimalMultiply(a, b) {
+  return { coef: a.coef * b.coef, scale: a.scale + b.scale };
+}
+function decimalNegate(a) {
+  return { coef: -a.coef, scale: a.scale };
+}
+function decimalIsZero(a) {
+  return a.coef === 0n;
+}
+function roundCoefToScale(coef, scale, targetScale) {
+  if (targetScale >= scale) return coef * pow10(targetScale - scale);
+  const divisor = pow10(scale - targetScale);
+  const negative = coef < 0n;
+  const magnitude = negative ? -coef : coef;
+  let q = magnitude / divisor;
+  const r = magnitude % divisor;
+  if (r * 2n >= divisor) q += 1n;
+  return negative ? -q : q;
+}
+function decimalRound(a, targetScale) {
+  return { coef: roundCoefToScale(a.coef, a.scale, targetScale), scale: targetScale };
+}
+function decimalDivide(a, b, maxFractionDigits = DEFAULT_DIVISION_SCALE) {
+  if (decimalIsZero(b)) {
+    throw chunkB4HBEFTB_cjs.ErrorFactory.internal("DECIMAL_DIVISION_BY_ZERO", "decimalDivide was called with a zero divisor", {});
+  }
+  const s = maxFractionDigits;
+  const numerator = a.coef * pow10(s + b.scale);
+  const denominator = b.coef * pow10(a.scale);
+  const negative = numerator < 0n !== denominator < 0n;
+  const num = numerator < 0n ? -numerator : numerator;
+  const den = denominator < 0n ? -denominator : denominator;
+  let q = num / den;
+  const r = num % den;
+  if (r * 2n >= den) q += 1n;
+  return { coef: negative ? -q : q, scale: s };
+}
+function decimalCompare(a, b) {
+  const { ca, cb } = align(a, b);
+  if (ca < cb) return -1;
+  if (ca > cb) return 1;
+  return 0;
+}
+function decimalToString(a) {
+  const negative = a.coef < 0n;
+  let digits = (negative ? -a.coef : a.coef).toString();
+  if (a.scale === 0) return negative ? `-${digits}` : digits;
+  if (digits.length <= a.scale) digits = digits.padStart(a.scale + 1, "0");
+  const cut = digits.length - a.scale;
+  const whole = digits.slice(0, cut);
+  const frac = digits.slice(cut);
+  return `${negative ? "-" : ""}${whole}.${frac}`;
+}
+function decimalToNumber(a) {
+  return Number(decimalToString(a));
+}
+function decimalToFixed(a, fractionDigits) {
+  const rounded = decimalRound(a, fractionDigits);
+  const negative = rounded.coef < 0n && rounded.coef !== 0n;
+  let digits = (rounded.coef < 0n ? -rounded.coef : rounded.coef).toString();
+  if (fractionDigits === 0) return negative ? `-${digits}` : digits;
+  if (digits.length <= fractionDigits) digits = digits.padStart(fractionDigits + 1, "0");
+  const cut = digits.length - fractionDigits;
+  const whole = digits.slice(0, cut);
+  const frac = digits.slice(cut);
+  return `${negative ? "-" : ""}${whole}.${frac}`;
+}
 
 // src/symbolic/Rational.ts
 var RATIONAL_ZERO = { n: 0n, d: 1n };
@@ -33,7 +151,7 @@ function gcd(a, b) {
 function guardMagnitude(n, d) {
   const magnitude = n < 0n ? -n : n;
   if (magnitude >= MAX_MAGNITUDE || d >= MAX_MAGNITUDE) {
-    throw chunk5KMIY374_cjs.ErrorFactory.execution(
+    throw chunkB4HBEFTB_cjs.ErrorFactory.execution(
       "SYMBOLIC_RATIONAL_OVERFLOW",
       `This calculation produced a fraction too large to represent exactly (over ${RATIONAL_MAX_BITS} bits).`,
       { limitBits: RATIONAL_MAX_BITS }
@@ -42,7 +160,7 @@ function guardMagnitude(n, d) {
 }
 function normalize(n, d) {
   if (d === 0n) {
-    throw chunk5KMIY374_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Division by zero in a symbolic expression.");
+    throw chunkB4HBEFTB_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Division by zero in a symbolic expression.");
   }
   if (n === 0n) return RATIONAL_ZERO;
   let numerator = d < 0n ? -n : n;
@@ -59,7 +177,7 @@ function rational(numerator, denominator = 1n) {
 var DECIMAL_FORM = /^(-?)(\d+)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/;
 function rationalFromNumber(value) {
   if (!Number.isFinite(value)) {
-    throw chunk5KMIY374_cjs.ErrorFactory.execution(
+    throw chunkB4HBEFTB_cjs.ErrorFactory.execution(
       "SYMBOLIC_NONFINITE_OPERAND",
       `"${String(value)}" has no exact value, so it cannot appear in a symbolic expression.`,
       { value: String(value) }
@@ -68,7 +186,7 @@ function rationalFromNumber(value) {
   if (Number.isInteger(value)) return normalize(BigInt(value), 1n);
   const parts = DECIMAL_FORM.exec(String(value));
   if (parts === null) {
-    throw chunk5KMIY374_cjs.ErrorFactory.internal(
+    throw chunkB4HBEFTB_cjs.ErrorFactory.internal(
       "INTERNAL_RATIONAL_PARSE",
       `Internal error: could not read "${String(value)}" as a decimal number.`,
       { value: String(value) }
@@ -100,7 +218,7 @@ function rationalMul(a, b) {
 }
 function rationalDiv(a, b) {
   if (b.n === 0n) {
-    throw chunk5KMIY374_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Division by zero in a symbolic expression.");
+    throw chunkB4HBEFTB_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Division by zero in a symbolic expression.");
   }
   return normalize(a.n * b.d, a.d * b.n);
 }
@@ -111,7 +229,7 @@ function rationalPow(base, exponent) {
   if (exponent === 0n) return RATIONAL_ONE;
   if (exponent < 0n) {
     if (base.n === 0n) {
-      throw chunk5KMIY374_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Zero raised to a negative power is undefined.");
+      throw chunkB4HBEFTB_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Zero raised to a negative power is undefined.");
     }
     const positive = -exponent;
     return normalize(bigintPow(base.d, positive), bigintPow(base.n, positive));
@@ -191,7 +309,7 @@ function complexMul(a, b) {
 }
 function complexDiv(a, b) {
   if (isComplexZero(b)) {
-    throw chunk5KMIY374_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Division by zero in a complex expression.");
+    throw chunkB4HBEFTB_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Division by zero in a complex expression.");
   }
   const denominator = rationalAdd(rationalMul(b.re, b.re), rationalMul(b.im, b.im));
   return {
@@ -212,7 +330,7 @@ function complexPow(base, exponent) {
   if (exponent === 0n) return COMPLEX_ONE;
   if (exponent < 0n) {
     if (isComplexZero(base)) {
-      throw chunk5KMIY374_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Zero raised to a negative power is undefined.");
+      throw chunkB4HBEFTB_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Zero raised to a negative power is undefined.");
     }
     return complexDiv(COMPLEX_ONE, complexPow(base, -exponent));
   }
@@ -925,7 +1043,7 @@ function foldCall(name, args) {
 }
 function simplifySymbolic(node) {
   if (nodeCount(node, SYMBOLIC_MAX_NODES) > SYMBOLIC_MAX_NODES) {
-    throw chunk5KMIY374_cjs.ErrorFactory.execution(
+    throw chunkB4HBEFTB_cjs.ErrorFactory.execution(
       "SYMBOLIC_NODE_LIMIT_EXCEEDED",
       `This symbolic expression is too large to simplify (over ${SYMBOLIC_MAX_NODES} terms).`,
       { limit: SYMBOLIC_MAX_NODES }
@@ -1277,9 +1395,9 @@ function symbolicToEntry(node) {
   return simplified.kind === "const" ? rationalToNumber(simplified.value) : simplified;
 }
 function matrixEntryToValue(cell) {
-  if (typeof cell === "boolean") return chunkJMXUNXQS_cjs.boolValue(cell);
-  if (typeof cell === "object" && cell !== null) return chunkJMXUNXQS_cjs.symbolicValue(cell);
-  return chunkJMXUNXQS_cjs.numberValue(cell);
+  if (typeof cell === "boolean") return chunk2TZKENDH_cjs.boolValue(cell);
+  if (typeof cell === "object" && cell !== null) return chunk2TZKENDH_cjs.symbolicValue(cell);
+  return chunk2TZKENDH_cjs.numberValue(cell);
 }
 function rowMajorToColumnMajor(rows, cols, rowMajorData) {
   const data = new Array(rows * cols);
@@ -1308,21 +1426,21 @@ function matrixMultiply(l, r) {
     if (useSymbolic) {
       const scalarNode = entryToSymbolic(scalarOperand.data[0]);
       const result2 = matrixOperand.data.map((v) => symbolicToEntry(simplifySymbolic({ kind: "mul", left: entryToSymbolic(v), right: scalarNode })));
-      return chunkJMXUNXQS_cjs.matrixValue(matrixOperand.rows, matrixOperand.cols, result2);
+      return chunk2TZKENDH_cjs.matrixValue(matrixOperand.rows, matrixOperand.cols, result2);
     }
     const scalar = scalarOperand.data[0];
     const result = matrixOperand.data.map((v) => v * scalar);
-    return chunkJMXUNXQS_cjs.matrixValue(matrixOperand.rows, matrixOperand.cols, result);
+    return chunk2TZKENDH_cjs.matrixValue(matrixOperand.rows, matrixOperand.cols, result);
   }
   if (l.cols !== r.rows) {
-    return chunkJMXUNXQS_cjs.errorValue(
+    return chunk2TZKENDH_cjs.errorValue(
       "DIMENSION_MISMATCH",
       `Cannot multiply a ${l.rows}x${l.cols} matrix by a ${r.rows}x${r.cols} matrix \u2014 inner dimensions must match (${l.cols} !== ${r.rows}).`
     );
   }
   const resultRows = l.rows;
   const resultCols = r.cols;
-  const data = chunkJMXUNXQS_cjs.checkedArray(resultRows * resultCols, "matrix cells");
+  const data = chunk2TZKENDH_cjs.checkedArray(resultRows * resultCols, "matrix cells");
   for (let row = 0; row < resultRows; row++) {
     for (let col = 0; col < resultCols; col++) {
       if (useSymbolic) {
@@ -1341,14 +1459,14 @@ function matrixMultiply(l, r) {
       }
     }
   }
-  return chunkJMXUNXQS_cjs.matrixValue(resultRows, resultCols, data);
+  return chunk2TZKENDH_cjs.matrixValue(resultRows, resultCols, data);
 }
 function matrixPower(m, exponent) {
   if (!isSquare(m)) {
-    return chunkJMXUNXQS_cjs.errorValue("MATRIX_POWER_REQUIRES_SQUARE_MATRIX", `^: only a square matrix can be raised to a power (got ${m.rows}x${m.cols}).`);
+    return chunk2TZKENDH_cjs.errorValue("MATRIX_POWER_REQUIRES_SQUARE_MATRIX", `^: only a square matrix can be raised to a power (got ${m.rows}x${m.cols}).`);
   }
   if (!Number.isInteger(exponent) || exponent < 0) {
-    return chunkJMXUNXQS_cjs.errorValue(
+    return chunk2TZKENDH_cjs.errorValue(
       "MATRIX_POWER_REQUIRES_WHOLE_EXPONENT",
       `^: a matrix can only be raised to a whole number of 0 or more (got ${exponent}); "^-1" means the inverse and "^T" the transpose.`
     );
@@ -1372,18 +1490,18 @@ function matrixPower(m, exponent) {
       squared = doubled.value;
     }
   }
-  return chunkJMXUNXQS_cjs.matrixValue(accumulated.rows, accumulated.cols, accumulated.data);
+  return chunk2TZKENDH_cjs.matrixValue(accumulated.rows, accumulated.cols, accumulated.data);
 }
 function matrixCompare(l, r, cmp) {
   if (!sameShape(l, r)) {
-    return chunkJMXUNXQS_cjs.errorValue(
+    return chunk2TZKENDH_cjs.errorValue(
       "DIMENSION_MISMATCH",
       `Cannot compare matrices of different shapes: ${l.rows}x${l.cols} and ${r.rows}x${r.cols}`
     );
   }
   const data = new Array(l.data.length);
   for (let i = 0; i < l.data.length; i++) data[i] = cmp(l.data[i], r.data[i]);
-  return chunkJMXUNXQS_cjs.matrixValue(l.rows, l.cols, data);
+  return chunk2TZKENDH_cjs.matrixValue(l.rows, l.cols, data);
 }
 function transpose(m) {
   const data = new Array(m.rows * m.cols);
@@ -1392,7 +1510,7 @@ function transpose(m) {
       data[r + c * m.cols] = matAt(m, c, r);
     }
   }
-  return chunkJMXUNXQS_cjs.matrixValue(m.cols, m.rows, data);
+  return chunk2TZKENDH_cjs.matrixValue(m.cols, m.rows, data);
 }
 function toWorkingRows(m) {
   const rows = [];
@@ -1448,7 +1566,7 @@ function integerDeterminant(rows) {
 }
 function numericDeterminant(m) {
   const integers = toIntegerRows(m);
-  if (integers !== null) return chunkJMXUNXQS_cjs.numberValue(Number(integerDeterminant(integers)));
+  if (integers !== null) return chunk2TZKENDH_cjs.numberValue(Number(integerDeterminant(integers)));
   const n = m.rows;
   const a = toWorkingRows(m);
   let det = 1;
@@ -1461,7 +1579,7 @@ function numericDeterminant(m) {
         pivotRow = r;
       }
     }
-    if (maxAbs === 0) return chunkJMXUNXQS_cjs.numberValue(0);
+    if (maxAbs === 0) return chunk2TZKENDH_cjs.numberValue(0);
     if (pivotRow !== col) {
       const tmp = a[col];
       a[col] = a[pivotRow];
@@ -1475,7 +1593,7 @@ function numericDeterminant(m) {
       for (let c = col; c < n; c++) a[r][c] -= factor * a[col][c];
     }
   }
-  return chunkJMXUNXQS_cjs.numberValue(det);
+  return chunk2TZKENDH_cjs.numberValue(det);
 }
 function symbolicDeterminant(m) {
   const n = m.rows;
@@ -1488,7 +1606,7 @@ function symbolicDeterminant(m) {
   let det = constNode(1);
   for (let col = 0; col < n; col++) {
     const pivot = simplifySymbolic(a[col][col]);
-    if (pivot.kind === "const" && isRationalZero(pivot.value)) return chunkJMXUNXQS_cjs.numberValue(0);
+    if (pivot.kind === "const" && isRationalZero(pivot.value)) return chunk2TZKENDH_cjs.numberValue(0);
     det = simplifySymbolic({ kind: "mul", left: det, right: pivot });
     for (let r = col + 1; r < n; r++) {
       const factor = simplifySymbolic({ kind: "div", left: a[r][col], right: pivot });
@@ -1497,11 +1615,11 @@ function symbolicDeterminant(m) {
       }
     }
   }
-  return det.kind === "const" ? chunkJMXUNXQS_cjs.numberValue(rationalToNumber(det.value)) : chunkJMXUNXQS_cjs.symbolicValue(det);
+  return det.kind === "const" ? chunk2TZKENDH_cjs.numberValue(rationalToNumber(det.value)) : chunk2TZKENDH_cjs.symbolicValue(det);
 }
 function determinant(m) {
   if (!isSquare(m)) {
-    return chunkJMXUNXQS_cjs.errorValue("DETERMINANT_REQUIRES_SQUARE_MATRIX", `det: matrix must be square (got ${m.rows}x${m.cols}).`);
+    return chunk2TZKENDH_cjs.errorValue("DETERMINANT_REQUIRES_SQUARE_MATRIX", `det: matrix must be square (got ${m.rows}x${m.cols}).`);
   }
   return m.hasSymbolic ? symbolicDeterminant(m) : numericDeterminant(m);
 }
@@ -1521,7 +1639,7 @@ function numericInverse(m) {
       }
     }
     if (maxAbs < 1e-10) {
-      return chunkJMXUNXQS_cjs.errorValue("SINGULAR_MATRIX", `inv: a ${n}x${n} matrix with a zero (or near-zero) pivot column is not invertible.`);
+      return chunk2TZKENDH_cjs.errorValue("SINGULAR_MATRIX", `inv: a ${n}x${n} matrix with a zero (or near-zero) pivot column is not invertible.`);
     }
     if (pivotRow !== col) {
       const tmp = a[col];
@@ -1541,13 +1659,13 @@ function numericInverse(m) {
   for (let r = 0; r < n; r++) {
     for (let c = 0; c < n; c++) data[r + c * n] = a[r][n + c];
   }
-  return chunkJMXUNXQS_cjs.matrixValue(n, n, data);
+  return chunk2TZKENDH_cjs.matrixValue(n, n, data);
 }
 var SYMBOLIC_INVERSE_DIMENSION_LIMIT = 9;
 function symbolicInverse(m) {
   const n = m.rows;
   if (n >= SYMBOLIC_INVERSE_DIMENSION_LIMIT) {
-    return chunkJMXUNXQS_cjs.errorValue(
+    return chunk2TZKENDH_cjs.errorValue(
       "SYMBOLIC_INVERSE_DIMENSION_LIMIT",
       `Symbolic matrix inversion is limited to matrices smaller than ${SYMBOLIC_INVERSE_DIMENSION_LIMIT}x${SYMBOLIC_INVERSE_DIMENSION_LIMIT} (got ${n}x${n}).`
     );
@@ -1562,7 +1680,7 @@ function symbolicInverse(m) {
   for (let col = 0; col < n; col++) {
     const pivot = simplifySymbolic(a[col][col]);
     if (pivot.kind === "const" && isRationalZero(pivot.value)) {
-      return chunkJMXUNXQS_cjs.errorValue(
+      return chunk2TZKENDH_cjs.errorValue(
         "SYMBOLIC_SINGULAR_OR_UNSUPPORTED_PIVOT",
         `Symbolic inverse: the pivot at row/col ${col} is exactly zero \u2014 this matrix's structure isn't invertible via this engine's diagonal-first symbolic elimination (no row-swapping); try reordering rows manually.`
       );
@@ -1583,22 +1701,22 @@ function symbolicInverse(m) {
   for (let r = 0; r < n; r++) {
     for (let c = 0; c < n; c++) data[r + c * n] = symbolicToEntry(a[r][n + c]);
   }
-  return chunkJMXUNXQS_cjs.matrixValue(n, n, data);
+  return chunk2TZKENDH_cjs.matrixValue(n, n, data);
 }
 function inverse(m) {
   if (!isSquare(m)) {
-    return chunkJMXUNXQS_cjs.errorValue("INVERSE_REQUIRES_SQUARE_MATRIX", `inv: matrix must be square (got ${m.rows}x${m.cols}).`);
+    return chunk2TZKENDH_cjs.errorValue("INVERSE_REQUIRES_SQUARE_MATRIX", `inv: matrix must be square (got ${m.rows}x${m.cols}).`);
   }
   return m.hasSymbolic ? symbolicInverse(m) : numericInverse(m);
 }
 function tooLarge(length, maxElements) {
-  return chunkJMXUNXQS_cjs.errorValue(
+  return chunk2TZKENDH_cjs.errorValue(
     "COLLECTION_TOO_LARGE",
     `This collection has ${length} elements, past the limit of ${maxElements} (see the engine's vm.maxCollectionSize setting).`
   );
 }
 function collectionToValues(v, maxElements = Number.POSITIVE_INFINITY) {
-  const faulted = chunkJMXUNXQS_cjs.faultedOperand(v);
+  const faulted = chunk2TZKENDH_cjs.faultedOperand(v);
   if (faulted) return faulted;
   if (v.type === 7 /* Matrix */) {
     const m = v.value;
@@ -1610,10 +1728,10 @@ function collectionToValues(v, maxElements = Number.POSITIVE_INFINITY) {
     const length = r.max - r.min + 1;
     if (length > maxElements) return tooLarge(length, maxElements);
     const out = new Array(length);
-    for (let i = 0; i < length; i++) out[i] = chunkJMXUNXQS_cjs.numberValue(r.min + i);
+    for (let i = 0; i < length; i++) out[i] = chunk2TZKENDH_cjs.numberValue(r.min + i);
     return out;
   }
-  return chunkJMXUNXQS_cjs.errorValue(
+  return chunk2TZKENDH_cjs.errorValue(
     "MAP_REDUCE_REQUIRES_COLLECTION",
     `map/reduce requires a Matrix or Range collection (e.g. "[1,2,3]" or "0:3").`
   );
@@ -1740,6 +1858,19 @@ exports.compareMonomials = compareMonomials;
 exports.complex = complex;
 exports.complexNode = complexNode;
 exports.constNode = constNode;
+exports.decimalAdd = decimalAdd;
+exports.decimalCompare = decimalCompare;
+exports.decimalDivide = decimalDivide;
+exports.decimalFromInteger = decimalFromInteger;
+exports.decimalFromLiteral = decimalFromLiteral;
+exports.decimalFromNumberIfExact = decimalFromNumberIfExact;
+exports.decimalIsZero = decimalIsZero;
+exports.decimalMultiply = decimalMultiply;
+exports.decimalNegate = decimalNegate;
+exports.decimalRound = decimalRound;
+exports.decimalSubtract = decimalSubtract;
+exports.decimalToFixed = decimalToFixed;
+exports.decimalToNumber = decimalToNumber;
 exports.determinant = determinant;
 exports.exactIntegerCbrt = exactIntegerCbrt;
 exports.exactIntegerSqrt = exactIntegerSqrt;
@@ -1766,6 +1897,7 @@ exports.polyDegree = polyDegree;
 exports.polyUnivariateVar = polyUnivariateVar;
 exports.polynomialDivide = polynomialDivide;
 exports.powNode = powNode;
+exports.rational = rational;
 exports.rationalAdd = rationalAdd;
 exports.rationalCompare = rationalCompare;
 exports.rationalDiv = rationalDiv;
@@ -1787,5 +1919,5 @@ exports.symbolicToEntry = symbolicToEntry;
 exports.toPolynomial = toPolynomial;
 exports.transpose = transpose;
 exports.varNode = varNode;
-//# sourceMappingURL=chunk-UM6BVY2S.cjs.map
-//# sourceMappingURL=chunk-UM6BVY2S.cjs.map
+//# sourceMappingURL=chunk-HIQ5HSZL.cjs.map
+//# sourceMappingURL=chunk-HIQ5HSZL.cjs.map