solve-engine 1.0.0-beta.7 → 1.0.0

package/dist/{chunk-DUEZFTK2.js → chunk-UKQHXPGW.js}

@@ -1,18 +1,10 @@
 // src/utilities/Number.ts
 function removeThousandsSeparators(value, locale, decimalPlaces) {
-  let localeNumber = value.toLocaleString(locale, {
+  return value.toLocaleString(locale, {
+    useGrouping: false,
     maximumFractionDigits: decimalPlaces,
     minimumFractionDigits: decimalPlaces
   });
-  switch (locale) {
-    case "de-DE":
-      localeNumber = localeNumber.replace(".", "");
-      break;
-    default:
-      localeNumber = localeNumber.replace(",", "");
-      break;
-  }
-  return localeNumber;
 }
 function autoFormatIntegerOrFloat(number, decimalPlaces = 2, includeThousandSeparators = false, numberLocale = "en-US") {
   if (Number.isInteger(number)) {
@@ -34,5 +26,5 @@ function autoFormatIntegerOrFloat(number, decimalPlaces = 2, includeThousandSepa
 }
 
 export { autoFormatIntegerOrFloat };
-//# sourceMappingURL=chunk-DUEZFTK2.js.map
-//# sourceMappingURL=chunk-DUEZFTK2.js.map
+//# sourceMappingURL=chunk-UKQHXPGW.js.map
+//# sourceMappingURL=chunk-UKQHXPGW.js.map

package/dist/chunk-UKQHXPGW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utilities/Number.ts"],"names":[],"mappings":";AAoBA,SAAS,yBAAA,CACR,KAAA,EACA,MAAA,EACA,aAAA,EACC;AACD,EAAA,OAAO,KAAA,CAAM,eAAe,MAAA,EAAQ;AAAA,IACnC,WAAA,EAAa,KAAA;AAAA,IACb,qBAAA,EAAuB,aAAA;AAAA,IACvB,qBAAA,EAAuB;AAAA,GACvB,CAAA;AACF;AAcO,SAAS,yBACf,MAAA,EACA,aAAA,GAAwB,GACxB,yBAAA,GAAqC,KAAA,EACrC,eAAuB,OAAA,EACtB;AACD,EAAA,IAAI,MAAA,CAAO,SAAA,CAAU,MAAM,CAAA,EAAG;AAC7B,IAAA,IAAI,yBAAA,EAA2B;AAE9B,MAAA,OAAO,MAAA,CAAO,eAAe,YAAA,EAAc;AAAA,QAC1C,qBAAA,EAAuB,CAAA;AAAA,QACvB,qBAAA,EAAuB;AAAA,OACvB,CAAA;AAAA,IACF;AAEA,IAAA,OAAO,0BAA0B,IAAA,CAAK,KAAA,CAAM,MAAM,CAAA,EAAG,cAAc,CAAC,CAAA;AAAA,EACrE;AAGA,EAAA,IAAI,yBAAA,EAA2B;AAE9B,IAAA,OAAO,MAAA,CAAO,eAAe,YAAA,EAAc;AAAA,MAC1C,qBAAA,EAAuB,aAAA;AAAA,MACvB,qBAAA,EAAuB;AAAA,KACvB,CAAA;AAAA,EACF;AAIA,EAAA,OAAO,yBAAA,CAA0B,MAAA,EAAQ,YAAA,EAAc,aAAa,CAAA;AACrE","file":"chunk-UKQHXPGW.js","sourcesContent":["/**\n * Render `value` in `locale` with `decimalPlaces` fractional digits and no\n * digit grouping, leaving the locale's own decimal separator alone.\n *\n * Asks `Intl` not to group in the first place rather than formatting with\n * grouping and then deleting a character afterwards. Deleting was wrong twice\n * over. It used `String.replace` with a string pattern, which removes one\n * occurrence, so \"1,234,567\" came back as \"1234,567\" and the surviving comma\n * read as a decimal point. And it chose the character to delete from a\n * two-case switch, \"de-DE\" or a comma for everything else, when a comma is the\n * DECIMAL separator in French, Spanish, Italian, Portuguese and every other\n * comma-decimal locale: deleting it turned 1.5 into \"150\", a hundred times the\n * number, while leaving French's actual group separator (a narrow no-break\n * space) in place. `numberResult.decimalSeparatorLocale` is an unvalidated\n * host string, so no locale can be assumed.\n *\n * An unusable locale tag still throws the `RangeError` `toLocaleString` has\n * always thrown for one, since swallowing it would hide the host's typo behind\n * silently different output.\n */\nfunction removeThousandsSeparators(\n\tvalue: number,\n\tlocale: string,\n\tdecimalPlaces: number\n) {\n\treturn value.toLocaleString(locale, {\n\t\tuseGrouping: false,\n\t\tmaximumFractionDigits: decimalPlaces,\n\t\tminimumFractionDigits: decimalPlaces,\n\t});\n}\n\n/**\n * Format `number` for display, branching on whether it's a whole number:\n * integers are always rendered with zero decimal places (never padded to\n * `decimalPlaces`), while non-integers are rendered with up to\n * `decimalPlaces` fractional digits. `includeThousandSeparators` controls\n * whether groups are separated (e.g. `\"1,234\"`) per `numberLocale`.\n *\n * @param number - The value to format.\n * @param decimalPlaces - Max fractional digits for non-integer values (default 2).\n * @param includeThousandSeparators - Whether to group digits (default false).\n * @param numberLocale - `Intl`/`toLocaleString` locale to format with (default \"en-US\").\n */\nexport function autoFormatIntegerOrFloat(\n\tnumber: number,\n\tdecimalPlaces: number = 2,\n\tincludeThousandSeparators: boolean = false,\n\tnumberLocale: string = \"en-US\"\n) {\n\tif (Number.isInteger(number)) {\n\t\tif (includeThousandSeparators) {\n\t\t\t// We can return the format early as we don't need to strip thousands\n\t\t\treturn number.toLocaleString(numberLocale, {\n\t\t\t\tminimumFractionDigits: 0,\n\t\t\t\tmaximumFractionDigits: 0,\n\t\t\t});\n\t\t}\n\n\t\treturn removeThousandsSeparators(Math.trunc(number), numberLocale, 0);\n\t}\n\n\t// Decimal\n\tif (includeThousandSeparators) {\n\t\t// We can return the format early as we don't need to strip thousands\n\t\treturn number.toLocaleString(numberLocale, {\n\t\t\tmaximumFractionDigits: decimalPlaces,\n\t\t\tminimumFractionDigits: decimalPlaces,\n\t\t});\n\t}\n\n\t// number.toFixed(decimalPlaces)\n\n\treturn removeThousandsSeparators(number, numberLocale, decimalPlaces);\n}\n"]}

package/dist/{chunk-4CVLFLOB.cjs → chunk-UM6BVY2S.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-var chunkOC6LTXYS_cjs = require('./chunk-OC6LTXYS.cjs');
-var chunkM4N5GA5Z_cjs = require('./chunk-M4N5GA5Z.cjs');
+var chunkJMXUNXQS_cjs = require('./chunk-JMXUNXQS.cjs');
+var chunk5KMIY374_cjs = require('./chunk-5KMIY374.cjs');
 
 // src/symbolic/Rational.ts
 var RATIONAL_ZERO = { n: 0n, d: 1n };
@@ -33,7 +33,7 @@ function gcd(a, b) {
 function guardMagnitude(n, d) {
   const magnitude = n < 0n ? -n : n;
   if (magnitude >= MAX_MAGNITUDE || d >= MAX_MAGNITUDE) {
-    throw chunkM4N5GA5Z_cjs.ErrorFactory.execution(
+    throw chunk5KMIY374_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 +42,7 @@ function guardMagnitude(n, d) {
 }
 function normalize(n, d) {
   if (d === 0n) {
-    throw chunkM4N5GA5Z_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Division by zero in a symbolic expression.");
+    throw chunk5KMIY374_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 +59,7 @@ function rational(numerator, denominator = 1n) {
 var DECIMAL_FORM = /^(-?)(\d+)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/;
 function rationalFromNumber(value) {
   if (!Number.isFinite(value)) {
-    throw chunkM4N5GA5Z_cjs.ErrorFactory.execution(
+    throw chunk5KMIY374_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 +68,7 @@ function rationalFromNumber(value) {
   if (Number.isInteger(value)) return normalize(BigInt(value), 1n);
   const parts = DECIMAL_FORM.exec(String(value));
   if (parts === null) {
-    throw chunkM4N5GA5Z_cjs.ErrorFactory.internal(
+    throw chunk5KMIY374_cjs.ErrorFactory.internal(
       "INTERNAL_RATIONAL_PARSE",
       `Internal error: could not read "${String(value)}" as a decimal number.`,
       { value: String(value) }
@@ -100,7 +100,7 @@ function rationalMul(a, b) {
 }
 function rationalDiv(a, b) {
   if (b.n === 0n) {
-    throw chunkM4N5GA5Z_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Division by zero in a symbolic expression.");
+    throw chunk5KMIY374_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 +111,7 @@ function rationalPow(base, exponent) {
   if (exponent === 0n) return RATIONAL_ONE;
   if (exponent < 0n) {
     if (base.n === 0n) {
-      throw chunkM4N5GA5Z_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Zero raised to a negative power is undefined.");
+      throw chunk5KMIY374_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 +191,7 @@ function complexMul(a, b) {
 }
 function complexDiv(a, b) {
   if (isComplexZero(b)) {
-    throw chunkM4N5GA5Z_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Division by zero in a complex expression.");
+    throw chunk5KMIY374_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 +212,7 @@ function complexPow(base, exponent) {
   if (exponent === 0n) return COMPLEX_ONE;
   if (exponent < 0n) {
     if (isComplexZero(base)) {
-      throw chunkM4N5GA5Z_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Zero raised to a negative power is undefined.");
+      throw chunk5KMIY374_cjs.ErrorFactory.execution("SYMBOLIC_DIVISION_BY_ZERO", "Zero raised to a negative power is undefined.");
     }
     return complexDiv(COMPLEX_ONE, complexPow(base, -exponent));
   }
@@ -734,6 +734,17 @@ function divideOutConstant(numerator, denominator, original) {
   }
   return { kind: "div", left: fromPolynomial(numerator), right: fromPolynomial(denominator) };
 }
+function squareFreePart(coefficients) {
+  const trimmed = trim([...coefficients]);
+  if (trimmed.length <= 1) return monic(trimmed);
+  const derivative = [];
+  for (let power = 1; power < trimmed.length; power++) {
+    derivative.push(rationalMul(trimmed[power], { n: BigInt(power), d: 1n }));
+  }
+  const shared = coefficientGcd(trimmed, derivative);
+  if (shared.length <= 1) return monic(trimmed);
+  return monic(polynomialDivide(trimmed, shared).quotient);
+}
 
 // src/symbolic/Radicals.ts
 function exactIntegerSqrt(value) {
@@ -789,14 +800,15 @@ function signedSurdNode(value) {
 }
 
 // src/symbolic/Simplify.ts
-function flattenSum(node, negated, out) {
+function flattenSum(node, negated, out, depth = 0) {
+  if (depth >= MAX_SIMPLIFY_DEPTH) return false;
   switch (node.kind) {
     case "add":
-      return flattenSum(node.left, negated, out) && flattenSum(node.right, negated, out);
+      return flattenSum(node.left, negated, out, depth + 1) && flattenSum(node.right, negated, out, depth + 1);
     case "sub":
-      return flattenSum(node.left, negated, out) && flattenSum(node.right, !negated, out);
+      return flattenSum(node.left, negated, out, depth + 1) && flattenSum(node.right, !negated, out, depth + 1);
     case "neg":
-      return flattenSum(node.operand, !negated, out);
+      return flattenSum(node.operand, !negated, out, depth + 1);
     case "const":
       out.push({ coeff: negated ? rationalNeg(node.value) : node.value, name: null });
       return true;
@@ -913,13 +925,27 @@ function foldCall(name, args) {
 }
 function simplifySymbolic(node) {
   if (nodeCount(node, SYMBOLIC_MAX_NODES) > SYMBOLIC_MAX_NODES) {
-    throw chunkM4N5GA5Z_cjs.ErrorFactory.execution(
+    throw chunk5KMIY374_cjs.ErrorFactory.execution(
       "SYMBOLIC_NODE_LIMIT_EXCEEDED",
       `This symbolic expression is too large to simplify (over ${SYMBOLIC_MAX_NODES} terms).`,
       { limit: SYMBOLIC_MAX_NODES }
     );
   }
-  return simplifyNode(node);
+  const depthOnEntry = walkDepth;
+  try {
+    return simplifyNode(node);
+  } finally {
+    walkDepth = depthOnEntry;
+  }
+}
+var MAX_SIMPLIFY_DEPTH = 900;
+var walkDepth = 0;
+function simplifyNode(node) {
+  if (walkDepth >= MAX_SIMPLIFY_DEPTH) return node;
+  walkDepth++;
+  const simplified = simplifyNodeAt(node);
+  walkDepth--;
+  return simplified;
 }
 function asComplex(node) {
   if (node.kind === "complex") return node.value;
@@ -974,7 +1000,7 @@ function foldComplexCall(name, args) {
       return null;
   }
 }
-function simplifyNode(node) {
+function simplifyNodeAt(node) {
   switch (node.kind) {
     case "const":
     case "complex":
@@ -1118,7 +1144,10 @@ function formatCoefficient(coeff, text) {
   if (coeff.n === -1n && coeff.d === 1n) return `-${text}`;
   return `${formatRational(coeff)}${text}`;
 }
-function formatFactor(node) {
+var MAX_FORMAT_DEPTH = 600;
+var ELIDED = "...";
+function formatFactor(node, depth) {
+  if (depth >= MAX_FORMAT_DEPTH) return ELIDED;
   switch (node.kind) {
     case "const":
       return formatRational(node.value);
@@ -1128,43 +1157,50 @@ function formatFactor(node) {
       return node.name;
     case "add":
     case "sub":
-      return `(${formatSymbolic(node)})`;
+      return `(${formatSum(node, depth)})`;
     case "neg":
-      return `-${formatFactor(node.operand)}`;
+      return `-${formatFactor(node.operand, depth + 1)}`;
     case "call":
-      return `${node.name}(${node.args.map(formatSymbolic).join(", ")})`;
+      return `${node.name}(${node.args.map((arg) => formatSum(arg, depth + 1)).join(", ")})`;
     case "pow": {
-      const base = isAtomic(node.base) ? formatFactor(node.base) : `(${formatSymbolic(node.base)})`;
-      const exponent = isAtomic(node.exponent) ? formatFactor(node.exponent) : `(${formatSymbolic(node.exponent)})`;
+      const base = isAtomic(node.base) ? formatFactor(node.base, depth + 1) : `(${formatSum(node.base, depth + 1)})`;
+      const exponent = isAtomic(node.exponent) ? formatFactor(node.exponent, depth + 1) : `(${formatSum(node.exponent, depth + 1)})`;
       return `${base}^${exponent}`;
     }
     case "mul": {
       const coeffVar = tryExtractCoeffVar(node);
       if (coeffVar) return formatCoefficient(coeffVar.coeff, coeffVar.name);
       const coeffPow = tryExtractCoeffPow(node);
-      if (coeffPow) return formatCoefficient(coeffPow.coeff, formatFactor(coeffPow.power));
+      if (coeffPow) return formatCoefficient(coeffPow.coeff, formatFactor(coeffPow.power, depth + 1));
       if (node.left.kind === "const" && node.right.kind === "mul") {
-        const inner = formatFactor(node.right);
+        const inner = formatFactor(node.right, depth + 1);
         if (!/^[\d.]/.test(inner)) return formatCoefficient(node.left.value, inner);
       }
-      return `${formatFactor(node.left)}*${formatFactor(node.right)}`;
+      return `${formatFactor(node.left, depth + 1)}*${formatFactor(node.right, depth + 1)}`;
+    }
+    case "div": {
+      const denominator = formatFactor(node.right, depth + 1);
+      const needsBrackets = node.right.kind === "mul" || node.right.kind === "div";
+      return `${formatFactor(node.left, depth + 1)}/${needsBrackets ? `(${denominator})` : denominator}`;
     }
-    case "div":
-      return `${formatFactor(node.left)}/${formatFactor(node.right)}`;
   }
 }
-function collectDisplayTerms(node, negated, out) {
+function collectDisplayTerms(node, negated, out, depth) {
+  if (depth >= MAX_FORMAT_DEPTH) {
+    out.push({ negated, text: ELIDED });
+    return;
+  }
   switch (node.kind) {
     case "add":
-      collectDisplayTerms(node.left, negated, out);
-      collectDisplayTerms(node.right, negated, out);
+      collectDisplayTerms(node.left, negated, out, depth + 1);
+      collectDisplayTerms(node.right, negated, out, depth + 1);
       return;
     case "sub":
-      collectDisplayTerms(node.left, negated, out);
-      collectDisplayTerms(node.right, !negated, out);
+      collectDisplayTerms(node.left, negated, out, depth + 1);
+      collectDisplayTerms(node.right, !negated, out, depth + 1);
       return;
     case "neg":
-      collectDisplayTerms(node.operand, !negated, out);
+      collectDisplayTerms(node.operand, !negated, out, depth + 1);
       return;
     case "const": {
       if (node.value.n === 0n) return;
@@ -1188,7 +1224,7 @@ function collectDisplayTerms(node, negated, out) {
       return;
     }
     default: {
-      const text = formatFactor(node);
+      const text = formatFactor(node, depth);
       const liftsSign = (node.kind === "mul" || node.kind === "div") && text.startsWith("-");
       if (liftsSign) out.push({ negated: !negated, text: text.slice(1) });
       else out.push({ negated, text });
@@ -1196,8 +1232,16 @@ function collectDisplayTerms(node, negated, out) {
   }
 }
 function formatSymbolic(node) {
+  try {
+    return formatSum(node, 0);
+  } catch (thrown) {
+    if (thrown instanceof RangeError) return ELIDED;
+    throw thrown;
+  }
+}
+function formatSum(node, depth) {
   const terms = [];
-  collectDisplayTerms(node, false, terms);
+  collectDisplayTerms(node, false, terms, depth);
   if (terms.length === 0) return "0";
   let out = "";
   terms.forEach((term, index) => {
@@ -1233,9 +1277,9 @@ function symbolicToEntry(node) {
   return simplified.kind === "const" ? rationalToNumber(simplified.value) : simplified;
 }
 function matrixEntryToValue(cell) {
-  if (typeof cell === "boolean") return chunkOC6LTXYS_cjs.boolValue(cell);
-  if (typeof cell === "object" && cell !== null) return chunkOC6LTXYS_cjs.symbolicValue(cell);
-  return chunkOC6LTXYS_cjs.numberValue(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);
 }
 function rowMajorToColumnMajor(rows, cols, rowMajorData) {
   const data = new Array(rows * cols);
@@ -1264,21 +1308,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 chunkOC6LTXYS_cjs.matrixValue(matrixOperand.rows, matrixOperand.cols, result2);
+      return chunkJMXUNXQS_cjs.matrixValue(matrixOperand.rows, matrixOperand.cols, result2);
     }
     const scalar = scalarOperand.data[0];
     const result = matrixOperand.data.map((v) => v * scalar);
-    return chunkOC6LTXYS_cjs.matrixValue(matrixOperand.rows, matrixOperand.cols, result);
+    return chunkJMXUNXQS_cjs.matrixValue(matrixOperand.rows, matrixOperand.cols, result);
   }
   if (l.cols !== r.rows) {
-    return chunkOC6LTXYS_cjs.errorValue(
+    return chunkJMXUNXQS_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 = new Array(resultRows * resultCols);
+  const data = chunkJMXUNXQS_cjs.checkedArray(resultRows * resultCols, "matrix cells");
   for (let row = 0; row < resultRows; row++) {
     for (let col = 0; col < resultCols; col++) {
       if (useSymbolic) {
@@ -1297,18 +1341,49 @@ function matrixMultiply(l, r) {
       }
     }
   }
-  return chunkOC6LTXYS_cjs.matrixValue(resultRows, resultCols, data);
+  return chunkJMXUNXQS_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}).`);
+  }
+  if (!Number.isInteger(exponent) || exponent < 0) {
+    return chunkJMXUNXQS_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.`
+    );
+  }
+  const n = m.rows;
+  const identity = new Array(n * n).fill(0);
+  for (let i = 0; i < n; i++) identity[i + i * n] = 1;
+  let accumulated = { rows: n, cols: n, data: identity, hasSymbolic: false };
+  let squared = m;
+  let remaining = exponent;
+  while (remaining > 0) {
+    if (remaining % 2 === 1) {
+      const product = matrixMultiply(accumulated, squared);
+      if (product.type === 13 /* Error */) return product;
+      accumulated = product.value;
+    }
+    remaining = Math.floor(remaining / 2);
+    if (remaining > 0) {
+      const doubled = matrixMultiply(squared, squared);
+      if (doubled.type === 13 /* Error */) return doubled;
+      squared = doubled.value;
+    }
+  }
+  return chunkJMXUNXQS_cjs.matrixValue(accumulated.rows, accumulated.cols, accumulated.data);
 }
 function matrixCompare(l, r, cmp) {
   if (!sameShape(l, r)) {
-    return chunkOC6LTXYS_cjs.errorValue(
+    return chunkJMXUNXQS_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 chunkOC6LTXYS_cjs.matrixValue(l.rows, l.cols, data);
+  return chunkJMXUNXQS_cjs.matrixValue(l.rows, l.cols, data);
 }
 function transpose(m) {
   const data = new Array(m.rows * m.cols);
@@ -1317,7 +1392,7 @@ function transpose(m) {
       data[r + c * m.cols] = matAt(m, c, r);
     }
   }
-  return chunkOC6LTXYS_cjs.matrixValue(m.cols, m.rows, data);
+  return chunkJMXUNXQS_cjs.matrixValue(m.cols, m.rows, data);
 }
 function toWorkingRows(m) {
   const rows = [];
@@ -1328,7 +1403,52 @@ function toWorkingRows(m) {
   }
   return rows;
 }
+var EXACT_DETERMINANT_DIMENSION_LIMIT = 12;
+function toIntegerRows(m) {
+  if (m.rows > EXACT_DETERMINANT_DIMENSION_LIMIT) return null;
+  const rows = [];
+  for (let r = 0; r < m.rows; r++) {
+    const row = [];
+    for (let c = 0; c < m.cols; c++) {
+      const cell = matAt(m, r, c);
+      if (typeof cell !== "number" || !Number.isSafeInteger(cell)) return null;
+      row.push(BigInt(cell));
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+function integerDeterminant(rows) {
+  const n = rows.length;
+  let previous = 1n;
+  let sign = 1n;
+  for (let k = 0; k < n - 1; k++) {
+    if (rows[k][k] === 0n) {
+      let candidate = -1;
+      for (let r = k + 1; r < n; r++) {
+        if (rows[r][k] !== 0n) {
+          candidate = r;
+          break;
+        }
+      }
+      if (candidate === -1) return 0n;
+      const swapped = rows[k];
+      rows[k] = rows[candidate];
+      rows[candidate] = swapped;
+      sign = -sign;
+    }
+    for (let i = k + 1; i < n; i++) {
+      for (let j = k + 1; j < n; j++) {
+        rows[i][j] = (rows[i][j] * rows[k][k] - rows[i][k] * rows[k][j]) / previous;
+      }
+    }
+    previous = rows[k][k];
+  }
+  return sign * rows[n - 1][n - 1];
+}
 function numericDeterminant(m) {
+  const integers = toIntegerRows(m);
+  if (integers !== null) return chunkJMXUNXQS_cjs.numberValue(Number(integerDeterminant(integers)));
   const n = m.rows;
   const a = toWorkingRows(m);
   let det = 1;
@@ -1341,7 +1461,7 @@ function numericDeterminant(m) {
         pivotRow = r;
       }
     }
-    if (maxAbs === 0) return chunkOC6LTXYS_cjs.numberValue(0);
+    if (maxAbs === 0) return chunkJMXUNXQS_cjs.numberValue(0);
     if (pivotRow !== col) {
       const tmp = a[col];
       a[col] = a[pivotRow];
@@ -1355,7 +1475,7 @@ function numericDeterminant(m) {
       for (let c = col; c < n; c++) a[r][c] -= factor * a[col][c];
     }
   }
-  return chunkOC6LTXYS_cjs.numberValue(det);
+  return chunkJMXUNXQS_cjs.numberValue(det);
 }
 function symbolicDeterminant(m) {
   const n = m.rows;
@@ -1368,7 +1488,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 chunkOC6LTXYS_cjs.numberValue(0);
+    if (pivot.kind === "const" && isRationalZero(pivot.value)) return chunkJMXUNXQS_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 });
@@ -1377,11 +1497,11 @@ function symbolicDeterminant(m) {
       }
     }
   }
-  return det.kind === "const" ? chunkOC6LTXYS_cjs.numberValue(rationalToNumber(det.value)) : chunkOC6LTXYS_cjs.symbolicValue(det);
+  return det.kind === "const" ? chunkJMXUNXQS_cjs.numberValue(rationalToNumber(det.value)) : chunkJMXUNXQS_cjs.symbolicValue(det);
 }
 function determinant(m) {
   if (!isSquare(m)) {
-    return chunkOC6LTXYS_cjs.errorValue("DETERMINANT_REQUIRES_SQUARE_MATRIX", `det: matrix must be square (got ${m.rows}x${m.cols}).`);
+    return chunkJMXUNXQS_cjs.errorValue("DETERMINANT_REQUIRES_SQUARE_MATRIX", `det: matrix must be square (got ${m.rows}x${m.cols}).`);
   }
   return m.hasSymbolic ? symbolicDeterminant(m) : numericDeterminant(m);
 }
@@ -1401,7 +1521,7 @@ function numericInverse(m) {
       }
     }
     if (maxAbs < 1e-10) {
-      return chunkOC6LTXYS_cjs.errorValue("SINGULAR_MATRIX", `inv: a ${n}x${n} matrix with a zero (or near-zero) pivot column is not invertible.`);
+      return chunkJMXUNXQS_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];
@@ -1421,13 +1541,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 chunkOC6LTXYS_cjs.matrixValue(n, n, data);
+  return chunkJMXUNXQS_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 chunkOC6LTXYS_cjs.errorValue(
+    return chunkJMXUNXQS_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}).`
     );
@@ -1442,48 +1562,58 @@ function symbolicInverse(m) {
   for (let col = 0; col < n; col++) {
     const pivot = simplifySymbolic(a[col][col]);
     if (pivot.kind === "const" && isRationalZero(pivot.value)) {
-      return chunkOC6LTXYS_cjs.errorValue(
+      return chunkJMXUNXQS_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.`
       );
     }
-    for (let c = 0; c < 2 * n; c++) {
-      a[col][c] = simplifySymbolic({ kind: "div", left: a[col][c], right: pivot });
-    }
     for (let r = 0; r < n; r++) {
       if (r === col) continue;
-      const factor = simplifySymbolic(a[r][col]);
+      const factor = simplifySymbolic({ kind: "div", left: a[r][col], right: pivot });
       if (factor.kind === "const" && isRationalZero(factor.value)) continue;
       for (let c = 0; c < 2 * n; c++) {
         a[r][c] = simplifySymbolic({ kind: "sub", left: a[r][c], right: { kind: "mul", left: factor, right: a[col][c] } });
       }
     }
+    for (let c = 0; c < 2 * n; c++) {
+      a[col][c] = simplifySymbolic({ kind: "div", left: a[col][c], right: pivot });
+    }
   }
   const data = new Array(n * n);
   for (let r = 0; r < n; r++) {
     for (let c = 0; c < n; c++) data[r + c * n] = symbolicToEntry(a[r][n + c]);
   }
-  return chunkOC6LTXYS_cjs.matrixValue(n, n, data);
+  return chunkJMXUNXQS_cjs.matrixValue(n, n, data);
 }
 function inverse(m) {
   if (!isSquare(m)) {
-    return chunkOC6LTXYS_cjs.errorValue("INVERSE_REQUIRES_SQUARE_MATRIX", `inv: matrix must be square (got ${m.rows}x${m.cols}).`);
+    return chunkJMXUNXQS_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 collectionToValues(v) {
-  if (v.type === 13 /* Error */) return v;
+function tooLarge(length, maxElements) {
+  return chunkJMXUNXQS_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);
+  if (faulted) return faulted;
   if (v.type === 7 /* Matrix */) {
     const m = v.value;
+    if (m.data.length > maxElements) return tooLarge(m.data.length, maxElements);
     return m.data.map(matrixEntryToValue);
   }
   if (v.type === 8 /* Range */) {
     const r = v.value;
-    const out = [];
-    for (let i = r.min; i <= r.max; i++) out.push(chunkOC6LTXYS_cjs.numberValue(i));
+    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);
     return out;
   }
-  return chunkOC6LTXYS_cjs.errorValue(
+  return chunkJMXUNXQS_cjs.errorValue(
     "MAP_REDUCE_REQUIRES_COLLECTION",
     `map/reduce requires a Matrix or Range collection (e.g. "[1,2,3]" or "0:3").`
   );
@@ -1628,6 +1758,7 @@ exports.matIndex = matIndex;
 exports.matrixCompare = matrixCompare;
 exports.matrixEntryToValue = matrixEntryToValue;
 exports.matrixMultiply = matrixMultiply;
+exports.matrixPower = matrixPower;
 exports.monomialFromKey = monomialFromKey;
 exports.monomialToKey = monomialToKey;
 exports.polyCoefficients = polyCoefficients;
@@ -1648,6 +1779,7 @@ exports.rowMajorToColumnMajor = rowMajorToColumnMajor;
 exports.sameShape = sameShape;
 exports.signedSurdNode = signedSurdNode;
 exports.simplifySymbolic = simplifySymbolic;
+exports.squareFreePart = squareFreePart;
 exports.substitute = substitute;
 exports.surdNode = surdNode;
 exports.symbolicKey = symbolicKey;
@@ -1655,5 +1787,5 @@ exports.symbolicToEntry = symbolicToEntry;
 exports.toPolynomial = toPolynomial;
 exports.transpose = transpose;
 exports.varNode = varNode;
-//# sourceMappingURL=chunk-4CVLFLOB.cjs.map
-//# sourceMappingURL=chunk-4CVLFLOB.cjs.map
+//# sourceMappingURL=chunk-UM6BVY2S.cjs.map
+//# sourceMappingURL=chunk-UM6BVY2S.cjs.map