@cortex-js/compute-engine 0.63.0 → 0.64.0

package/dist/compute-engine.umd.cjs

@@ -1,4 +1,4 @@
-/** Compute Engine 0.63.0 */
+/** Compute Engine 0.64.0 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ComputeEngine = {}));})(this, (function (exports) { 'use strict';
 "use strict";
 var ComputeEngine = (() => {
@@ -5355,7 +5355,6 @@ var ComputeEngine = (() => {
   }
 
   // src/compute-engine/numerics/primes.ts
-  var LARGE_PRIME = 1125899906842597;
   var SMALL_PRIMES = /* @__PURE__ */ new Set([
     2,
     3,
@@ -6402,102 +6401,60 @@ var ComputeEngine = (() => {
     else result[n] = 1;
     return result;
   }
-  function isPrime(n) {
-    if (!Number.isInteger(n) || !Number.isFinite(n) || Number.isNaN(n) || n <= 1) {
-      return false;
-    }
-    if (n <= LARGEST_SMALL_PRIME) return SMALL_PRIMES.has(n);
-    for (const smallPrime of SMALL_PRIMES) {
-      if (n % smallPrime === 0) return false;
-    }
-    if (n < LARGE_PRIME) return n === leastFactor(n) || void 0;
-    return probablyPrime(n, 30) ? void 0 : false;
-  }
-  function leastFactor(n) {
-    if (n === 1) return 1;
-    if (n % 2 === 0) return 2;
-    if (n % 3 === 0) return 3;
-    if (n % 5 === 0) return 5;
-    const m = Math.floor(Math.sqrt(n));
-    let i = 7;
-    while (i <= m) {
-      if (n % i === 0) return i;
-      if (n % (i + 4) === 0) return i + 4;
-      if (n % (i + 6) === 0) return i + 6;
-      if (n % (i + 10) === 0) return i + 10;
-      if (n % (i + 12) === 0) return i + 12;
-      if (n % (i + 16) === 0) return i + 16;
-      if (n % (i + 22) === 0) return i + 22;
-      if (n % (i + 24) === 0) return i + 24;
-      i += 30;
-    }
-    return n;
-  }
+  var MILLER_RABIN_THRESHOLD = 1n << 32n;
+  var MILLER_RABIN_BASES = [
+    2n,
+    3n,
+    5n,
+    7n,
+    11n,
+    13n,
+    17n,
+    19n,
+    23n,
+    29n,
+    31n,
+    37n
+  ];
   function isPrimeBigint(n) {
-    if (n <= 1) return false;
-    if (n <= LARGEST_SMALL_PRIME) return isPrime(Number(n));
-    for (const smallPrime of SMALL_PRIMES) {
-      if (n % BigInt(smallPrime) === BigInt(0)) return false;
-    }
-    if (n < LARGE_PRIME) n = leastBigFactor(n);
-    return probablyPrimeBigint(n, 30) ? void 0 : false;
-  }
-  function leastBigFactor(n) {
-    if (n === BigInt(1)) return BigInt(1);
-    if (n % BigInt(2) === BigInt(0)) return BigInt(2);
-    if (n % BigInt(3) === BigInt(0)) return BigInt(3);
-    if (n % BigInt(5) === BigInt(0)) return BigInt(5);
-    const m = BigInt(Math.floor(Math.sqrt(Number(n))));
-    let i = BigInt(7);
-    while (i <= m) {
-      if (n % i === BigInt(0)) return i;
-      if (n % (i + BigInt(4)) === BigInt(0)) return i + BigInt(4);
-      if (n % (i + BigInt(6)) === BigInt(0)) return i + BigInt(6);
-      if (n % (i + BigInt(10)) === BigInt(0)) return i + BigInt(10);
-      if (n % (i + BigInt(12)) === BigInt(0)) return i + BigInt(12);
-      if (n % (i + BigInt(16)) === BigInt(0)) return i + BigInt(16);
-      if (n % (i + BigInt(22)) === BigInt(0)) return i + BigInt(22);
-      if (n % (i + BigInt(24)) === BigInt(0)) return i + BigInt(24);
-      i += BigInt(30);
+    if (n < 2n) return false;
+    if (n <= LARGEST_SMALL_PRIME) return SMALL_PRIMES.has(Number(n));
+    if (n < MILLER_RABIN_THRESHOLD) {
+      if (n % 2n === 0n || n % 3n === 0n) return false;
+      for (let i = 5n; i * i <= n; i += 6n)
+        if (n % i === 0n || n % (i + 2n) === 0n) return false;
+      return true;
     }
-    return n;
+    return millerRabin(n);
   }
-  function probablyPrime(n, k) {
-    let s = 0;
-    let d = n - 1;
-    while (d % 2 === 0) {
-      d /= 2;
-      ++s;
-    }
-    WitnessLoop: do {
-      let x = Math.pow(2 + Math.floor(Math.random() * (n - 3)), d) % n;
-      if (x === 1 || x === n - 1) continue;
-      for (let i = s - 1; i--; ) {
-        x = x * x % n;
-        if (x === 1) return false;
-        if (x === n - 1) continue WitnessLoop;
-      }
-      return false;
-    } while (--k);
-    return true;
+  function modPow(base, exp3, mod3) {
+    if (mod3 === 1n) return 0n;
+    let result = 1n;
+    base = (base % mod3 + mod3) % mod3;
+    while (exp3 > 0n) {
+      if (exp3 & 1n) result = result * base % mod3;
+      base = base * base % mod3;
+      exp3 >>= 1n;
+    }
+    return result;
   }
-  function probablyPrimeBigint(n, k) {
-    let s = 0;
-    let d = n - BigInt(1);
-    while (d % BigInt(2) === BigInt(0)) {
-      d = d / BigInt(2);
-      ++s;
-    }
-    WitnessLoop: do {
-      let x = BigInt(2 + Math.floor(Math.random() * (Number(n) - 3))) ** d % n;
-      if (x === BigInt(1) || x === n - BigInt(1)) continue;
-      for (let i = s - 1; i--; ) {
+  function millerRabin(n) {
+    for (const p of MILLER_RABIN_BASES) if (n % p === 0n) return n === p;
+    let d = n - 1n;
+    let s = 0n;
+    while (d % 2n === 0n) {
+      d /= 2n;
+      s += 1n;
+    }
+    WitnessLoop: for (const a of MILLER_RABIN_BASES) {
+      let x = modPow(a, d, n);
+      if (x === 1n || x === n - 1n) continue;
+      for (let r = 1n; r < s; r++) {
         x = x * x % n;
-        if (x === BigInt(1)) return false;
-        if (x === n - BigInt(1)) continue WitnessLoop;
+        if (x === n - 1n) continue WitnessLoop;
       }
       return false;
-    } while (--k);
+    }
     return true;
   }
   var PRIME_WHEEL_INC = [
@@ -6510,6 +6467,63 @@ var ComputeEngine = (() => {
     BigInt(2),
     BigInt(6)
   ];
+  function bigPrimeFactors(d) {
+    if (d < Number.MAX_SAFE_INTEGER) {
+      const factors = primeFactors(Number(d));
+      const result2 = /* @__PURE__ */ new Map();
+      for (const f of Object.keys(factors))
+        result2.set(bigint(f), factors[Number(f)]);
+      return result2;
+    }
+    let n = d;
+    const result = /* @__PURE__ */ new Map();
+    let count2 = 0;
+    let count3 = 0;
+    let count5 = 0;
+    let k = BigInt(10);
+    while (n % k === BigInt(0)) {
+      count2 += 1;
+      count5 += 1;
+      n = n / k;
+    }
+    k = BigInt(5);
+    while (n % k === BigInt(0)) {
+      count5 += 1;
+      n = n / k;
+    }
+    k = BigInt(3);
+    while (n % k === BigInt(0)) {
+      count3 += 1;
+      n = n / k;
+    }
+    k = BigInt(2);
+    while (n % k === BigInt(0)) {
+      count2 += 1;
+      n = n / k;
+    }
+    if (count2 > 0) result.set("2", count2);
+    if (count3 > 0) result.set("3", count3);
+    if (count5 > 0) result.set("5", count5);
+    k = BigInt(7);
+    let kIndex = "";
+    let i = 0;
+    while (k * k < n) {
+      if (n % k === BigInt(0)) {
+        if (!kIndex) kIndex = k.toString();
+        result.set(kIndex, (result.get(kIndex) ?? 0) + 1);
+        n = n / k;
+      } else {
+        k = k + PRIME_WHEEL_INC[i];
+        kIndex = "";
+        i = i < 7 ? i + 1 : 0;
+      }
+    }
+    if (n !== BigInt(1))
+      result.set(n.toString(), (result.get(n.toString()) ?? 0) + 1);
+    const r = /* @__PURE__ */ new Map();
+    for (const [k2, v] of result) r.set(bigint(k2), v);
+    return r;
+  }
 
   // src/compute-engine/numerics/numeric.ts
   var DEFAULT_PRECISION = 21;
@@ -25351,7 +25365,11 @@ ${lines.join("\n")}`;
   function toInteger(expr2) {
     if (!isNumber(expr2)) return null;
     const num = expr2.numericValue;
-    return Math.round(typeof num === "number" ? num : num.re);
+    const re = typeof num === "number" ? num : num.re;
+    if (!Number.isFinite(re)) return null;
+    const n = Math.round(re);
+    if (!Number.isSafeInteger(n)) return null;
+    return n;
   }
   function toBigint(expr2) {
     if (expr2 === void 0 || expr2 === null) return null;
@@ -31970,12 +31988,10 @@ ${lines.join("\n")}`;
   }
 
   // src/compute-engine/boxed-expression/predicates.ts
-  function isPrime2(expr2) {
+  function isPrime(expr2) {
     if (!expr2.isInteger) return void 0;
     if (expr2.isNegative) return void 0;
     if (!isNumber(expr2)) return void 0;
-    const n = toInteger(expr2);
-    if (n !== null) return isPrime(n);
     const b = asBigint(expr2);
     if (b !== null) return isPrimeBigint(b);
     return void 0;
@@ -37947,6 +37963,7 @@ ${lines.join("\n")}`;
         sgn: ([x]) => x.isNonNegative ? "positive" : x.isNegative || x.isReal === false ? "unsigned" : void 0,
         evaluate: (ops) => {
           const x = ops[0];
+          if (x.isInteger !== true) return void 0;
           const n = toInteger(x);
           if (n === null) return void 0;
           const ce = x.engine;
@@ -38900,7 +38917,7 @@ ${lines.join("\n")}`;
         broadcastable: true,
         signature: "(number) -> boolean",
         evaluate: ([n], { engine }) => {
-          const result = isPrime2(n);
+          const result = isPrime(n);
           if (result === void 0) return void 0;
           return engine.symbol(result ? "True" : "False");
         }
@@ -39582,8 +39599,8 @@ ${lines.join("\n")}`;
     nonpositive: (x) => x.isNonPositive,
     even: (x) => x.isEven,
     odd: (x) => x.isOdd,
-    prime: (x) => isPrime2(x) === true,
-    composite: (x) => isPrime2(x) === false,
+    prime: (x) => isPrime(x) === true,
+    composite: (x) => isPrime(x) === false,
     notzero: (x) => x.isSame(0) === false,
     notone: (x) => x.isSame(1) === false,
     finite: (x) => x.isFinite,
@@ -56602,6 +56619,7 @@ ${e instanceof Error ? e.message : e}
         signature: "(integer) -> integer",
         type: () => "finite_integer",
         evaluate: ([n], { engine: ce }) => {
+          if (n.isInteger !== true) return void 0;
           const k = toInteger(n);
           if (k === null || k < 0) return void 0;
           let result = 1n;
@@ -56619,6 +56637,7 @@ ${e instanceof Error ? e.message : e}
         signature: "(integer) -> integer",
         type: () => "finite_integer",
         evaluate: ([n], { engine: ce }) => {
+          if (n.isInteger !== true) return void 0;
           const k = toInteger(n);
           if (k === null || k < 0) return void 0;
           let row = [1n];
@@ -58198,17 +58217,35 @@ ${e instanceof Error ? e.message : e}
         }
       },
       N: {
-        description: "Numerically evaluate an expression",
+        description: [
+          "N(expr): numerically evaluate an expression",
+          "N(expr, precision): evaluate to `precision` significant digits"
+        ],
         lazy: true,
-        signature: "(any) -> unknown",
+        signature: "(any, integer?) -> unknown",
         type: ([x]) => x.type,
         canonical: (ops, { engine: ce }) => {
-          if (ops.length !== 1) return ce._fn("N", checkArity(ce, ops, 1));
-          const h = ops[0].operator;
-          if (h === "N" || h === "Evaluate") return ops[0].canonical;
+          if (ops.length === 0) return ce._fn("N", checkArity(ce, ops, 1));
+          if (ops.length > 2) return ce._fn("N", checkArity(ce, ops, 2));
+          if (ops.length === 1) {
+            const h = ops[0].operator;
+            if (h === "N" || h === "Evaluate") return ops[0].canonical;
+          }
           return ce._fn("N", ops);
         },
-        evaluate: ([x]) => x.N()
+        evaluate: (ops, { engine: ce }) => {
+          const x = ops[0];
+          if (ops.length < 2) return x.canonical.N();
+          let p = ops[1].canonical.N().re;
+          if (!Number.isFinite(p) || p < 1) return x.canonical.N();
+          p = Math.min(Math.trunc(p), 1e3);
+          const global = ce.precision;
+          if (p > global) {
+            ce.precision = p;
+            return x.canonical.N();
+          }
+          return roundToSignificantDigits(x.canonical.N(), p);
+        }
       },
       Random: {
         description: [
@@ -58713,6 +58750,20 @@ ${e instanceof Error ? e.message : e}
       }
     }
   ];
+  function roundToSignificantDigits(value, p) {
+    const ce = value.engine;
+    const re = value.re;
+    const im = value.im;
+    if (!Number.isFinite(re) || !Number.isFinite(im)) return value;
+    if (im !== 0) {
+      const clamp2 = Math.min(p, 100);
+      return ce.number(
+        ce.complex(Number(re.toPrecision(clamp2)), Number(im.toPrecision(clamp2)))
+      );
+    }
+    const bd = value.bignumRe ?? ce.bignum(re);
+    return ce.number(bd.toPrecision(p));
+  }
 
   // src/compute-engine/library/linear-algebra.ts
   var LINEAR_ALGEBRA_LIBRARY = [
@@ -59171,6 +59222,165 @@ ${e instanceof Error ? e.message : e}
           return void 0;
         }
       },
+      Dot: {
+        description: "Dot product (vector inner product) or matrix product.",
+        complexity: 8300,
+        signature: "(matrix|vector, matrix|vector) -> value",
+        // `Dot` is Mathematica's `.`: it reduces to the inner product for two
+        // vectors and to the matrix product otherwise — exactly what
+        // `MatrixMultiply` already computes.
+        evaluate: (ops, { engine: ce }) => ce.function("MatrixMultiply", ops).evaluate()
+      },
+      MatrixRank: {
+        description: "Rank of a matrix (number of linearly independent rows/columns).",
+        complexity: 8200,
+        signature: "(value) -> integer",
+        sgn: () => "non-negative",
+        evaluate: ([map], { engine: ce }) => {
+          const op = map.evaluate();
+          if (op.isNumber) return ce.number(op.isSame(0) ? 0 : 1);
+          if (!isTensor2(op)) return void 0;
+          const shape = op.shape;
+          if (shape.length > 2) return ce.error("expected-matrix", op.toString());
+          const rowCount = shape.length === 1 ? 1 : shape[0];
+          const columnCount = shape.length === 1 ? shape[0] : shape[1];
+          const matrix = tensorToNumericMatrix(op, rowCount, columnCount);
+          if (!matrix) return void 0;
+          const nullity = computeNullSpaceBasis(matrix).length;
+          return ce.number(columnCount - nullity);
+        }
+      },
+      IsSquareMatrix: {
+        description: "Whether the value is a square matrix.",
+        complexity: 8200,
+        signature: "(value) -> boolean",
+        evaluate: ([m], { engine: ce }) => {
+          const op = m.evaluate();
+          if (!isTensor2(op)) return ce.False;
+          return op.tensor.isSquare ? ce.True : ce.False;
+        }
+      },
+      IsSymmetric: {
+        description: "Whether the matrix is symmetric (A equals its transpose).",
+        complexity: 8200,
+        signature: "(value) -> boolean",
+        evaluate: ([m], { engine: ce }) => {
+          const op = m.evaluate();
+          if (!isTensor2(op)) return ce.False;
+          return op.tensor.isSymmetric ? ce.True : ce.False;
+        }
+      },
+      IsDiagonal: {
+        description: "Whether the matrix is diagonal (all off-diagonal entries are zero).",
+        complexity: 8200,
+        signature: "(value) -> boolean",
+        evaluate: ([m], { engine: ce }) => {
+          const op = m.evaluate();
+          if (!isTensor2(op)) return ce.False;
+          return op.tensor.isDiagonal ? ce.True : ce.False;
+        }
+      },
+      Cross: {
+        description: "Cross product of two 3-vectors.",
+        complexity: 8300,
+        signature: "(vector, vector) -> vector",
+        evaluate: ([a, b], { engine: ce }) => {
+          const A = a.evaluate();
+          const B = b.evaluate();
+          if (!isTensor2(A) || !isTensor2(B)) return void 0;
+          if (A.shape.length !== 1 || A.shape[0] !== 3 || B.shape.length !== 1 || B.shape[0] !== 3)
+            return ce.error(
+              "incompatible-dimensions",
+              "cross product requires two 3-vectors"
+            );
+          const a1 = ce.expr(A.tensor.at(1) ?? ce.Zero);
+          const a2 = ce.expr(A.tensor.at(2) ?? ce.Zero);
+          const a3 = ce.expr(A.tensor.at(3) ?? ce.Zero);
+          const b1 = ce.expr(B.tensor.at(1) ?? ce.Zero);
+          const b2 = ce.expr(B.tensor.at(2) ?? ce.Zero);
+          const b3 = ce.expr(B.tensor.at(3) ?? ce.Zero);
+          return ce.function("List", [
+            a2.mul(b3).sub(a3.mul(b2)),
+            a3.mul(b1).sub(a1.mul(b3)),
+            a1.mul(b2).sub(a2.mul(b1))
+          ]).evaluate();
+        }
+      },
+      MatrixPower: {
+        description: "Square matrix raised to an integer power (repeated matrix product).",
+        complexity: 8300,
+        signature: "(matrix, integer) -> matrix",
+        evaluate: ([mat, exponent], { engine: ce }) => {
+          const A = mat.evaluate();
+          if (!isTensor2(A)) return void 0;
+          if (!A.tensor.isSquare)
+            return ce.error("expected-square-matrix", A.toString());
+          const n = exponent.re;
+          if (n === void 0 || !Number.isInteger(n)) return void 0;
+          const size = A.shape[0];
+          if (n === 0)
+            return ce.function("IdentityMatrix", [ce.number(size)]).evaluate();
+          let base = A;
+          let k = n;
+          if (n < 0) {
+            const inv = ce.function("Inverse", [A]).evaluate();
+            if (!isTensor2(inv)) return inv;
+            base = inv;
+            k = -n;
+          }
+          let result = base;
+          for (let i = 1; i < k; i++)
+            result = ce.function("MatrixMultiply", [result, base]).evaluate();
+          return result;
+        }
+      },
+      CharacteristicPolynomial: {
+        description: "Characteristic polynomial det(x\xB7I \u2212 A) of a square matrix (monic).",
+        complexity: 8700,
+        // The variable is accepted as `any` (not `symbol`): an undeclared symbol
+        // is inferred to have a numeric type, which would fail a `symbol`
+        // signature check. The evaluate handler validates it with `isSymbol`.
+        signature: "(matrix, any?) -> expression",
+        evaluate: ([mat, variable], { engine: ce }) => {
+          const A = mat.evaluate();
+          if (!isTensor2(A)) return void 0;
+          if (!A.tensor.isSquare)
+            return ce.error("expected-square-matrix", A.toString());
+          const x = variable && isSymbol2(variable) ? variable : ce.symbol("x");
+          const n = A.shape[0];
+          const rows = [];
+          for (let i = 0; i < n; i++) {
+            const row = [];
+            for (let j = 0; j < n; j++) {
+              const entry = ce.expr(A.tensor.at(i + 1, j + 1) ?? ce.Zero);
+              row.push(i === j ? x.sub(entry) : entry.neg());
+            }
+            rows.push(ce.function("List", row));
+          }
+          return ce.function("Determinant", [ce.function("List", rows)]).evaluate();
+        }
+      },
+      RowReduce: {
+        description: "Reduced row echelon form (RREF) of a matrix.",
+        complexity: 8200,
+        signature: "(matrix) -> matrix",
+        evaluate: ([m], { engine: ce }) => {
+          const op = m.evaluate();
+          if (!isTensor2(op)) return void 0;
+          const shape = op.shape;
+          if (shape.length !== 2)
+            return ce.error("expected-matrix", op.toString());
+          const matrix = tensorToNumericMatrix(op, shape[0], shape[1]);
+          if (!matrix) return void 0;
+          const { matrix: reduced } = rref(matrix);
+          return ce.expr([
+            "List",
+            ...reduced.map(
+              (row) => ce.expr(["List", ...row.map((value) => ce.number(ce.chop(value)))])
+            )
+          ]);
+        }
+      },
       // Diagonal can be used to:
       // 1. Create a diagonal matrix from a vector
       // 2. Extract the diagonal from a matrix as a vector
@@ -60781,6 +60991,628 @@ ${e instanceof Error ? e.message : e}
   // src/compute-engine/library/number-theory.ts
   var NUMBER_THEORY_LIBRARY = [
     {
+      FactorInteger: {
+        description: "Return the prime factorization of an integer `n` as a list of `[prime, exponent]` tuples, ordered by ascending prime. For a negative `n`, a leading `[-1, 1]` tuple carries the sign.",
+        signature: "(integer) -> list<tuple<integer, integer>>",
+        examples: ["FactorInteger(360)  // [(2, 3), (3, 2), (5, 1)]"],
+        evaluate: ([n], { engine: ce }) => {
+          const k = toBigint(n);
+          if (k === null) return void 0;
+          const tuple = (prime, exponent) => ce._fn("Tuple", [ce.number(prime), ce.number(exponent)]);
+          if (k === 0n) return ce.function("List", [tuple(0n, 1)]);
+          if (k === 1n) return ce.function("List", [tuple(1n, 1)]);
+          const result = [];
+          let m = k;
+          if (m < 0n) {
+            result.push(tuple(-1n, 1));
+            m = -m;
+          }
+          if (m > 1n) {
+            const factors = bigPrimeFactors(m);
+            const primes = [...factors.keys()].sort(
+              (a, b) => a < b ? -1 : a > b ? 1 : 0
+            );
+            for (const p of primes) result.push(tuple(p, factors.get(p)));
+          }
+          return ce.function("List", result);
+        }
+      },
+      Divisors: {
+        description: "Return the sorted list of positive divisors of an integer `n`. The sign of `n` is ignored.",
+        signature: "(integer) -> list<integer>",
+        examples: ["Divisors(12)  // [1, 2, 3, 4, 6, 12]"],
+        evaluate: ([n], { engine: ce }) => {
+          const k = toBigint(n);
+          if (k === null) return void 0;
+          const m = k < 0n ? -k : k;
+          if (m === 0n) return void 0;
+          return ce.function(
+            "List",
+            divisorsAscending(m, ce._deadline).map((d) => ce.number(d))
+          );
+        }
+      },
+      NthPrime: {
+        description: "Return the nth prime number (1-based): `NthPrime(1)` is 2, `NthPrime(2)` is 3, \u2026",
+        signature: "(integer) -> integer",
+        type: () => "finite_integer",
+        examples: ["NthPrime(10)  // 29"],
+        evaluate: ([n], { engine: ce }) => {
+          const k = toBigint(n);
+          if (k === null || k < 1n) return void 0;
+          if (k === 1n) return ce.number(2);
+          let count = 1n;
+          let candidate = 1n;
+          let steps = 0;
+          while (count < k) {
+            candidate += 2n;
+            if ((++steps & 1023) === 0) checkDeadline(ce._deadline);
+            if (isPrimeBigint(candidate)) count += 1n;
+          }
+          return ce.number(candidate);
+        }
+      },
+      NextPrime: {
+        description: "Return the smallest prime greater than `n`. With a second argument `k`, return the kth prime after `n` (`k < 0` returns the |k|th prime before `n`).",
+        signature: "(integer, integer?) -> integer",
+        type: () => "finite_integer",
+        examples: ["NextPrime(10)  // 11", "NextPrime(10, -1)  // 7"],
+        evaluate: ([n, kArg], { engine: ce }) => {
+          const start = toBigint(n);
+          if (start === null) return void 0;
+          const k = kArg === void 0 ? 1n : toBigint(kArg);
+          if (k === null || k === 0n) return void 0;
+          let p = start;
+          let steps = 0;
+          if (k > 0n) {
+            for (let i = 0n; i < k; i++) {
+              do {
+                p += 1n;
+                if ((++steps & 1023) === 0) checkDeadline(ce._deadline);
+              } while (!isPrimeBigint(p));
+            }
+          } else {
+            for (let i = 0n; i > k; i--) {
+              do {
+                p -= 1n;
+                if ((++steps & 1023) === 0) checkDeadline(ce._deadline);
+                if (p < 2n) return void 0;
+              } while (!isPrimeBigint(p));
+            }
+          }
+          return ce.number(p);
+        }
+      },
+      PrimeFactors: {
+        description: "Return the sorted list of distinct prime factors of an integer `n`. The sign of `n` is ignored; `PrimeFactors(1)` is the empty list.",
+        signature: "(integer) -> list<integer>",
+        examples: ["PrimeFactors(360)  // [2, 3, 5]"],
+        evaluate: ([n], { engine: ce }) => {
+          const k = toBigint(n);
+          if (k === null) return void 0;
+          const m = k < 0n ? -k : k;
+          if (m === 0n) return void 0;
+          const primes = [...bigPrimeFactors(m).keys()].filter((p) => p !== 1n).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+          return ce.function(
+            "List",
+            primes.map((p) => ce.number(p))
+          );
+        }
+      },
+      PrimeNu: {
+        description: "Return \u03C9(n), the number of distinct prime factors of `n`. The sign of `n` is ignored; `PrimeNu(1)` is 0.",
+        signature: "(integer) -> integer",
+        type: () => "finite_integer",
+        examples: ["PrimeNu(360)  // 3"],
+        evaluate: ([n], { engine: ce }) => {
+          const k = toBigint(n);
+          if (k === null) return void 0;
+          const m = k < 0n ? -k : k;
+          if (m === 0n) return void 0;
+          if (m === 1n) return ce.number(0);
+          return ce.number(bigPrimeFactors(m).size);
+        }
+      },
+      PrimeOmega: {
+        description: "Return \u03A9(n), the number of prime factors of `n` counted with multiplicity. The sign of `n` is ignored; `PrimeOmega(1)` is 0.",
+        signature: "(integer) -> integer",
+        type: () => "finite_integer",
+        examples: ["PrimeOmega(360)  // 6"],
+        evaluate: ([n], { engine: ce }) => {
+          const k = toBigint(n);
+          if (k === null) return void 0;
+          const m = k < 0n ? -k : k;
+          if (m === 0n) return void 0;
+          if (m === 1n) return ce.number(0);
+          let total = 0;
+          for (const e of bigPrimeFactors(m).values()) total += e;
+          return ce.number(total);
+        }
+      },
+      MoebiusMu: {
+        description: "Return the M\xF6bius function \u03BC(n): 0 if `n` is divisible by a perfect square > 1, otherwise (-1) raised to the number of distinct prime factors. The sign of `n` is ignored.",
+        signature: "(integer) -> integer",
+        type: () => "finite_integer",
+        examples: ["MoebiusMu(30)  // -1"],
+        evaluate: ([n], { engine: ce }) => {
+          const k = toBigint(n);
+          if (k === null) return void 0;
+          const m = k < 0n ? -k : k;
+          if (m === 0n) return void 0;
+          if (m === 1n) return ce.number(1);
+          const factors = bigPrimeFactors(m);
+          for (const e of factors.values()) if (e > 1) return ce.number(0);
+          return ce.number(factors.size % 2 === 0 ? 1 : -1);
+        }
+      },
+      IsSquareFree: {
+        description: 'Return `"True"` if `n` is square-free (not divisible by any perfect square > 1). The sign of `n` is ignored.',
+        signature: "(integer) -> boolean",
+        examples: ['IsSquareFree(30)  // "True"'],
+        evaluate: ([n], { engine: ce }) => {
+          const k = toBigint(n);
+          if (k === null) return void 0;
+          const m = k < 0n ? -k : k;
+          if (m === 0n) return ce.False;
+          if (m === 1n) return ce.True;
+          const factors = bigPrimeFactors(m);
+          for (const e of factors.values()) if (e > 1) return ce.False;
+          return ce.True;
+        }
+      },
+      Radical: {
+        description: "Return the radical of `n` (its square-free kernel): the product of its distinct prime factors. The sign of `n` is ignored; `Radical(1)` is 1.",
+        signature: "(integer) -> integer",
+        type: () => "finite_integer",
+        examples: ["Radical(360)  // 30"],
+        evaluate: ([n], { engine: ce }) => {
+          const k = toBigint(n);
+          if (k === null) return void 0;
+          const m = k < 0n ? -k : k;
+          if (m === 0n) return void 0;
+          if (m === 1n) return ce.number(1);
+          let product = 1n;
+          for (const p of bigPrimeFactors(m).keys()) product *= p;
+          return ce.number(product);
+        }
+      },
+      PowerMod: {
+        description: "Return `a^b mod m` (modular exponentiation). A negative `b` uses the modular inverse of `a`; the result is undefined when that inverse does not exist (i.e. when `a` and `m` are not coprime). The result is in the range [0, m).",
+        signature: "(integer, integer, integer) -> integer",
+        type: () => "finite_integer",
+        examples: ["PowerMod(2, 10, 1000)  // 24"],
+        evaluate: ([aOp, bOp, mOp], { engine: ce }) => {
+          const a = toBigint(aOp);
+          const b = toBigint(bOp);
+          const m = toBigint(mOp);
+          if (a === null || b === null || m === null) return void 0;
+          if (m <= 0n) return void 0;
+          if (m === 1n) return ce.number(0);
+          if (b >= 0n) return ce.number(modPow(a, b, m));
+          const base = (a % m + m) % m;
+          const [g, s] = extGcd(base, m);
+          if (g !== 1n) return void 0;
+          const inv = (s % m + m) % m;
+          return ce.number(modPow(inv, -b, m));
+        }
+      },
+      ExtendedGCD: {
+        description: "Return the extended GCD of `a` and `b` as a tuple `(g, x, y)` where `g = gcd(a, b)` is non-negative and `a\xB7x + b\xB7y = g` (B\xE9zout coefficients).",
+        signature: "(integer, integer) -> tuple<integer, integer, integer>",
+        examples: ["ExtendedGCD(12, 18)  // (6, -1, 1)"],
+        evaluate: ([aOp, bOp], { engine: ce }) => {
+          const a = toBigint(aOp);
+          const b = toBigint(bOp);
+          if (a === null || b === null) return void 0;
+          let [g, x, y] = extGcd(a, b);
+          if (g < 0n) {
+            g = -g;
+            x = -x;
+            y = -y;
+          }
+          return ce._fn("Tuple", [ce.number(g), ce.number(x), ce.number(y)]);
+        }
+      },
+      IntegerSqrt: {
+        description: "Return the integer square root of `n`, i.e. the largest integer `m` such that `m\xB2 \u2264 n`. Undefined for negative `n`.",
+        signature: "(integer) -> integer",
+        type: () => "finite_integer",
+        examples: ["IntegerSqrt(17)  // 4"],
+        evaluate: ([n], { engine: ce }) => {
+          const k = toBigint(n);
+          if (k === null || k < 0n) return void 0;
+          return ce.number(bigintSqrt2(k));
+        }
+      },
+      ChineseRemainder: {
+        description: "Solve a system of simultaneous congruences: return the smallest non-negative integer `x` such that `x \u2261 residues[i] (mod moduli[i])` for every `i`. Undefined if the system is inconsistent or the two lists differ in length.",
+        signature: "(collection, collection) -> integer",
+        examples: ["ChineseRemainder([2, 3, 2], [3, 5, 7])  // 23"],
+        evaluate: ([residuesOp, moduliOp], { engine: ce }) => {
+          const residues = Array.from(residuesOp?.each() ?? []).map(toBigint);
+          const moduli = Array.from(moduliOp?.each() ?? []).map(toBigint);
+          if (residues.length === 0 || residues.length !== moduli.length)
+            return void 0;
+          if (residues.includes(null) || moduli.includes(null)) return void 0;
+          const x = chineseRemainder(residues, moduli);
+          if (x === null) return void 0;
+          return ce.number(x);
+        }
+      },
+      CarmichaelLambda: {
+        description: "Return the Carmichael function \u03BB(n) (the reduced totient): the smallest positive integer `m` such that `a^m \u2261 1 (mod n)` for every `a` coprime to `n`. Defined for `n \u2265 1`.",
+        signature: "(integer) -> integer",
+        type: () => "finite_integer",
+        examples: ["CarmichaelLambda(15)  // 4"],
+        evaluate: ([n], { engine: ce }) => {
+          const k = toBigint(n);
+          if (k === null || k < 1n) return void 0;
+          return ce.number(carmichaelLambda(k));
+        }
+      },
+      LucasL: {
+        description: "Return the nth Lucas number: `LucasL(0)` is 2, `LucasL(1)` is 1, and `LucasL(n) = LucasL(n-1) + LucasL(n-2)`. Negative indices follow `LucasL(-n) = (-1)^n \xB7 LucasL(n)`.",
+        signature: "(integer) -> integer",
+        type: () => "finite_integer",
+        examples: ["LucasL(10)  // 123"],
+        evaluate: ([n], { engine: ce }) => {
+          const k = toBigint(n);
+          if (k === null) return void 0;
+          const neg2 = k < 0n;
+          const kk = neg2 ? -k : k;
+          let a = 2n;
+          let b = 1n;
+          let steps = 0;
+          for (let i = 0n; i < kk; i++) {
+            if ((++steps & 4095) === 0) checkDeadline(ce._deadline);
+            [a, b] = [b, a + b];
+          }
+          return ce.number(neg2 && kk % 2n === 1n ? -a : a);
+        }
+      },
+      CatalanNumber: {
+        description: "Return the nth Catalan number `C(n) = (2n)! / ((n+1)! \xB7 n!)`: 1, 1, 2, 5, 14, 42, \u2026 Defined for `n \u2265 0`.",
+        signature: "(integer) -> integer",
+        type: () => "finite_integer",
+        examples: ["CatalanNumber(5)  // 42"],
+        evaluate: ([n], { engine: ce }) => {
+          const k = toBigint(n);
+          if (k === null || k < 0n) return void 0;
+          let c = 1n;
+          let steps = 0;
+          for (let i = 0n; i < k; i++) {
+            if ((++steps & 4095) === 0) checkDeadline(ce._deadline);
+            c = c * 2n * (2n * i + 1n) / (i + 2n);
+          }
+          return ce.number(c);
+        }
+      },
+      IsPerfectPower: {
+        description: 'Return `"True"` if `n` is a perfect power `a^b` for integers `a` and `b \u2265 2` (a negative `n` requires an odd exponent). The smallest perfect power is 4.',
+        signature: "(integer) -> boolean",
+        examples: ['IsPerfectPower(64)  // "True"'],
+        evaluate: ([n], { engine: ce }) => {
+          const k = toBigint(n);
+          if (k === null) return void 0;
+          const m = k < 0n ? -k : k;
+          if (m < 4n) return ce.False;
+          return ce.symbol(
+            isPerfectPowerBigint(m, k < 0n, ce._deadline) ? "True" : "False"
+          );
+        }
+      },
+      ContinuedFraction: {
+        description: "Return the continued-fraction expansion of `x` as a list of integer terms `[a0, a1, \u2026]`. An exact rational is expanded fully; for an inexact value the expansion is truncated to the optional `n` terms (default 20).",
+        signature: "(number, integer?) -> list<integer>",
+        examples: ["ContinuedFraction(43/19)  // [2, 3, 1, 4]"],
+        evaluate: ([xOp, nOp], { engine: ce }) => {
+          if (xOp === void 0) return void 0;
+          const maxTerms = nOp === void 0 ? void 0 : Number(toBigint(nOp) ?? 0n);
+          if (maxTerms !== void 0 && maxTerms < 1) return void 0;
+          const terms = [];
+          if (xOp.isRational) {
+            let a = toBigint(xOp.numerator);
+            let b = toBigint(xOp.denominator);
+            if (a === null || b === null || b === 0n) return void 0;
+            if (b < 0n) {
+              a = -a;
+              b = -b;
+            }
+            while (b !== 0n) {
+              let q = a / b;
+              if (a % b !== 0n && a < 0n !== b < 0n) q -= 1n;
+              terms.push(q);
+              [a, b] = [b, a - q * b];
+              if (maxTerms !== void 0 && terms.length >= maxTerms) break;
+            }
+          } else {
+            let val = xOp.re;
+            if (!Number.isFinite(val)) return void 0;
+            const cap = maxTerms ?? 20;
+            for (let i = 0; i < cap; i++) {
+              const fl = Math.floor(val);
+              terms.push(BigInt(fl));
+              const frac = val - fl;
+              if (frac < 1e-12) break;
+              val = 1 / frac;
+              if (!Number.isFinite(val)) break;
+            }
+          }
+          return ce.function(
+            "List",
+            terms.map((t) => ce.number(t))
+          );
+        }
+      },
+      FromContinuedFraction: {
+        description: "Reconstruct the (rational) value of a continued fraction given its list of integer terms `[a0, a1, \u2026]`.",
+        signature: "(collection) -> number",
+        examples: ["FromContinuedFraction([2, 3, 1, 4])  // 43/19"],
+        evaluate: ([listOp], { engine: ce }) => {
+          const terms = Array.from(listOp?.each() ?? []).map(toBigint);
+          if (terms.length === 0 || terms.includes(null)) return void 0;
+          let p = 1n;
+          let q = 0n;
+          for (let i = terms.length - 1; i >= 0; i--)
+            [p, q] = [terms[i] * p + q, p];
+          if (q === 0n) return void 0;
+          return ce.number(p).div(ce.number(q));
+        }
+      },
+      IntegerDigits: {
+        description: "Return the digits of `n` in the given `base` (default 10), most-significant first. The sign of `n` is ignored. With a third argument `length`, the result is zero-padded on the left (or truncated to its least-significant digits) to that length.",
+        signature: "(integer, integer?, integer?) -> list<integer>",
+        examples: ["IntegerDigits(255, 16)  // [15, 15]"],
+        evaluate: ([nOp, baseOp, lenOp], { engine: ce }) => {
+          const k = toBigint(nOp);
+          if (k === null) return void 0;
+          const base = baseOp === void 0 ? 10n : toBigint(baseOp);
+          if (base === null || base < 2n) return void 0;
+          let m = k < 0n ? -k : k;
+          const digits = [];
+          if (m === 0n) digits.push(0n);
+          while (m > 0n) {
+            digits.push(m % base);
+            m = m / base;
+          }
+          digits.reverse();
+          if (lenOp !== void 0) {
+            const len = toBigint(lenOp);
+            if (len === null || len < 0n) return void 0;
+            const L = Number(len);
+            while (digits.length < L) digits.unshift(0n);
+            if (digits.length > L) digits.splice(0, digits.length - L);
+          }
+          return ce.function(
+            "List",
+            digits.map((d) => ce.number(d))
+          );
+        }
+      },
+      DigitCount: {
+        description: "Count digits of `n` in the given `base` (default 10); the sign of `n` is ignored. With a third argument `digit`, return how many times that digit occurs. Otherwise return a list `[count of 1, count of 2, \u2026, count of base-1, count of 0]`.",
+        signature: "(integer, integer?, integer?) -> integer | list<integer>",
+        type: ([, , digit]) => digit !== void 0 ? "finite_integer" : "list",
+        examples: ["DigitCount(122, 10, 2)  // 2"],
+        evaluate: ([nOp, baseOp, digitOp], { engine: ce }) => {
+          const k = toBigint(nOp);
+          if (k === null) return void 0;
+          const base = baseOp === void 0 ? 10n : toBigint(baseOp);
+          if (base === null || base < 2n) return void 0;
+          const counts = /* @__PURE__ */ new Map();
+          let m = k < 0n ? -k : k;
+          if (m === 0n) counts.set(0n, 1);
+          while (m > 0n) {
+            const d = m % base;
+            counts.set(d, (counts.get(d) ?? 0) + 1);
+            m = m / base;
+          }
+          if (digitOp !== void 0) {
+            const d = toBigint(digitOp);
+            if (d === null || d < 0n || d >= base) return void 0;
+            return ce.number(counts.get(d) ?? 0);
+          }
+          const list = [];
+          for (let d = 1n; d < base; d++)
+            list.push(ce.number(counts.get(d) ?? 0));
+          list.push(ce.number(counts.get(0n) ?? 0));
+          return ce.function("List", list);
+        }
+      },
+      RandomPrime: {
+        description: "Return a random prime. `RandomPrime(n)` draws a prime in [2, n]; `RandomPrime(m, n)` draws a prime in [m, n]. Undefined if the range contains no prime.",
+        pure: false,
+        signature: "(integer, integer?) -> integer",
+        type: () => "finite_integer",
+        examples: ["RandomPrime(100)  // e.g. 47"],
+        evaluate: ([aOp, bOp], { engine: ce }) => {
+          let lo;
+          let hi;
+          if (bOp === void 0) {
+            lo = 2n;
+            hi = toBigint(aOp);
+          } else {
+            lo = toBigint(aOp);
+            hi = toBigint(bOp);
+          }
+          if (lo === null || hi === null) return void 0;
+          if (lo < 2n) lo = 2n;
+          if (hi < lo) return void 0;
+          const range2 = hi - lo + 1n;
+          const attempts = 100 + 20 * hi.toString().length;
+          for (let i = 0; i < attempts; i++) {
+            const r = lo + randomBigintBelow(range2);
+            if (isPrimeBigint(r)) return ce.number(r);
+          }
+          for (let p = lo; p <= hi; p++) {
+            checkDeadline(ce._deadline);
+            if (isPrimeBigint(p)) return ce.number(p);
+          }
+          return void 0;
+        }
+      },
+      PrimePi: {
+        description: "Return \u03C0(n), the prime-counting function: the number of primes less than or equal to `n`.",
+        signature: "(real) -> integer",
+        type: () => "finite_integer",
+        examples: ["PrimePi(10)  // 4"],
+        evaluate: ([n], { engine: ce }) => {
+          const x = n?.re;
+          if (x === void 0 || !Number.isFinite(x)) return void 0;
+          const bound = BigInt(Math.floor(x));
+          if (bound < 2n) return ce.number(0);
+          let count = 1;
+          let steps = 0;
+          for (let k = 3n; k <= bound; k += 2n) {
+            if ((++steps & 1023) === 0) checkDeadline(ce._deadline);
+            if (isPrimeBigint(k)) count++;
+          }
+          return ce.number(count);
+        }
+      },
+      BernoulliB: {
+        description: "Return the nth Bernoulli number B\u2099 as an exact rational, using the convention B\u2081 = -1/2. Odd `n > 1` give 0.",
+        signature: "(integer) -> finite_rational",
+        type: () => "finite_rational",
+        examples: ["BernoulliB(2)  // 1/6"],
+        evaluate: ([n], { engine: ce }) => {
+          const k = toBigint(n);
+          if (k === null || k < 0n) return void 0;
+          if (k === 0n) return ce.number(1);
+          if (k === 1n) return ce.number(-1).div(ce.number(2));
+          if (k % 2n === 1n) return ce.number(0);
+          const [num, den] = bernoulliNumber(Number(k), ce._deadline);
+          return den === 1n ? ce.number(num) : ce.number(num).div(ce.number(den));
+        }
+      },
+      FromDigits: {
+        description: "Reconstruct an integer from its list of digits (most-significant first) in the given `base` (default 10). The inverse of `IntegerDigits`. Digits outside `[0, base)` are combined positionally (Horner evaluation).",
+        signature: "(collection, integer?) -> integer",
+        type: () => "finite_integer",
+        examples: ["FromDigits([1, 2, 3, 4])  // 1234"],
+        evaluate: ([digitsOp, baseOp], { engine: ce }) => {
+          const digits = Array.from(digitsOp?.each() ?? []).map(toBigint);
+          if (digits.length === 0 || digits.includes(null)) return void 0;
+          const base = baseOp === void 0 ? 10n : toBigint(baseOp);
+          if (base === null || base < 2n) return void 0;
+          let result = 0n;
+          for (const d of digits) result = result * base + d;
+          return ce.number(result);
+        }
+      },
+      DigitSum: {
+        description: "Return the sum of the digits of `n` in the given `base` (default 10). The sign of `n` is ignored.",
+        signature: "(integer, integer?) -> integer",
+        type: () => "finite_integer",
+        examples: ["DigitSum(1234)  // 10"],
+        evaluate: ([nOp, baseOp], { engine: ce }) => {
+          const k = toBigint(nOp);
+          if (k === null) return void 0;
+          const base = baseOp === void 0 ? 10n : toBigint(baseOp);
+          if (base === null || base < 2n) return void 0;
+          let m = k < 0n ? -k : k;
+          let sum = 0n;
+          while (m > 0n) {
+            sum += m % base;
+            m /= base;
+          }
+          return ce.number(sum);
+        }
+      },
+      DivisorSigma: {
+        description: "The divisor function \u03C3_k(n) = \u03A3_{d | n} d\u1D4F over the positive divisors of `n`. \u03C3\u2080 counts divisors, \u03C3\u2081 sums them. Defined for `n \u2265 1`.",
+        signature: "(integer, integer) -> integer",
+        type: () => "finite_integer",
+        examples: ["DivisorSigma(2, 6)  // 50"],
+        evaluate: ([kOp, nOp], { engine: ce }) => {
+          const k = toBigint(kOp);
+          const n = toBigint(nOp);
+          if (k === null || n === null || k < 0n || n < 1n) return void 0;
+          if (n === 1n) return ce.number(1);
+          let result = 1n;
+          for (const [p, e] of bigPrimeFactors(n)) {
+            if (k === 0n) result *= BigInt(e + 1);
+            else {
+              const pk = p ** k;
+              result *= (pk ** BigInt(e + 1) - 1n) / (pk - 1n);
+            }
+          }
+          return ce.number(result);
+        }
+      },
+      JacobiSymbol: {
+        description: "The Jacobi symbol (a/n) for an odd `n > 0`. Returns -1, 0, or 1. Undefined when `n` is even or non-positive.",
+        signature: "(integer, integer) -> integer",
+        type: () => "finite_integer",
+        examples: ["JacobiSymbol(5, 21)  // 1"],
+        evaluate: ([aOp, nOp], { engine: ce }) => {
+          const a = toBigint(aOp);
+          const n = toBigint(nOp);
+          if (a === null || n === null) return void 0;
+          if (n <= 0n || n % 2n === 0n) return void 0;
+          return ce.number(jacobiSymbol(a, n));
+        }
+      },
+      LegendreSymbol: {
+        description: "The Legendre symbol (a/p) for an odd prime `p`. Returns -1, 0, or 1. Undefined when `p` is not an odd prime.",
+        signature: "(integer, integer) -> integer",
+        type: () => "finite_integer",
+        examples: ["LegendreSymbol(3, 7)  // -1"],
+        evaluate: ([aOp, pOp], { engine: ce }) => {
+          const a = toBigint(aOp);
+          const p = toBigint(pOp);
+          if (a === null || p === null) return void 0;
+          if (p <= 2n || p % 2n === 0n || !isPrimeBigint(p)) return void 0;
+          return ce.number(jacobiSymbol(a, p));
+        }
+      },
+      MultiplicativeOrder: {
+        description: "The multiplicative order of `a` modulo `n`: the smallest `k > 0` such that `a^k \u2261 1 (mod n)`. Undefined unless `a` and `n` are coprime.",
+        signature: "(integer, integer) -> integer",
+        type: () => "finite_integer",
+        examples: ["MultiplicativeOrder(2, 7)  // 3"],
+        evaluate: ([aOp, nOp], { engine: ce }) => {
+          const a0 = toBigint(aOp);
+          const n = toBigint(nOp);
+          if (a0 === null || n === null || n < 1n) return void 0;
+          if (n === 1n) return ce.number(1);
+          const a = (a0 % n + n) % n;
+          if (gcd2(a, n) !== 1n) return void 0;
+          for (const d of divisorsAscending(carmichaelLambda(n), ce._deadline)) {
+            checkDeadline(ce._deadline);
+            if (modPow(a, d, n) === 1n) return ce.number(d);
+          }
+          return void 0;
+        }
+      },
+      PrimitiveRoot: {
+        description: "The smallest primitive root modulo `n` (a generator of the multiplicative group of integers mod `n`), or undefined if none exists (which happens unless `n` is 1, 2, 4, p\u1D4F, or 2p\u1D4F for an odd prime p).",
+        signature: "(integer) -> integer",
+        type: () => "finite_integer",
+        examples: ["PrimitiveRoot(7)  // 3"],
+        evaluate: ([nOp], { engine: ce }) => {
+          const n = toBigint(nOp);
+          if (n === null || n < 1n) return void 0;
+          if (n === 1n) return ce.number(0);
+          if (n === 2n) return ce.number(1);
+          if (n === 4n) return ce.number(3);
+          if (!hasPrimitiveRoot(n)) return void 0;
+          const phi = eulerPhi(n);
+          const phiFactors = [...bigPrimeFactors(phi).keys()];
+          for (let a = 2n; a < n; a++) {
+            checkDeadline(ce._deadline);
+            if (gcd2(a, n) !== 1n) continue;
+            if (phiFactors.every((q) => modPow(a, phi / q, n) !== 1n))
+              return ce.number(a);
+          }
+          return void 0;
+        }
+      },
+      PrimeNumber: {
+        description: "The nth prime number. `PrimeNumber` is an alias for `NthPrime`, which is the preferred name.",
+        signature: "(integer) -> integer",
+        canonical: ([n], { engine }) => engine._fn("NthPrime", [n])
+      },
       Totient: {
         wikidata: "Q190026",
         description: "Euler's totient function \u03C6(n): count of positive integers \u2264 n that are coprime to n.",
@@ -61017,6 +61849,165 @@ ${e instanceof Error ? e.message : e}
       }
     }
   ];
+  function extGcd(a, b) {
+    let [oldR, r] = [a, b];
+    let [oldS, s] = [1n, 0n];
+    let [oldT, t] = [0n, 1n];
+    while (r !== 0n) {
+      const q = oldR / r;
+      [oldR, r] = [r, oldR - q * r];
+      [oldS, s] = [s, oldS - q * s];
+      [oldT, t] = [t, oldT - q * t];
+    }
+    return [oldR, oldS, oldT];
+  }
+  function bigintSqrt2(n) {
+    if (n < 2n) return n;
+    let x = 1n << (BigInt(n.toString(2).length) + 1n) / 2n;
+    for (; ; ) {
+      const y = x + n / x >> 1n;
+      if (y >= x) break;
+      x = y;
+    }
+    while (x * x > n) x -= 1n;
+    return x;
+  }
+  function chineseRemainder(residues, moduli) {
+    let x = 0n;
+    let m = 1n;
+    for (let i = 0; i < residues.length; i++) {
+      const ni = moduli[i];
+      if (ni <= 0n) return null;
+      const ri = (residues[i] % ni + ni) % ni;
+      const [g, p] = extGcd(m, ni);
+      if ((ri - x) % g !== 0n) return null;
+      const lcmMN = m / g * ni;
+      const mod22 = ni / g;
+      const lambda = ((ri - x) / g * p % mod22 + mod22) % mod22;
+      x = ((x + m * lambda) % lcmMN + lcmMN) % lcmMN;
+      m = lcmMN;
+    }
+    return x;
+  }
+  function iroot(n, b) {
+    if (n < 2n) return n;
+    const bb = BigInt(b);
+    const approx = Math.pow(Number(n), 1 / b);
+    let x = Number.isFinite(approx) ? BigInt(Math.round(approx)) : 1n << BigInt(n.toString(2).length) / bb + 1n;
+    if (x < 1n) x = 1n;
+    while (x ** bb > n) x -= 1n;
+    while ((x + 1n) ** bb <= n) x += 1n;
+    return x;
+  }
+  function isPerfectPowerBigint(m, oddOnly, deadline) {
+    const bits = m.toString(2).length;
+    for (let b = oddOnly ? 3 : 2; b <= bits; b++) {
+      if (oddOnly && b % 2 === 0) continue;
+      checkDeadline(deadline);
+      const r = iroot(m, b);
+      if (r >= 2n && r ** BigInt(b) === m) return true;
+    }
+    return false;
+  }
+  function randomBigintBelow(n) {
+    if (n <= 1n) return 0n;
+    if (n <= BigInt(Number.MAX_SAFE_INTEGER))
+      return BigInt(Math.floor(Math.random() * Number(n)));
+    const bits = n.toString(2).length;
+    let r;
+    do {
+      r = 0n;
+      for (let i = 0; i < bits; i += 30)
+        r = r << 30n | BigInt(Math.floor(Math.random() * (1 << 30)));
+      r &= (1n << BigInt(bits)) - 1n;
+    } while (r >= n);
+    return r;
+  }
+  function divisorsAscending(m, deadline) {
+    const small = [];
+    const large = [];
+    let steps = 0;
+    for (let i = 1n; i * i <= m; i++) {
+      if ((++steps & 4095) === 0) checkDeadline(deadline);
+      if (m % i === 0n) {
+        small.push(i);
+        const j = m / i;
+        if (j !== i) large.push(j);
+      }
+    }
+    large.reverse();
+    return [...small, ...large];
+  }
+  function eulerPhi(n) {
+    if (n <= 1n) return 1n;
+    let result = n;
+    for (const p of bigPrimeFactors(n).keys()) result = result / p * (p - 1n);
+    return result;
+  }
+  function carmichaelLambda(n) {
+    if (n <= 1n) return 1n;
+    let result = 1n;
+    for (const [p, e] of bigPrimeFactors(n)) {
+      const lambda = p === 2n ? e === 1 ? 1n : e === 2 ? 2n : 1n << BigInt(e - 2) : p ** BigInt(e - 1) * (p - 1n);
+      result = lcm2(result, lambda);
+    }
+    return result;
+  }
+  function jacobiSymbol(a, n) {
+    a = (a % n + n) % n;
+    let result = 1;
+    while (a !== 0n) {
+      while (a % 2n === 0n) {
+        a /= 2n;
+        const r = n % 8n;
+        if (r === 3n || r === 5n) result = -result;
+      }
+      [a, n] = [n, a];
+      if (a % 4n === 3n && n % 4n === 3n) result = -result;
+      a %= n;
+    }
+    return n === 1n ? result : 0;
+  }
+  function hasPrimitiveRoot(n) {
+    if (n === 1n || n === 2n || n === 4n) return true;
+    let m = n;
+    let twos = 0;
+    while (m % 2n === 0n) {
+      m /= 2n;
+      twos++;
+    }
+    if (twos > 1) return false;
+    if (m === 1n) return false;
+    return bigPrimeFactors(m).size === 1;
+  }
+  function reduceRat(num, den) {
+    if (den < 0n) {
+      num = -num;
+      den = -den;
+    }
+    const g = gcd2(num < 0n ? -num : num, den);
+    return g > 1n ? [num / g, den / g] : [num, den];
+  }
+  function bernoulliNumber(n, deadline) {
+    const B = [[1n, 1n]];
+    for (let m = 1; m <= n; m++) {
+      checkDeadline(deadline);
+      let sNum = 0n;
+      let sDen = 1n;
+      let c = 1n;
+      for (let k = 0; k < m; k++) {
+        const tNum = c * B[k][0];
+        const tDen = B[k][1];
+        const g = gcd2(sDen, tDen);
+        sNum = sNum * (tDen / g) + tNum * (sDen / g);
+        sDen = sDen / g * tDen;
+        [sNum, sDen] = reduceRat(sNum, sDen);
+        c = c * BigInt(m + 1 - k) / BigInt(k + 1);
+      }
+      B.push(reduceRat(-sNum, sDen * BigInt(m + 1)));
+    }
+    return B[n];
+  }
   function sumSquareDigits(k) {
     return k.toString().split("").map((d) => BigInt(d)).reduce((sum, d) => sum + d * d, 0n);
   }
@@ -84392,14 +85383,14 @@ ${code}`;
   _setDefaultEngineFactory(() => new ComputeEngine());
 
   // src/compute-engine.ts
-  var version = "0.63.0";
+  var version = "0.64.0";
   ComputeEngine._latexSyntaxFactory = () => new LatexSyntax();
   _setDefaultEngineFactory(
     () => new ComputeEngine({ latexSyntax: new LatexSyntax() })
   );
   globalThis[/* @__PURE__ */ Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.63.0"
+    version: "0.64.0"
   };
   return __toCommonJS(compute_engine_exports);
 })();