@cortex-js/compute-engine 0.52.0 → 0.52.1

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.52.0 */
+/** Compute Engine 0.52.1 */
 
 // node_modules/complex-esm/dist/src/complex.js
 var cosh = Math.cosh || function(x) {
@@ -8131,6 +8131,58 @@ function splitGraphemes(string) {
 }
 
 // src/compute-engine/latex-syntax/tokenizer.ts
+var UNICODE_SUPERSCRIPT_MAP = {
+  "\u2070": "0",
+  // ⁰
+  "\xB9": "1",
+  // ¹
+  "\xB2": "2",
+  // ²
+  "\xB3": "3",
+  // ³
+  "\u2074": "4",
+  // ⁴
+  "\u2075": "5",
+  // ⁵
+  "\u2076": "6",
+  // ⁶
+  "\u2077": "7",
+  // ⁷
+  "\u2078": "8",
+  // ⁸
+  "\u2079": "9",
+  // ⁹
+  "\u207B": "-",
+  // ⁻
+  "\u2071": "i",
+  // ⁱ
+  "\u207F": "n"
+  // ⁿ
+};
+var UNICODE_SUBSCRIPT_MAP = {
+  "\u2080": "0",
+  // ₀
+  "\u2081": "1",
+  // ₁
+  "\u2082": "2",
+  // ₂
+  "\u2083": "3",
+  // ₃
+  "\u2084": "4",
+  // ₄
+  "\u2085": "5",
+  // ₅
+  "\u2086": "6",
+  // ₆
+  "\u2087": "7",
+  // ₇
+  "\u2088": "8",
+  // ₈
+  "\u2089": "9",
+  // ₉
+  "\u208B": "-"
+  // ₋
+};
 var Tokenizer = class {
   s;
   pos;
@@ -8138,6 +8190,14 @@ var Tokenizer = class {
   constructor(s) {
     s = s.replace(/[\u200E\u200F\u2066-\u2069\u202A-\u202E]/g, "");
     s = s.replace(/\u2212/g, "-");
+    s = s.replace(/[⁰¹²³⁴⁵⁶⁷⁸⁹⁻ⁱⁿ]+/g, (m) => {
+      const digits = Array.from(m).map((c) => UNICODE_SUPERSCRIPT_MAP[c]).join("");
+      return `^{${digits}}`;
+    });
+    s = s.replace(/[₀₁₂₃₄₅₆₇₈₉₋]+/g, (m) => {
+      const digits = Array.from(m).map((c) => UNICODE_SUBSCRIPT_MAP[c]).join("");
+      return `_{${digits}}`;
+    });
     this.s = splitGraphemes(s);
     this.pos = 0;
   }
@@ -9335,6 +9395,7 @@ function parseSequence(parser, terminator, lhs, prec, sep) {
       result.push("Nothing");
       parser.skipSpace();
     }
+    parser.skipVisualSpace();
     if (parser.atTerminator(terminator)) {
       result.push("Nothing");
     } else {
@@ -9345,6 +9406,7 @@ function parseSequence(parser, terminator, lhs, prec, sep) {
     if (!done) {
       parser.skipSpace();
       done = !parser.match(sep);
+      if (!done) parser.skipVisualSpace();
     }
   }
   return result;
@@ -9914,7 +9976,7 @@ var DEFINITIONS_CORE = [
       const args = operands(expr);
       if (!args || args.length === 0) return "";
       const parts = args.filter((a) => operator(a) !== "Declare").map((a) => serializer.serialize(a));
-      return parts.join(";\\; ");
+      return parts.join("; ");
     }
   },
   // Serializer for If expressions (separate from the parser entry
@@ -10701,6 +10763,7 @@ var DELIMITERS_SHORTHAND = {
   // '⎿': '', // U+23BF RIGHT PARENTHESIS LOWER HOOK
 };
 function parseAssign(parser, lhs, until) {
+  const isLocalBindingContext = (until?.minPrec ?? 0) >= 19;
   const lhsSymbol = symbol(lhs);
   if (lhsSymbol && lhsSymbol.includes("_")) {
     const underscoreIndex = lhsSymbol.indexOf("_");
@@ -10708,7 +10771,10 @@ function parseAssign(parser, lhs, until) {
     const subscriptStr = lhsSymbol.substring(underscoreIndex + 1);
     const subscriptNum = parseInt(subscriptStr, 10);
     const subscript = !isNaN(subscriptNum) && String(subscriptNum) === subscriptStr ? subscriptNum : subscriptStr;
-    lhs = ["Subscript", baseName, subscript];
+    const simpleSequenceLikeSubscript = subscript !== "" && (typeof subscript === "number" || typeof subscript === "string" && subscript.length === 1);
+    if (parser.getSymbolType(baseName).matches("indexed_collection") || !isLocalBindingContext && simpleSequenceLikeSubscript) {
+      lhs = ["Subscript", baseName, subscript];
+    }
   }
   if (operator(lhs) === "InvisibleOperator" && nops(lhs) === 2 && operator(operand(lhs, 2)) === "Delimiter") {
     const fn2 = symbol(operand(lhs, 1));
@@ -10723,7 +10789,15 @@ function parseAssign(parser, lhs, until) {
   }
   if (operator(lhs) === "Subscript" && symbol(operand(lhs, 1))) {
     const fn2 = symbol(operand(lhs, 1));
-    if (!fn2) return null;
+    if (!parser.getSymbolType(fn2).matches("indexed_collection")) {
+      const sub4 = operand(lhs, 2);
+      const subStr = (sub4 !== null && typeof sub4 === "string" ? sub4 : void 0) ?? (sub4 !== null && typeof sub4 === "number" ? String(sub4) : void 0);
+      if (subStr && isLocalBindingContext) {
+        const rhs3 = parser.parseExpression({ ...until ?? {}, minPrec: 20 });
+        if (rhs3 === null) return null;
+        return ["Assign", fn2 + "_" + subStr, rhs3];
+      }
+    }
     const rhs2 = parser.parseExpression({ ...until ?? {}, minPrec: 20 });
     if (rhs2 === null) return null;
     const sub3 = operand(lhs, 2);
@@ -10804,6 +10878,7 @@ function matchTextKeyword(parser, keyword) {
 }
 function matchKeyword(parser, keyword) {
   const start = parser.index;
+  parser.skipVisualSpace();
   if (parser.match("\\text")) {
     if (matchTextKeyword(parser, keyword)) return true;
     parser.index = start;
@@ -10821,18 +10896,21 @@ function peekKeyword(parser, keyword) {
   return result;
 }
 function parseIfExpression(parser, until) {
+  parser.skipVisualSpace();
   const condition = parser.parseExpression({
     minPrec: 0,
     condition: (p) => peekKeyword(p, "then")
   });
   if (condition === null) return null;
   if (!matchKeyword(parser, "then")) return null;
+  parser.skipVisualSpace();
   const trueBranch = parser.parseExpression({
     minPrec: 0,
     condition: (p) => peekKeyword(p, "else")
   });
   if (trueBranch === null) return null;
   if (!matchKeyword(parser, "else")) return null;
+  parser.skipVisualSpace();
   const falseBranch = parser.parseExpression(until) ?? "Nothing";
   return ["If", condition, trueBranch, falseBranch];
 }
@@ -10887,11 +10965,12 @@ function parseWhereExpression(parser, lhs, until) {
   if (bindings.length === 0) return null;
   const block = [];
   for (const b of bindings) {
-    if (operator(b) === "Assign") {
-      block.push(["Declare", operand(b, 1)]);
-      block.push(b);
+    const normalized = normalizeLocalAssign(b);
+    if (operator(normalized) === "Assign") {
+      block.push(["Declare", operand(normalized, 1)]);
+      block.push(normalized);
     } else {
-      block.push(b);
+      block.push(normalized);
     }
   }
   block.push(lhs);
@@ -10900,13 +10979,25 @@ function parseWhereExpression(parser, lhs, until) {
 function buildBlockFromSequence(seq) {
   const block = [];
   for (const s of seq) {
-    if (operator(s) === "Assign") {
-      block.push(["Declare", operand(s, 1)]);
+    const normalized = normalizeLocalAssign(s);
+    if (operator(normalized) === "Assign") {
+      block.push(["Declare", operand(normalized, 1)]);
     }
-    block.push(s);
+    block.push(normalized);
   }
   return ["Block", ...block];
 }
+function normalizeLocalAssign(expr) {
+  if (operator(expr) !== "Assign") return expr;
+  const lhs = operand(expr, 1);
+  if (operator(lhs) !== "Subscript") return expr;
+  const base = symbol(operand(lhs, 1));
+  if (!base) return expr;
+  const sub3 = operand(lhs, 2);
+  const subStr = (typeof sub3 === "string" ? sub3 : void 0) ?? (typeof sub3 === "number" ? String(sub3) : void 0);
+  if (!subStr) return expr;
+  return ["Assign", `${base}_${subStr}`, operand(expr, 2) ?? "Nothing"];
+}
 function parseAt(...close) {
   return (parser, lhs) => {
     if (!symbol(lhs) && operator(lhs) !== "List") return null;
@@ -12363,14 +12454,14 @@ var _BoxedExpression = class __BoxedExpression {
   get numeratorDenominator() {
     return [this, this.engine.One];
   }
-  is(other) {
+  is(other, tolerance) {
     if (this.isSame(other)) return true;
-    if (!this.isConstant) return false;
+    if (this.freeVariables.length > 0) return false;
     if (typeof other === "number" || typeof other === "bigint") {
       const n = this.N();
       if (n === this) return false;
       if (!isNumber(n)) return false;
-      const tol = this.engine.tolerance;
+      const tol = tolerance ?? this.engine.tolerance;
       const nRe = n.re;
       const nIm = n.im;
       if (typeof other === "number") {
@@ -12381,11 +12472,11 @@ var _BoxedExpression = class __BoxedExpression {
       return Math.abs(nRe - Number(other)) <= tol && Math.abs(nIm) <= tol;
     }
     if (other instanceof __BoxedExpression) {
-      if (!other.isConstant) return false;
+      if (other.freeVariables.length > 0) return false;
       const nThis = this.N();
       const nOther = other.N();
       if (!isNumber(nThis) || !isNumber(nOther)) return false;
-      const tol = this.engine.tolerance;
+      const tol = tolerance ?? this.engine.tolerance;
       return Math.abs(nThis.re - nOther.re) <= tol && Math.abs(nThis.im - nOther.im) <= tol;
     }
     return false;
@@ -12766,7 +12857,6 @@ var _BoxedValueDefinition = class {
     if (def.neq) this.neq = def.neq;
     if (def.cmp) this.cmp = def.cmp;
     if (def.collection) {
-      if (name === "Take") debugger;
       this.collection = defaultCollectionHandlers(def.collection);
     }
     if (def.subscriptEvaluate) this.subscriptEvaluate = def.subscriptEvaluate;
@@ -12946,7 +13036,8 @@ function getImaginaryFactor(expr) {
   if (expr.re === 0) return ce.number(expr.im);
   if (isFunction2(expr, "Negate")) return getImaginaryFactor(expr.op1)?.neg();
   if (isFunction2(expr, "Complex")) {
-    if (expr.op1.isSame(0) && !isNaN(expr.op2.re)) return ce.number(expr.op2.re);
+    if (expr.op1.isSame(0) && !isNaN(expr.op2.re))
+      return ce.number(expr.op2.re);
     return void 0;
   }
   if (isFunction2(expr, "Multiply") && expr.nops === 2) {
@@ -23414,6 +23505,7 @@ var ARITHMETIC_LIBRARY = [
     // Functions
     //
     Abs: {
+      description: "Absolute value (magnitude) of a number.",
       wikidata: "Q3317982",
       // magnitude 'Q120812 (for reals)
       broadcastable: true,
@@ -23429,6 +23521,7 @@ var ARITHMETIC_LIBRARY = [
       evaluate: ([x]) => evaluateAbs(x)
     },
     Add: {
+      description: "Sum of two or more values.",
       wikidata: "Q32043",
       associative: true,
       commutative: true,
@@ -23483,6 +23576,7 @@ var ARITHMETIC_LIBRARY = [
       )
     },
     Chop: {
+      description: "Replace tiny numeric values with zero.",
       associative: true,
       broadcastable: true,
       idempotent: true,
@@ -23506,6 +23600,7 @@ var ARITHMETIC_LIBRARY = [
     //   complexity: 500,
     // },
     Divide: {
+      description: "Quotient of a numerator and one or more denominators.",
       wikidata: "Q1226939",
       complexity: 2500,
       broadcastable: true,
@@ -23554,6 +23649,7 @@ var ARITHMETIC_LIBRARY = [
       }
     },
     Exp: {
+      description: "Natural exponential function: e^x.",
       wikidata: "Q168698",
       broadcastable: true,
       complexity: 3500,
@@ -23663,6 +23759,7 @@ var ARITHMETIC_LIBRARY = [
       }
     },
     Floor: {
+      description: "Rounds a number down to the nearest integer.",
       wikidata: "Q56860783",
       complexity: 1250,
       broadcastable: true,
@@ -23702,6 +23799,7 @@ var ARITHMETIC_LIBRARY = [
       )
     },
     Gamma: {
+      description: "Gamma function, extending factorial to complex numbers.",
       wikidata: "Q190573",
       complexity: 8e3,
       broadcastable: true,
@@ -23716,6 +23814,7 @@ var ARITHMETIC_LIBRARY = [
       ) : void 0
     },
     GammaLn: {
+      description: "Natural logarithm of the gamma function.",
       complexity: 8e3,
       broadcastable: true,
       signature: "(number) -> number",
@@ -23987,6 +24086,7 @@ var ARITHMETIC_LIBRARY = [
       )
     },
     Multiply: {
+      description: "Product of two or more values.",
       wikidata: "Q40276",
       associative: true,
       commutative: true,
@@ -24083,6 +24183,7 @@ var ARITHMETIC_LIBRARY = [
       evaluate: ([x, y], { engine }) => engine.tuple(x.add(y.neg()), x.add(y))
     },
     Power: {
+      description: "Exponentiation: raise a base to a power.",
       wikidata: "Q33456",
       broadcastable: true,
       complexity: 3500,
@@ -24141,6 +24242,7 @@ var ARITHMETIC_LIBRARY = [
       // https://proofwiki.org/wiki/Square_Root_of_Prime_is_Irrational
     },
     Rational: {
+      description: "Construct a rational number from a numerator and denominator.",
       complexity: 2400,
       signature: "(number, integer?) -> rational",
       sgn: ([n]) => n.sgn,
@@ -24177,6 +24279,7 @@ var ARITHMETIC_LIBRARY = [
       }
     },
     Root: {
+      description: "n-th root of a value.",
       complexity: 3200,
       broadcastable: true,
       signature: "(number, number) -> number",
@@ -24237,6 +24340,7 @@ var ARITHMETIC_LIBRARY = [
       )
     },
     Round: {
+      description: "Rounds a number to the nearest integer.",
       complexity: 1250,
       broadcastable: true,
       signature: "(number) -> integer",
@@ -24266,6 +24370,7 @@ var ARITHMETIC_LIBRARY = [
     },
     /** Heaviside step function: H(x) = 0 for x < 0, 1/2 for x = 0, 1 for x > 0 */
     Heaviside: {
+      description: "Heaviside step function.",
       complexity: 1200,
       broadcastable: true,
       signature: "(number) -> real",
@@ -24279,6 +24384,7 @@ var ARITHMETIC_LIBRARY = [
       }
     },
     Sign: {
+      description: "Sign of a number: -1, 0, or 1.",
       complexity: 1200,
       broadcastable: true,
       signature: "(number) -> integer",
@@ -24350,6 +24456,7 @@ var ARITHMETIC_LIBRARY = [
       // https://proofwiki.org/wiki/Square_Root_of_Prime_is_Irrational
     },
     Square: {
+      description: "Square of a number: x^2.",
       wikidata: "Q3075175",
       complexity: 3100,
       broadcastable: true,
@@ -24372,6 +24479,7 @@ var ARITHMETIC_LIBRARY = [
       }
     },
     Subtract: {
+      description: "Difference between two or more values.",
       wikidata: "Q40754",
       complexity: 1350,
       broadcastable: true,
@@ -24546,9 +24654,11 @@ var ARITHMETIC_LIBRARY = [
   },
   {
     PreIncrement: {
+      description: "Increment a number by one.",
       signature: "(number) -> number"
     },
     PreDecrement: {
+      description: "Decrement a number by one.",
       signature: "(number) -> number"
     }
   },
@@ -29090,6 +29200,7 @@ var CALCULUS_LIBRARY = [
     // with values of the order that can be either fractional or negative
     //
     Derivative: {
+      description: "Derivative operator that returns a derivative function.",
       broadcastable: false,
       lazy: true,
       signature: "(function, order:number?) -> function",
@@ -29117,6 +29228,7 @@ var CALCULUS_LIBRARY = [
     //
     // This is equivalent to `["Apply", ["Derivative", "Sin"], "x"]`
     D: {
+      description: "Symbolic partial derivative with respect to one or more variables.",
       broadcastable: false,
       scoped: true,
       lazy: true,
@@ -29161,6 +29273,7 @@ var CALCULUS_LIBRARY = [
     },
     // Evaluate a numerical approximation of a derivative at point x
     ND: {
+      description: "Numerical derivative evaluated at a point.",
       broadcastable: false,
       lazy: true,
       signature: "(function, at:number) -> number",
@@ -29179,6 +29292,7 @@ var CALCULUS_LIBRARY = [
       }
     },
     Integrate: {
+      description: "Symbolic integral with optional bounds.",
       wikidata: "Q80091",
       broadcastable: false,
       lazy: true,
@@ -29259,6 +29373,7 @@ var CALCULUS_LIBRARY = [
       }
     },
     NIntegrate: {
+      description: "Numerical approximation of a definite integral.",
       broadcastable: false,
       lazy: true,
       signature: "(function, limits:(tuple|symbol)?) -> number",
@@ -33103,6 +33218,7 @@ var COLORS_LIBRARY = {
 var CONTROL_STRUCTURES_LIBRARY = [
   {
     Block: {
+      description: "Evaluate a sequence of expressions in a local scope.",
       lazy: true,
       scoped: true,
       signature: "(unknown*) -> unknown",
@@ -33116,6 +33232,7 @@ var CONTROL_STRUCTURES_LIBRARY = [
     // A condition expression tests for one or more conditions of an expression
     // ['Condition', value, "positive"]
     Condition: {
+      description: "Test whether a value satisfies one or more conditions.",
       lazy: true,
       signature: "(value, symbol) -> boolean",
       evaluate: ([value, conds], { engine }) => {
@@ -33130,6 +33247,7 @@ var CONTROL_STRUCTURES_LIBRARY = [
       }
     },
     If: {
+      description: "Conditional branch: evaluate one of two expressions.",
       lazy: true,
       signature: "(expression, expression, expression) -> any",
       type: ([_cond, ifTrue, ifFalse]) => widen(ifTrue.type.type, ifFalse.type.type),
@@ -33146,6 +33264,7 @@ var CONTROL_STRUCTURES_LIBRARY = [
       }
     },
     Loop: {
+      description: "Evaluate a body expression over elements of a collection.",
       lazy: true,
       signature: "(body:expression, collection:expression) -> any",
       type: ([body]) => body.type,
@@ -33153,6 +33272,7 @@ var CONTROL_STRUCTURES_LIBRARY = [
       evaluateAsync: async ([body, collection], { engine: ce, signal }) => runAsync(runLoop(body, collection, ce), ce._timeRemaining, signal)
     },
     Which: {
+      description: "Return the value for the first condition that is true.",
       lazy: true,
       signature: "(expression+) -> unknown",
       type: (args) => {
@@ -33170,7 +33290,11 @@ var CONTROL_STRUCTURES_LIBRARY = [
       },
       evaluate: (ops, options) => evaluateWhich(ops, options)
     },
-    FixedPoint: { lazy: true, signature: "(any) -> unknown" }
+    FixedPoint: {
+      description: "Iterate a function until a fixed point is reached.",
+      lazy: true,
+      signature: "(any) -> unknown"
+    }
   }
 ];
 function evaluateWhich(args, options) {
@@ -33250,6 +33374,7 @@ function* runLoop(body, collection, ce) {
 var COMBINATORICS_LIBRARY = [
   {
     Choose: {
+      description: "Binomial coefficient: number of ways to choose k items from n.",
       complexity: 1200,
       signature: "(n:number, m:number) -> number",
       type: () => "finite_integer",
@@ -33507,6 +33632,7 @@ function binomial(n, k) {
 var COMPLEX_LIBRARY = [
   {
     Real: {
+      description: "Real part of a complex number.",
       // @todo: could be extended to return an expression, i.e. ["Real", ["Add", "x", ["Complex", 0, 5]]] -> "x". Not for any operator, but at least for Add, Multiply, Negate, etc.
       broadcastable: true,
       complexity: 1200,
@@ -33526,6 +33652,7 @@ var COMPLEX_LIBRARY = [
       }
     },
     Imaginary: {
+      description: "Imaginary part of a complex number.",
       broadcastable: true,
       complexity: 1200,
       signature: "(number) -> real",
@@ -33544,6 +33671,7 @@ var COMPLEX_LIBRARY = [
       }
     },
     Argument: {
+      description: "Complex argument (phase angle) of a number.",
       broadcastable: true,
       complexity: 1200,
       signature: "(number) -> real",
@@ -33558,6 +33686,7 @@ var COMPLEX_LIBRARY = [
     },
     // For Abs (magnitude) see src/compute-engine/library/processAbs
     AbsArg: {
+      description: "Tuple of magnitude and argument of a complex number.",
       broadcastable: true,
       complexity: 1200,
       signature: "(number) -> tuple<real, real>",
@@ -33570,6 +33699,7 @@ var COMPLEX_LIBRARY = [
       }
     },
     Conjugate: {
+      description: "Complex conjugate of a number.",
       broadcastable: true,
       complexity: 1200,
       signature: "(number) -> number",
@@ -33583,6 +33713,7 @@ var COMPLEX_LIBRARY = [
       }
     },
     ComplexRoots: {
+      description: "All n-th complex roots of a number.",
       broadcastable: true,
       complexity: 1200,
       signature: "(number, number) -> list<number>",
@@ -34534,6 +34665,7 @@ var CORE_LIBRARY = [
      *
      */
     InvisibleOperator: {
+      description: "Implicit operator used for juxtapositions such as function application or multiplication.",
       complexity: 9e3,
       lazy: true,
       signature: "function",
@@ -34548,6 +34680,7 @@ var CORE_LIBRARY = [
     },
     /** See above for a theory of operations */
     Sequence: {
+      description: "Ordered sequence of expressions.",
       lazy: true,
       signature: "function",
       type: (args) => {
@@ -34564,6 +34697,7 @@ var CORE_LIBRARY = [
     },
     /** See above for a theory of operations */
     Delimiter: {
+      description: "Group expressions with explicit delimiters.",
       // Use to represent groups of expressions.
       // Named after https://en.wikipedia.org/wiki/Delimiter
       complexity: 9e3,
@@ -34606,6 +34740,7 @@ var CORE_LIBRARY = [
       }
     },
     Error: {
+      description: "Represent an error expression.",
       /**
        * - The first argument is either a string or an `["ErrorCode"]`
        * expression indicating the nature of the error.
@@ -34620,6 +34755,7 @@ var CORE_LIBRARY = [
       canonical: (args, { engine: ce }) => ce._fn("Error", args)
     },
     ErrorCode: {
+      description: "Structured error code with optional arguments.",
       complexity: 500,
       lazy: true,
       signature: "(string, any*) -> error",
@@ -34676,6 +34812,7 @@ var CORE_LIBRARY = [
       }
     },
     HorizontalSpacing: {
+      description: "Horizontal spacing annotation.",
       signature: "(number) -> nothing",
       canonical: (args, { engine: ce }) => {
         if (args.length === 2) return args[0].canonical;
@@ -34683,6 +34820,7 @@ var CORE_LIBRARY = [
       }
     },
     Annotated: {
+      description: "Attach metadata or style annotations to an expression.",
       signature: "(expression, dictionary) -> expression",
       type: ([x]) => x.type,
       complexity: 9e3,
@@ -34884,6 +35022,7 @@ var CORE_LIBRARY = [
       evaluate: (ops, { engine: ce }) => ce.symbol(ce.assume(ops[0]))
     },
     Declare: {
+      description: "Declare a symbol and optionally assign a type.",
       lazy: true,
       pure: false,
       signature: "(symbol, type: string | symbol) -> nothing",
@@ -34914,11 +35053,13 @@ var CORE_LIBRARY = [
     },
     /** Return the type of an expression */
     Type: {
+      description: "Return the type of an expression as a string.",
       lazy: true,
       signature: "(any) -> string",
       evaluate: ([x], { engine: ce }) => ce.string(x.type.toString() ?? "unknown")
     },
     Evaluate: {
+      description: "Evaluate an expression.",
       lazy: true,
       signature: "(any) -> unknown",
       type: ([x]) => x.type,
@@ -34928,6 +35069,7 @@ var CORE_LIBRARY = [
     // Evaluate an expression at a specific point, potentially symbolically
     // i.e. it's the `f|_{a}` notation
     EvaluateAt: {
+      description: "Evaluate a function at one point or between two bounds.",
       lazy: true,
       signature: "(function, lower:number, upper:number) -> number",
       type: ([x]) => functionResult(x.type.type) ?? "number",
@@ -34955,6 +35097,7 @@ var CORE_LIBRARY = [
       }
     },
     BuiltinFunction: {
+      description: "Return a built-in function symbol by name.",
       complexity: 9876,
       lazy: true,
       signature: "(symbol | string) -> symbol",
@@ -34974,6 +35117,7 @@ var CORE_LIBRARY = [
       }
     },
     Rule: {
+      description: "Pattern replacement rule.",
       lazy: true,
       signature: "(match: expression, replace: expression, predicate: function?) -> expression",
       evaluate: ([_match, _replace, _predicate], { engine: _ce }) => {
@@ -34981,6 +35125,7 @@ var CORE_LIBRARY = [
       }
     },
     Simplify: {
+      description: "Simplify an expression.",
       lazy: true,
       signature: "(any) -> expression",
       canonical: (ops, { engine: ce }) => ce._fn("Simplify", checkArity(ce, ops, 1)),
@@ -35049,6 +35194,7 @@ var CORE_LIBRARY = [
     },
     // @todo: need review
     Signature: {
+      description: "Return the signature string of an operator.",
       lazy: true,
       signature: "(symbol) -> string | nothing",
       evaluate: ([x], { engine: ce }) => {
@@ -35057,6 +35203,7 @@ var CORE_LIBRARY = [
       }
     },
     Subscript: {
+      description: "Subscript notation for indexing or compound symbols.",
       /**
        * The `Subscript` function can take several forms:
        *
@@ -35227,6 +35374,7 @@ var CORE_LIBRARY = [
   //
   {
     Wildcard: {
+      description: "Single-expression pattern wildcard.",
       signature: "(symbol) -> symbol",
       canonical: (args, { engine: ce }) => {
         if (args.length !== 1) return ce.symbol("_");
@@ -35234,6 +35382,7 @@ var CORE_LIBRARY = [
       }
     },
     WildcardSequence: {
+      description: "Pattern wildcard matching one or more expressions.",
       signature: "(symbol) -> symbol",
       canonical: (args, { engine: ce }) => {
         if (args.length !== 1) return ce.symbol("__");
@@ -35241,6 +35390,7 @@ var CORE_LIBRARY = [
       }
     },
     WildcardOptionalSequence: {
+      description: "Pattern wildcard matching zero or more expressions.",
       signature: "(symbol) -> symbol",
       canonical: (args, { engine: ce }) => {
         if (args.length !== 1) return ce.symbol("___");
@@ -35461,6 +35611,7 @@ var CORE_LIBRARY = [
   },
   {
     RandomExpression: {
+      description: "Generate a random expression.",
       signature: "() -> expression",
       evaluate: (_ops, { engine }) => engine.box(randomExpression())
     }
@@ -35471,6 +35622,7 @@ var CORE_LIBRARY = [
 var LINEAR_ALGEBRA_LIBRARY = [
   {
     Matrix: {
+      description: "Matrix constructor and canonicalizer.",
       complexity: 9e3,
       lazy: true,
       signature: "(matrix, string?, string?) -> matrix",
@@ -35481,6 +35633,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     // Vector is a specialized collection to represent a column vector.
     // ["Vector", a, b, c] is a shorthand for ["List", ["List", a], ["List", b], ["List", c]]
     Vector: {
+      description: "Construct a column vector.",
       complexity: 9e3,
       lazy: true,
       signature: "(number+) -> vector",
@@ -35501,6 +35654,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
   {
     // Corresponds to monadic Shape `⍴` in APL
     Shape: {
+      description: "Return the shape tuple of an expression.",
       complexity: 8200,
       signature: "(value) -> tuple",
       evaluate: ([xs], { engine: ce }) => ce.tuple(...xs.shape)
@@ -35515,6 +35669,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     // Corresponds to ArrayReshape in Mathematica
     // and dyadic Shape `⍴` in APL
     Reshape: {
+      description: "Reshape a tensor or collection to a target shape.",
       complexity: 8200,
       signature: "(value, tuple) -> value",
       type: ([value, shape]) => {
@@ -35559,6 +35714,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     // Corresponds to Ravel `,` in APL
     // Also Enlist `∊``⍋` in APL
     Flatten: {
+      description: "Flatten a tensor or collection into a list.",
       complexity: 8200,
       signature: "(value) -> list",
       evaluate: (ops, { engine: ce }) => {
@@ -35578,6 +35734,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     // Ex: Transpose([[a, b, c], [1, 2, 3]]) = [[a, 1], [b, 2], [c, 3]]
     // For rank > 2: Default swaps last two axes, or specify explicit axes
     Transpose: {
+      description: "Transpose a matrix or swap two tensor axes.",
       complexity: 8200,
       signature: "(value, axis1: integer?, axis2: integer?) -> value",
       evaluate: (ops, { engine: ce }) => {
@@ -35606,6 +35763,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     // Conjugate transpose (Hermitian adjoint): transpose + complex conjugate
     // For rank > 2: Default swaps last two axes, or specify explicit axes
     ConjugateTranspose: {
+      description: "Conjugate transpose (Hermitian adjoint) of a matrix or tensor.",
       complexity: 8200,
       signature: "(value, axis1: integer?, axis2: integer?) -> value",
       evaluate: (ops, { engine: ce }) => {
@@ -35635,6 +35793,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
       }
     },
     Determinant: {
+      description: "Determinant of a square matrix.",
       complexity: 8200,
       signature: "(matrix) -> number",
       evaluate: (ops, { engine: ce }) => {
@@ -35654,6 +35813,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
       }
     },
     Inverse: {
+      description: "Multiplicative inverse of a square matrix.",
       complexity: 8200,
       signature: "(matrix) -> matrix",
       type: ([matrix]) => matrix.type,
@@ -35674,6 +35834,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
       }
     },
     PseudoInverse: {
+      description: "Moore-Penrose pseudoinverse of a matrix.",
       complexity: 8200,
       signature: "(matrix) -> matrix",
       evaluate: ([matrix], { engine: ce }) => {
@@ -35698,6 +35859,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     //   },
     // },
     AdjugateMatrix: {
+      description: "Adjugate (classical adjoint) of a square matrix.",
       complexity: 8200,
       signature: "(matrix) -> matrix",
       evaluate: (ops) => {
@@ -35722,6 +35884,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     // For rank > 2 tensors: returns tensor of traces over last two axes (batch trace)
     // Optional axis1, axis2 to specify which axes to trace over (default: last two)
     Trace: {
+      description: "Trace of a matrix or pair of tensor axes.",
       complexity: 8200,
       signature: "(value, axis1: integer?, axis2: integer?) -> value",
       evaluate: (ops, { engine: ce }) => {
@@ -35830,6 +35993,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     // Matrix multiplication: A (m×n) × B (n×p) → result (m×p)
     // Handles matrix × matrix, matrix × vector, vector × matrix
     MatrixMultiply: {
+      description: "Matrix and vector multiplication.",
       complexity: 8300,
       signature: "(matrix|vector, matrix|vector) -> matrix|vector",
       evaluate: (ops, { engine: ce }) => {
@@ -35915,6 +36079,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     // 2. Extract the diagonal from a matrix as a vector
     // 3. For a scalar, return the scalar (or could create 1x1 matrix)
     Diagonal: {
+      description: "Extract a matrix diagonal or build a diagonal matrix.",
       complexity: 8200,
       signature: "(value) -> value",
       evaluate: (ops, { engine: ce }) => {
@@ -35951,6 +36116,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     },
     // Creates an n×n identity matrix
     IdentityMatrix: {
+      description: "n-by-n identity matrix.",
       complexity: 8100,
       signature: "(integer) -> matrix",
       evaluate: (ops, { engine: ce }) => {
@@ -35971,6 +36137,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     },
     // Creates an m×n matrix of zeros
     ZeroMatrix: {
+      description: "Matrix filled with zeros.",
       complexity: 8100,
       signature: "(integer, integer?) -> matrix",
       evaluate: (ops, { engine: ce }) => {
@@ -35998,6 +36165,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     },
     // Creates an m×n matrix of ones
     OnesMatrix: {
+      description: "Matrix filled with ones.",
       complexity: 8100,
       signature: "(integer, integer?) -> matrix",
       evaluate: (ops, { engine: ce }) => {
@@ -36032,6 +36200,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     // For matrices:
     //   - Frobenius (default): √(ΣΣ|aij|²)
     Norm: {
+      description: "Vector or matrix norm.",
       complexity: 8200,
       signature: "(value, number|string?) -> number",
       evaluate: (ops, { engine: ce }) => {
@@ -36153,6 +36322,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     // For 2×2 matrices: uses characteristic polynomial (symbolic)
     // For larger matrices: uses QR algorithm (numeric)
     Eigenvalues: {
+      description: "Eigenvalues of a square matrix.",
       complexity: 8500,
       signature: "(matrix) -> list",
       evaluate: (ops, { engine: ce }) => {
@@ -36198,6 +36368,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     // Compute the eigenvectors of a square matrix
     // Returns a list of eigenvectors (as column vectors)
     Eigenvectors: {
+      description: "Eigenvectors of a square matrix.",
       complexity: 8600,
       signature: "(matrix) -> list",
       evaluate: (ops, { engine: ce }) => {
@@ -36228,6 +36399,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     // Compute both eigenvalues and eigenvectors
     // Returns a tuple: [eigenvalues, eigenvectors]
     Eigen: {
+      description: "Eigenvalue-eigenvector decomposition of a square matrix.",
       complexity: 8700,
       signature: "(matrix) -> tuple",
       evaluate: (ops, { engine: ce }) => {
@@ -36247,6 +36419,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     // LU Decomposition: A = LU (or PA = LU with pivoting)
     // Returns [L, U] for no pivoting or [P, L, U] with pivoting
     LUDecomposition: {
+      description: "LU decomposition of a square matrix.",
       complexity: 8600,
       signature: "(matrix) -> tuple",
       evaluate: (ops, { engine: ce }) => {
@@ -36266,6 +36439,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     // QR Decomposition: A = QR
     // Returns [Q, R] where Q is orthogonal and R is upper triangular
     QRDecomposition: {
+      description: "QR decomposition of a matrix.",
       complexity: 8600,
       signature: "(matrix) -> tuple",
       evaluate: (ops, { engine: ce }) => {
@@ -36285,6 +36459,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     // Cholesky Decomposition: A = LL^T (for positive definite matrices)
     // Returns L (lower triangular matrix)
     CholeskyDecomposition: {
+      description: "Cholesky decomposition of a positive-definite matrix.",
       complexity: 8600,
       signature: "(matrix) -> matrix",
       evaluate: (ops, { engine: ce }) => {
@@ -36301,6 +36476,7 @@ var LINEAR_ALGEBRA_LIBRARY = [
     // Singular Value Decomposition: A = UΣV^T
     // Returns [U, Σ, V] where U and V are orthogonal, Σ is diagonal
     SVD: {
+      description: "Singular value decomposition of a matrix.",
       complexity: 8700,
       signature: "(matrix) -> tuple",
       evaluate: (ops, { engine: ce }) => {
@@ -39758,6 +39934,7 @@ function bigInterquartileRange(values) {
 var STATISTICS_LIBRARY = [
   {
     Erf: {
+      description: "Gauss error function",
       complexity: 7500,
       signature: "(number) -> number",
       type: () => "finite_real",
@@ -39768,6 +39945,7 @@ var STATISTICS_LIBRARY = [
       }
     },
     Erfc: {
+      description: "Complementary error function: 1 - Erf(x)",
       complexity: 7500,
       signature: "(number) -> number",
       type: () => "finite_real",
@@ -39778,6 +39956,7 @@ var STATISTICS_LIBRARY = [
       }
     },
     ErfInv: {
+      description: "Inverse of the error function",
       complexity: 7500,
       signature: "(number) -> number",
       type: () => "finite_real",
@@ -39796,7 +39975,7 @@ var STATISTICS_LIBRARY = [
       broadcastable: false,
       signature: "((collection|number)+) -> number",
       type: () => "finite_real",
-      description: "The most frequently occurring value in the collection.",
+      description: "Arithmetic mean of a collection of numbers.",
       evaluate: (ops, { engine, numericApproximation: numericApproximation2 }) => {
         const xs = ops.map((x) => x.evaluate({ numericApproximation: numericApproximation2 }));
         return engine.number(
@@ -39809,7 +39988,7 @@ var STATISTICS_LIBRARY = [
       broadcastable: false,
       signature: "((collection|number)+) -> number",
       type: () => "finite_real",
-      description: "The most frequently occurring value in the collection.",
+      description: "Median of a collection of numbers.",
       examples: ["Mode([1, 2, 2, 3])  // Returns 2"],
       evaluate: (ops, { engine, numericApproximation: numericApproximation2 }) => {
         const xs = ops.map((x) => x.evaluate({ numericApproximation: numericApproximation2 }));
@@ -39819,6 +39998,7 @@ var STATISTICS_LIBRARY = [
       }
     },
     Variance: {
+      description: "Sample variance of a collection of numbers.",
       complexity: 1200,
       broadcastable: false,
       signature: "((collection|number)+) -> number",
@@ -39831,6 +40011,7 @@ var STATISTICS_LIBRARY = [
       }
     },
     PopulationVariance: {
+      description: "Population variance of a collection of numbers.",
       complexity: 1200,
       broadcastable: false,
       signature: "((collection|number)+) -> number",
@@ -39878,6 +40059,7 @@ var STATISTICS_LIBRARY = [
       }
     },
     Kurtosis: {
+      description: "Kurtosis of a collection of numbers.",
       complexity: 1200,
       broadcastable: false,
       signature: "((collection|number)+) -> number",
@@ -39890,6 +40072,7 @@ var STATISTICS_LIBRARY = [
       }
     },
     Skewness: {
+      description: "Skewness of a collection of numbers.",
       complexity: 1200,
       broadcastable: false,
       signature: "((collection|number)+) -> number",
@@ -39902,6 +40085,7 @@ var STATISTICS_LIBRARY = [
       }
     },
     Mode: {
+      description: "Most frequently occurring value in a collection.",
       complexity: 1200,
       broadcastable: false,
       signature: "((collection|number)+) -> number",
@@ -39914,6 +40098,7 @@ var STATISTICS_LIBRARY = [
       }
     },
     Quartiles: {
+      description: "Lower quartile, median, and upper quartile of a collection.",
       complexity: 1200,
       broadcastable: false,
       signature: "((collection|number)+) -> tuple<mid:number, lower:number, upper:number>",
@@ -39925,6 +40110,7 @@ var STATISTICS_LIBRARY = [
       }
     },
     InterquartileRange: {
+      description: "Interquartile range (Q3 - Q1) of a collection.",
       complexity: 1200,
       broadcastable: false,
       signature: "((collection|number)+) -> number",
@@ -40679,6 +40865,7 @@ var TRIGONOMETRY_LIBRARY = [
   },
   {
     Degrees: {
+      description: "Convert an angle in degrees.",
       /* = Pi / 180 */
       signature: "(real) -> real",
       type: () => "finite_real",
@@ -40708,6 +40895,7 @@ var TRIGONOMETRY_LIBRARY = [
     },
     // DMS(degrees, minutes?, seconds?) — programmatic angle construction
     DMS: {
+      description: "Construct an angle from degrees, minutes, and seconds.",
       signature: "(real, real?, real?) -> real",
       type: () => "finite_real",
       canonical: (ops, { engine: ce }) => {
@@ -40731,6 +40919,7 @@ var TRIGONOMETRY_LIBRARY = [
     },
     // Hypot: sqrt(x*x + y*y)
     Hypot: {
+      description: "Hypotenuse length: sqrt(x^2 + y^2).",
       broadcastable: true,
       signature: "(real, real) -> real",
       type: () => "finite_real",
@@ -40747,6 +40936,7 @@ var TRIGONOMETRY_LIBRARY = [
     // (may be used in the definition of other functions below)
     //
     Arctan: {
+      description: "Inverse tangent.",
       wikidata: "Q2257242",
       complexity: 5200,
       broadcastable: true,
@@ -40756,6 +40946,7 @@ var TRIGONOMETRY_LIBRARY = [
       evaluate: ([x], { numericApproximation: numericApproximation2 }) => numericApproximation2 ? evalTrig("Arctan", x) : constructibleValues("Arctan", x) ?? evalTrig("Arctan", x)
     },
     Arctan2: {
+      description: "Two-argument arctangent giving the angle of a vector.",
       wikidata: "Q776598",
       complexity: 5200,
       broadcastable: true,
@@ -40801,6 +40992,7 @@ var TRIGONOMETRY_LIBRARY = [
     Sinh: trigFunction("Sinh", 6e3),
     /** = sin(z/2)^2 = (1 - cos z) / 2*/
     Haversine: {
+      description: "Haversine function.",
       wikidata: "Q2528380",
       broadcastable: true,
       signature: "(real) -> number",
@@ -40809,6 +41001,7 @@ var TRIGONOMETRY_LIBRARY = [
     },
     /** = 2 * Arcsin(Sqrt(z)) */
     InverseHaversine: {
+      description: "Inverse haversine function.",
       //  Range ['Interval', [['Negate', 'Pi'], 'Pi'],
       broadcastable: true,
       signature: "(real) -> real",
@@ -40832,6 +41025,7 @@ var TRIGONOMETRY_LIBRARY = [
     Coth: trigFunction("Coth", 6300),
     /** sinc(x) = sin(x)/x with sinc(0) = 1 (unnormalized cardinal sine) */
     Sinc: {
+      description: "Unnormalized sinc function: sin(x)/x with sinc(0)=1.",
       complexity: 5100,
       broadcastable: true,
       signature: "(number) -> real",
@@ -40843,6 +41037,7 @@ var TRIGONOMETRY_LIBRARY = [
     },
     /** FresnelS(x) = ∫₀ˣ sin(πt²/2) dt — odd function, S(∞) = 1/2 */
     FresnelS: {
+      description: "Fresnel sine integral.",
       complexity: 5200,
       broadcastable: true,
       signature: "(number) -> real",
@@ -40854,6 +41049,7 @@ var TRIGONOMETRY_LIBRARY = [
     },
     /** FresnelC(x) = ∫₀ˣ cos(πt²/2) dt — odd function, C(∞) = 1/2 */
     FresnelC: {
+      description: "Fresnel cosine integral.",
       complexity: 5200,
       broadcastable: true,
       signature: "(number) -> real",
@@ -40869,6 +41065,7 @@ var TRIGONOMETRY_LIBRARY = [
     //   outputDomain: ['TupleOf', 'RealNumbers', 'RealNumbers'],
     // },
     InverseFunction: {
+      description: "Inverse of a function.",
       lazy: true,
       signature: "(function) -> function",
       canonical: (ops, { engine }) => {
@@ -41245,6 +41442,18 @@ function parseRoot(parser) {
   if (degree !== null) return ["Root", base, degree];
   return ["Sqrt", base];
 }
+function negateNumberLiteral(expr) {
+  if (typeof expr === "number") return -expr;
+  if (typeof expr === "string") {
+    if (expr.startsWith("-")) return expr.slice(1);
+    if (expr.startsWith("+")) return "-" + expr.slice(1);
+    return "-" + expr;
+  }
+  const num = expr.num;
+  if (num.startsWith("-")) return { num: num.slice(1) };
+  if (num.startsWith("+")) return { num: "-" + num.slice(1) };
+  return { num: "-" + num };
+}
 function serializeRoot(serializer, style, base, degree) {
   if (base === null || base === void 0) return "\\sqrt{}";
   degree = degree ?? 2;
@@ -41810,6 +42019,11 @@ var DEFINITIONS_ARITHMETIC = [
         minPrec: ADDITION_PRECEDENCE
       });
       if (rhs === null) return null;
+      if (operator(rhs) === "Negate") {
+        const value = operand(rhs, 1);
+        if (isNumberExpression(value))
+          return foldAssociativeOperator("Add", lhs, negateNumberLiteral(value));
+      }
       return foldAssociativeOperator("Add", lhs, rhs);
     },
     serialize: serializeAdd
@@ -42468,13 +42682,12 @@ var DEFINITIONS_ARITHMETIC = [
     associativity: "left",
     precedence: ADDITION_PRECEDENCE + 2,
     parse: (parser, lhs, terminator) => {
-      parser.index -= 1;
       const rhs = parser.parseExpression({
         ...terminator,
         minPrec: ADDITION_PRECEDENCE + 3
       });
       if (rhs === null) return null;
-      return ["Add", lhs, rhs];
+      return ["Subtract", lhs, rhs];
     },
     serialize: (serializer, expr) => {
       const lhs = serializer.wrap(operand(expr, 1), ADDITION_PRECEDENCE + 2);
@@ -47679,7 +47892,8 @@ var BoxedFunction = class extends _BoxedExpression {
       const exponent = asSmallInteger(expr.op2);
       if (exponent !== null)
         return [coef.pow(exponent), ce.function("Power", [base, expr.op2])];
-      if (expr.op2.isSame(0.5)) return [coef.sqrt(), ce.function("Sqrt", [base])];
+      if (expr.op2.isSame(0.5))
+        return [coef.sqrt(), ce.function("Sqrt", [base])];
       return [ce._numericValue(1), this];
     }
     if (isFunction2(expr, "Sqrt")) {
@@ -49984,7 +50198,7 @@ var BaseCompiler = class _BaseCompiler {
     if (args.length === 1 && locals.length === 0) {
       return _BaseCompiler.compile(args[0], target);
     }
-    const result = args.map(
+    const result = args.filter((a) => !isSymbol2(a, "Nothing")).map(
       (arg) => _BaseCompiler.compile(arg, {
         ...target,
         var: (id) => {
@@ -49992,7 +50206,8 @@ var BaseCompiler = class _BaseCompiler {
           return target.var(id);
         }
       })
-    );
+    ).filter((s) => s !== "");
+    if (result.length === 0) return "";
     result[result.length - 1] = `return ${result[result.length - 1]}`;
     return `(() => {${target.ws("\n")}${result.join(
       `;${target.ws("\n")}`
@@ -53300,7 +53515,8 @@ function simplifyDivide(x) {
     if (numBase && denomBase && numBase.isSame(denomBase)) {
       if (!asRational(numExp) || !asRational(denomExp)) {
         const diffExp = ce.function("Add", [numExp, denomExp.neg()]);
-        if (diffExp.isSame(0)) return { value: ce.One, because: "x^a/x^a -> 1" };
+        if (diffExp.isSame(0))
+          return { value: ce.One, because: "x^a/x^a -> 1" };
         if (diffExp.isSame(1))
           return { value: numBase, because: "x^a/x^b -> x when a-b=1" };
         return {
@@ -53756,7 +53972,8 @@ var SIMPLIFY_RULES = [
     const ce = expr.engine;
     if (y.isFinite === false && x.isFinite === false)
       return { value: ce.NaN, because: "arctan2" };
-    if (y.isSame(0) && x.isSame(0)) return { value: ce.Zero, because: "arctan2" };
+    if (y.isSame(0) && x.isSame(0))
+      return { value: ce.Zero, because: "arctan2" };
     if (x.isFinite === false)
       return { value: x.isPositive ? ce.Zero : ce.Pi, because: "arctan2" };
     if (y.isFinite === false)
@@ -55174,10 +55391,10 @@ var BoxedSymbol = class extends _BoxedExpression {
     if (this._def) return this;
     return this.engine.symbol(this._id);
   }
-  is(other) {
-    if (this.isSame(other)) return true;
+  is(other, tolerance) {
+    if (tolerance === void 0 && this.isSame(other)) return true;
     const val = this.value;
-    if (val && val !== this) return val.is(other);
+    if (val && val !== this) return val.is(other, tolerance);
     return false;
   }
   isSame(other) {
@@ -57239,21 +57456,23 @@ function compileGPUMatrix(args, compile3, vecFn, matFn, arrayFn) {
 var GPU_GAMMA_PREAMBLE = `
 float _gpu_gamma(float z) {
   const float PI = 3.14159265358979;
-  if (z < 0.5) {
-    return PI / (sin(PI * z) * _gpu_gamma(1.0 - z));
-  }
-  z -= 1.0;
+  // For z < 0.5, use reflection formula with inlined Lanczos (non-recursive)
+  float w = z;
+  if (z < 0.5) w = 1.0 - z;
+  w -= 1.0;
   float x = 0.99999999999980993;
-  x += 676.5203681218851 / (z + 1.0);
-  x += -1259.1392167224028 / (z + 2.0);
-  x += 771.32342877765313 / (z + 3.0);
-  x += -176.61502916214059 / (z + 4.0);
-  x += 12.507343278686905 / (z + 5.0);
-  x += -0.13857109526572012 / (z + 6.0);
-  x += 9.9843695780195716e-6 / (z + 7.0);
-  x += 1.5056327351493116e-7 / (z + 8.0);
-  float t = z + 7.5;
-  return sqrt(2.0 * PI) * pow(t, z + 0.5) * exp(-t) * x;
+  x += 676.5203681218851 / (w + 1.0);
+  x += -1259.1392167224028 / (w + 2.0);
+  x += 771.32342877765313 / (w + 3.0);
+  x += -176.61502916214059 / (w + 4.0);
+  x += 12.507343278686905 / (w + 5.0);
+  x += -0.13857109526572012 / (w + 6.0);
+  x += 9.9843695780195716e-6 / (w + 7.0);
+  x += 1.5056327351493116e-7 / (w + 8.0);
+  float t = w + 7.5;
+  float g = sqrt(2.0 * PI) * pow(t, w + 0.5) * exp(-t) * x;
+  if (z < 0.5) return PI / (sin(PI * z) * g);
+  return g;
 }
 
 float _gpu_gammaln(float z) {
@@ -60614,21 +60833,23 @@ IntervalResult ia_asech(IntervalResult x) {
 // Poles at non-positive integers; minimum at x \u2248 1.4616
 float _gpu_gamma(float z) {
   const float PI = 3.14159265358979;
-  if (z < 0.5) {
-    return PI / (sin(PI * z) * _gpu_gamma(1.0 - z));
-  }
-  z -= 1.0;
+  // For z < 0.5, use reflection formula with inlined Lanczos (non-recursive)
+  float w = z;
+  if (z < 0.5) w = 1.0 - z;
+  w -= 1.0;
   float x = 0.99999999999980993;
-  x += 676.5203681218851 / (z + 1.0);
-  x += -1259.1392167224028 / (z + 2.0);
-  x += 771.32342877765313 / (z + 3.0);
-  x += -176.61502916214059 / (z + 4.0);
-  x += 12.507343278686905 / (z + 5.0);
-  x += -0.13857109526572012 / (z + 6.0);
-  x += 9.9843695780195716e-6 / (z + 7.0);
-  x += 1.5056327351493116e-7 / (z + 8.0);
-  float t = z + 7.5;
-  return sqrt(2.0 * PI) * pow(t, z + 0.5) * exp(-t) * x;
+  x += 676.5203681218851 / (w + 1.0);
+  x += -1259.1392167224028 / (w + 2.0);
+  x += 771.32342877765313 / (w + 3.0);
+  x += -176.61502916214059 / (w + 4.0);
+  x += 12.507343278686905 / (w + 5.0);
+  x += -0.13857109526572012 / (w + 6.0);
+  x += 9.9843695780195716e-6 / (w + 7.0);
+  x += 1.5056327351493116e-7 / (w + 8.0);
+  float t = w + 7.5;
+  float g = sqrt(2.0 * PI) * pow(t, w + 0.5) * exp(-t) * x;
+  if (z < 0.5) return PI / (sin(PI * z) * g);
+  return g;
 }
 
 // Interval gamma function
@@ -60801,6 +61022,128 @@ float ia_notEqual(IntervalResult a, IntervalResult b) {
   return ia_notEqual(a.value, b.value);
 }
 `;
+var _preambleHeader = "";
+var _preambleFunctions = /* @__PURE__ */ new Map();
+var _preambleParsed = false;
+var GLSL_FUNC_RE = /^(IntervalResult|vec2|float|bool|void)\s+(ia_\w+|_gpu_\w+)\s*\(/;
+var GLSL_CALL_RE = /\b(ia_\w+|_gpu_\w+)\s*\(/g;
+var GLSL_CONST_RE = /^const\s+float\s+(IA_\w+)\s*=/;
+function parsePreamble() {
+  if (_preambleParsed) return;
+  _preambleParsed = true;
+  const lines = GLSL_INTERVAL_LIBRARY.split("\n");
+  let headerDone = false;
+  const headerLines = [];
+  let currentBlock = [];
+  let currentName = null;
+  let braceDepth = 0;
+  let inFunction = false;
+  let pendingComments = [];
+  let pendingConstants = [];
+  for (const line of lines) {
+    const constMatch = !inFunction && GLSL_CONST_RE.exec(line);
+    if (constMatch && headerDone) {
+      pendingConstants.push(line);
+      continue;
+    }
+    const funcMatch = !inFunction && GLSL_FUNC_RE.exec(line);
+    if (funcMatch) {
+      if (!headerDone) {
+        _preambleHeader = headerLines.join("\n");
+        headerDone = true;
+      }
+      currentName = funcMatch[2];
+      currentBlock = [...pendingComments, ...pendingConstants, line];
+      pendingComments = [];
+      pendingConstants = [];
+      inFunction = true;
+      braceDepth = 0;
+      for (const ch of line) {
+        if (ch === "{") braceDepth++;
+        if (ch === "}") braceDepth--;
+      }
+      if (braceDepth <= 0) {
+        finishFunction(currentName, currentBlock.join("\n"));
+        inFunction = false;
+        currentName = null;
+      }
+    } else if (inFunction) {
+      currentBlock.push(line);
+      for (const ch of line) {
+        if (ch === "{") braceDepth++;
+        if (ch === "}") braceDepth--;
+      }
+      if (braceDepth <= 0) {
+        finishFunction(currentName, currentBlock.join("\n"));
+        inFunction = false;
+        currentName = null;
+      }
+    } else if (!headerDone) {
+      headerLines.push(line);
+    } else {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("//") || trimmed === "") {
+        pendingComments.push(line);
+      }
+    }
+  }
+  if (pendingConstants.length > 0) {
+    _preambleHeader += "\n" + pendingConstants.join("\n");
+  }
+}
+function finishFunction(name, source) {
+  const deps = /* @__PURE__ */ new Set();
+  let match2;
+  const callRe = new RegExp(GLSL_CALL_RE.source, "g");
+  while ((match2 = callRe.exec(source)) !== null) {
+    const callee = match2[1];
+    if (callee !== name) deps.add(callee);
+  }
+  const existing = _preambleFunctions.get(name);
+  if (existing) {
+    existing.source += "\n\n" + source;
+    for (const d of deps) existing.deps.push(d);
+  } else {
+    _preambleFunctions.set(name, {
+      name,
+      source,
+      deps: [...deps]
+    });
+  }
+}
+function buildIntervalPreamble(code) {
+  parsePreamble();
+  const needed = /* @__PURE__ */ new Set();
+  let match2;
+  const callRe = new RegExp(GLSL_CALL_RE.source, "g");
+  while ((match2 = callRe.exec(code)) !== null) {
+    needed.add(match2[1]);
+  }
+  if (needed.size === 0) return _preambleHeader;
+  const resolved = /* @__PURE__ */ new Set();
+  function resolve(name) {
+    if (resolved.has(name)) return;
+    const block = _preambleFunctions.get(name);
+    if (!block) return;
+    for (const dep of block.deps) resolve(dep);
+    resolved.add(name);
+  }
+  for (const name of needed) resolve(name);
+  const parts = [_preambleHeader];
+  const needsComparisonConstants = [...resolved].some(
+    (name) => name.startsWith("ia_less") || name.startsWith("ia_greater") || name.startsWith("ia_equal") || name.startsWith("ia_notEqual") || name === "ia_and" || name === "ia_or" || name === "ia_not"
+  );
+  if (needsComparisonConstants) {
+    parts.push(
+      "\nconst float IA_TRUE = 1.0;\nconst float IA_FALSE = 0.0;\nconst float IA_MAYBE = 0.5;"
+    );
+  }
+  for (const name of resolved) {
+    const block = _preambleFunctions.get(name);
+    if (block) parts.push("\n" + block.source);
+  }
+  return parts.join("\n");
+}
 var INTERVAL_GLSL_OPERATORS = {
   Add: ["ia_add", 20],
   Negate: ["ia_negate", 20],
@@ -61026,7 +61369,7 @@ var IntervalGLSLTarget = class {
       target: "interval-glsl",
       success: true,
       code: glslCode,
-      preamble: GLSL_INTERVAL_LIBRARY
+      preamble: buildIntervalPreamble(glslCode)
     };
   }
   /**
@@ -61069,7 +61412,7 @@ var IntervalGLSLTarget = class {
     return `#version ${version2}
 precision highp float;
 
-${GLSL_INTERVAL_LIBRARY}
+${buildIntervalPreamble(body)}
 
 IntervalResult ${functionName}(${params}) {
   return ${body};
@@ -62180,6 +62523,122 @@ fn ia_notEqual(a: IntervalResult, b: IntervalResult) -> f32 {
   return ia_notEqual_v(a.value, b.value);
 }
 `;
+var _wgslPreambleHeader = "";
+var _wgslPreambleFunctions = /* @__PURE__ */ new Map();
+var _wgslPreambleParsed = false;
+var WGSL_FUNC_RE = /^fn\s+(ia_\w+|_gpu_\w+)\s*\(/;
+var WGSL_CALL_RE = /\b(ia_\w+|_gpu_\w+)\s*\(/g;
+var WGSL_CONST_RE = /^const\s+(IA_\w+)\s*:/;
+function parseWGSLPreamble() {
+  if (_wgslPreambleParsed) return;
+  _wgslPreambleParsed = true;
+  const lines = WGSL_INTERVAL_LIBRARY.split("\n");
+  let headerDone = false;
+  const headerLines = [];
+  let currentBlock = [];
+  let currentName = null;
+  let braceDepth = 0;
+  let inFunction = false;
+  let pendingComments = [];
+  let pendingConstants = [];
+  for (const line of lines) {
+    const constMatch = !inFunction && WGSL_CONST_RE.exec(line);
+    if (constMatch && headerDone) {
+      pendingConstants.push(line);
+      continue;
+    }
+    const funcMatch = !inFunction && WGSL_FUNC_RE.exec(line);
+    if (funcMatch) {
+      if (!headerDone) {
+        _wgslPreambleHeader = headerLines.join("\n");
+        headerDone = true;
+      }
+      currentName = funcMatch[1];
+      currentBlock = [...pendingComments, ...pendingConstants, line];
+      pendingComments = [];
+      pendingConstants = [];
+      inFunction = true;
+      braceDepth = 0;
+      for (const ch of line) {
+        if (ch === "{") braceDepth++;
+        if (ch === "}") braceDepth--;
+      }
+      if (braceDepth <= 0) {
+        finishWGSLFunction(currentName, currentBlock.join("\n"));
+        inFunction = false;
+        currentName = null;
+      }
+    } else if (inFunction) {
+      currentBlock.push(line);
+      for (const ch of line) {
+        if (ch === "{") braceDepth++;
+        if (ch === "}") braceDepth--;
+      }
+      if (braceDepth <= 0) {
+        finishWGSLFunction(currentName, currentBlock.join("\n"));
+        inFunction = false;
+        currentName = null;
+      }
+    } else if (!headerDone) {
+      headerLines.push(line);
+    } else {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("//") || trimmed === "") {
+        pendingComments.push(line);
+      }
+    }
+  }
+  if (pendingConstants.length > 0) {
+    _wgslPreambleHeader += "\n" + pendingConstants.join("\n");
+  }
+}
+function finishWGSLFunction(name, source) {
+  const deps = /* @__PURE__ */ new Set();
+  let match2;
+  const callRe = new RegExp(WGSL_CALL_RE.source, "g");
+  while ((match2 = callRe.exec(source)) !== null) {
+    const callee = match2[1];
+    if (callee !== name) deps.add(callee);
+  }
+  _wgslPreambleFunctions.set(name, {
+    name,
+    source,
+    deps: [...deps]
+  });
+}
+function buildIntervalWGSLPreamble(code) {
+  parseWGSLPreamble();
+  const needed = /* @__PURE__ */ new Set();
+  let match2;
+  const callRe = new RegExp(WGSL_CALL_RE.source, "g");
+  while ((match2 = callRe.exec(code)) !== null) {
+    needed.add(match2[1]);
+  }
+  if (needed.size === 0) return _wgslPreambleHeader;
+  const resolved = /* @__PURE__ */ new Set();
+  function resolve(name) {
+    if (resolved.has(name)) return;
+    const block = _wgslPreambleFunctions.get(name);
+    if (!block) return;
+    for (const dep of block.deps) resolve(dep);
+    resolved.add(name);
+  }
+  for (const name of needed) resolve(name);
+  const parts = [_wgslPreambleHeader];
+  const needsComparisonConstants = [...resolved].some(
+    (name) => name.startsWith("ia_less") || name.startsWith("ia_greater") || name.startsWith("ia_equal") || name.startsWith("ia_notEqual") || name === "ia_and" || name === "ia_or" || name === "ia_not"
+  );
+  if (needsComparisonConstants) {
+    parts.push(
+      "\nconst IA_TRUE: f32 = 1.0;\nconst IA_FALSE: f32 = 0.0;\nconst IA_MAYBE: f32 = 0.5;"
+    );
+  }
+  for (const name of resolved) {
+    const block = _wgslPreambleFunctions.get(name);
+    if (block) parts.push("\n" + block.source);
+  }
+  return parts.join("\n");
+}
 var INTERVAL_WGSL_OPERATORS = {
   Add: ["ia_add", 20],
   Negate: ["ia_negate", 20],
@@ -62403,7 +62862,7 @@ var IntervalWGSLTarget = class {
       target: "interval-wgsl",
       success: true,
       code: wgslCode,
-      preamble: WGSL_INTERVAL_LIBRARY
+      preamble: buildIntervalWGSLPreamble(wgslCode)
     };
   }
   /**
@@ -62439,7 +62898,8 @@ var IntervalWGSLTarget = class {
     const target = this.createTarget();
     const body = BaseCompiler.compile(expr, target);
     const params = parameters.map((name) => `${name}: vec2f`).join(", ");
-    return `${WGSL_INTERVAL_LIBRARY}
+    const preamble = buildIntervalWGSLPreamble(body);
+    return `${preamble}
 
 fn ${functionName}(${params}) -> IntervalResult {
   return ${body};
@@ -62929,7 +63389,23 @@ var BoxedNumber = class extends _BoxedExpression {
     if (typeof this._value === "number") return true;
     return isSubtype(this._value.type, "real");
   }
-  is(other) {
+  get isExact() {
+    const n = this._value;
+    if (typeof n === "number")
+      return !Number.isFinite(n) || Number.isInteger(n);
+    return n.isExact;
+  }
+  is(other, tolerance) {
+    if (tolerance === void 0) return this.isSame(other);
+    if (typeof other === "number") {
+      return Math.abs(this.re - other) <= tolerance && Math.abs(this.im) <= tolerance;
+    }
+    if (typeof other === "bigint") {
+      return Math.abs(this.re - Number(other)) <= tolerance && Math.abs(this.im) <= tolerance;
+    }
+    if (other instanceof _BoxedExpression && isNumber(other)) {
+      return Math.abs(this.re - other.re) <= tolerance && Math.abs(this.im - other.im) <= tolerance;
+    }
     return this.isSame(other);
   }
   isSame(other) {
@@ -65489,6 +65965,58 @@ var _Parser = class __Parser {
       return null;
     }
     this.skipSpace();
+    let subscript = null;
+    if (this.peek === "_") {
+      const underIndex = this.index;
+      this.index++;
+      subscript = this.parseGroup();
+      if (subscript === null) {
+        const subStart = this.index;
+        if (!this.atEnd && /^[a-zA-Z]$/.test(this.peek)) {
+          subscript = this.peek;
+          this.index++;
+        } else {
+          let digits = "";
+          while (!this.atEnd && /^[0-9]$/.test(this.peek)) {
+            digits += this.peek;
+            this.index++;
+          }
+          if (digits) subscript = parseInt(digits);
+        }
+        if (subscript === null) {
+          this.index = start;
+          return null;
+        }
+      }
+      this.skipSpace();
+    }
+    let exponent = null;
+    if (this.peek === "^") {
+      const caretIndex = this.index;
+      this.index++;
+      exponent = this.parseGroup();
+      if (exponent === null) {
+        const digitStart = this.index;
+        let neg2 = false;
+        if (this.peek === "-") {
+          neg2 = true;
+          this.index++;
+        }
+        let digits = "";
+        while (!this.atEnd && /^[0-9]$/.test(this.peek)) {
+          digits += this.peek;
+          this.index++;
+        }
+        if (digits) {
+          const num = parseInt(digits);
+          exponent = neg2 ? -num : num;
+        } else {
+          this.index = start;
+          return null;
+        }
+      }
+      this.skipSpace();
+    }
     if (this.peek !== "(") {
       this.index = start;
       return null;
@@ -65563,8 +66091,19 @@ var _Parser = class __Parser {
       this.index = start;
       return null;
     }
-    if (name === "cbrt") return ["Root", args[0] ?? "Nothing", 3];
-    return [fnName, ...args];
+    if (name === "cbrt") {
+      const result2 = ["Root", args[0] ?? "Nothing", 3];
+      return exponent !== null ? ["Power", result2, exponent] : result2;
+    }
+    let result;
+    if (name === "log" && subscript !== null) {
+      if (subscript === 2) result = ["Lb", ...args];
+      else if (subscript === 10) result = ["Log", ...args];
+      else result = ["Log", args[0], subscript];
+    } else {
+      result = [fnName, ...args];
+    }
+    return exponent !== null ? ["Power", result, exponent] : result;
   }
   static BARE_SYMBOL_MAP = {
     // Greek lowercase
@@ -69466,10 +70005,10 @@ var ComputeEngine = class _ComputeEngine {
 _setComputeEngineClass(ComputeEngine);
 
 // src/compute-engine.ts
-var version = "0.52.0";
+var version = "0.52.1";
 globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.52.0"
+  version: "0.52.1"
 };
 export {
   BaseCompiler,