@cortex-js/compute-engine 0.55.0 → 0.55.3

package/dist/compute-engine.umd.cjs

@@ -1,4 +1,4 @@
-/** Compute Engine 0.55.0 */
+/** Compute Engine 0.55.3 */
     (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';
 var ComputeEngine = (() => {
   var __defProp = Object.defineProperty;
@@ -9601,6 +9601,452 @@ var ComputeEngine = (() => {
     return expr2;
   }
 
+  // src/compute-engine/latex-syntax/dictionary/definitions-logic.ts
+  var DEFINITIONS_LOGIC = [
+    // Constants
+    {
+      name: "True",
+      kind: "symbol",
+      latexTrigger: ["\\top"]
+      // ⊤ U+22A4
+    },
+    {
+      kind: "symbol",
+      latexTrigger: "\\mathrm{True}",
+      parse: "True"
+    },
+    {
+      kind: "symbol",
+      latexTrigger: "\\operatorname{True}",
+      parse: "True"
+    },
+    {
+      kind: "symbol",
+      latexTrigger: "\\mathsf{T}",
+      parse: "True"
+    },
+    {
+      name: "False",
+      kind: "symbol",
+      latexTrigger: ["\\bot"]
+      // ⊥ U+22A5
+    },
+    {
+      kind: "symbol",
+      latexTrigger: "\\operatorname{False}",
+      parse: "False"
+    },
+    {
+      kind: "symbol",
+      latexTrigger: "\\mathsf{F}",
+      parse: "False"
+    },
+    // Operators
+    // Logic operators have lower precedence than comparisons (245)
+    // so that `x = 1 \lor x = 2` parses as `(x = 1) \lor (x = 2)`
+    // See https://github.com/cortex-js/compute-engine/issues/243
+    {
+      name: "And",
+      kind: "infix",
+      latexTrigger: ["\\land"],
+      precedence: 235
+      // serialize: '\\land',
+    },
+    { kind: "infix", latexTrigger: ["\\wedge"], parse: "And", precedence: 235 },
+    { kind: "infix", latexTrigger: "\\&", parse: "And", precedence: 235 },
+    {
+      kind: "infix",
+      latexTrigger: "\\operatorname{and}",
+      parse: "And",
+      precedence: 235
+    },
+    {
+      name: "Or",
+      kind: "infix",
+      latexTrigger: ["\\lor"],
+      precedence: 230
+    },
+    { kind: "infix", latexTrigger: ["\\vee"], parse: "Or", precedence: 230 },
+    { kind: "infix", latexTrigger: "\\parallel", parse: "Or", precedence: 230 },
+    {
+      kind: "infix",
+      latexTrigger: "\\operatorname{or}",
+      parse: "Or",
+      precedence: 230
+    },
+    {
+      name: "Xor",
+      kind: "infix",
+      latexTrigger: ["\\veebar"],
+      precedence: 232
+    },
+    // Possible alt: \oplus ⊕ U+2295
+    {
+      name: "Not",
+      kind: "prefix",
+      latexTrigger: ["\\lnot"],
+      precedence: 880
+    },
+    {
+      kind: "prefix",
+      latexTrigger: ["\\neg"],
+      parse: "Not",
+      precedence: 880
+    },
+    {
+      name: "Nand",
+      kind: "infix",
+      latexTrigger: ["\\barwedge"],
+      precedence: 232
+      // serialize: '\\mid',
+    },
+    {
+      name: "Nor",
+      kind: "infix",
+      latexTrigger: ["\u22BD"],
+      // bar vee
+      precedence: 232
+      // serialize: '\\downarrow',
+    },
+    // Functions
+    {
+      kind: "function",
+      symbolTrigger: "and",
+      parse: "And"
+    },
+    {
+      kind: "function",
+      symbolTrigger: "or",
+      parse: "Or"
+    },
+    {
+      kind: "function",
+      symbolTrigger: "not",
+      parse: "Not"
+    },
+    // Relations
+    {
+      name: "Implies",
+      kind: "infix",
+      precedence: 220,
+      associativity: "right",
+      latexTrigger: ["\\implies"],
+      serialize: "\\implies"
+    },
+    {
+      latexTrigger: ["\\Rightarrow"],
+      kind: "infix",
+      precedence: 220,
+      associativity: "right",
+      parse: "Implies"
+    },
+    {
+      latexTrigger: ["\\rightarrow"],
+      kind: "infix",
+      precedence: 220,
+      associativity: "right",
+      parse: "Implies"
+    },
+    {
+      latexTrigger: ["\\Longrightarrow"],
+      kind: "infix",
+      precedence: 220,
+      associativity: "right",
+      parse: "Implies"
+    },
+    {
+      latexTrigger: ["\\longrightarrow"],
+      kind: "infix",
+      precedence: 220,
+      associativity: "right",
+      parse: "Implies"
+    },
+    {
+      // Non-strict mode: => for implies
+      latexTrigger: ["=", ">"],
+      kind: "infix",
+      precedence: 220,
+      associativity: "right",
+      parse: (parser, lhs, until) => {
+        if (parser.options.strict !== false) return null;
+        const rhs = parser.parseExpression({ ...until, minPrec: 220 });
+        if (rhs === null) return null;
+        return ["Implies", lhs, rhs];
+      }
+    },
+    {
+      name: "Equivalent",
+      // MathML: identical to, Mathematica: Congruent
+      latexTrigger: ["\\iff"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 219
+    },
+    {
+      latexTrigger: ["\\Leftrightarrow"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 219,
+      parse: "Equivalent"
+    },
+    {
+      latexTrigger: ["\\leftrightarrow"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 219,
+      parse: "Equivalent"
+    },
+    {
+      latexTrigger: ["\\Longleftrightarrow"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 219,
+      parse: "Equivalent"
+    },
+    {
+      latexTrigger: ["\\longleftrightarrow"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 219,
+      parse: "Equivalent"
+    },
+    {
+      // Non-strict mode: <=> for equivalence
+      latexTrigger: ["<", "=", ">"],
+      kind: "infix",
+      precedence: 219,
+      associativity: "right",
+      parse: (parser, lhs, until) => {
+        if (parser.options.strict !== false) return null;
+        const rhs = parser.parseExpression({ ...until, minPrec: 219 });
+        if (rhs === null) return null;
+        return ["Equivalent", lhs, rhs];
+      }
+    },
+    {
+      latexTrigger: ["\\equiv"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 219,
+      parse: (parser, lhs, terminator) => {
+        const rhs = parser.parseExpression({ ...terminator, minPrec: 219 });
+        const index = parser.index;
+        const modulus = parser.parseExpression({ ...terminator, minPrec: 219 });
+        if (modulus !== null && operator(modulus) === "Mod")
+          return ["Congruent", lhs, rhs, missingIfEmpty(operand(modulus, 1))];
+        parser.index = index;
+        return ["Equivalent", lhs, missingIfEmpty(rhs)];
+      }
+    },
+    {
+      name: "Proves",
+      kind: "infix",
+      latexTrigger: ["\\vdash"],
+      precedence: 220,
+      associativity: "right",
+      serialize: "\\vdash"
+    },
+    {
+      name: "Entails",
+      kind: "infix",
+      latexTrigger: ["\\vDash"],
+      precedence: 220,
+      associativity: "right",
+      serialize: "\\vDash"
+    },
+    {
+      name: "Satisfies",
+      kind: "infix",
+      latexTrigger: ["\\models"],
+      precedence: 220,
+      associativity: "right",
+      serialize: "\\models"
+    },
+    // Quantifiers: for all, exists
+    {
+      name: "ForAll",
+      kind: "prefix",
+      latexTrigger: ["\\forall"],
+      precedence: 200,
+      // Has to be lower than COMPARISON_PRECEDENCE
+      serialize: serializeQuantifier("\\forall"),
+      parse: parseQuantifier("ForAll")
+    },
+    {
+      name: "Exists",
+      kind: "prefix",
+      latexTrigger: ["\\exists"],
+      precedence: 200,
+      // Has to be lower than COMPARISON_PRECEDENCE,
+      serialize: serializeQuantifier("\\exists"),
+      parse: parseQuantifier("Exists")
+    },
+    {
+      name: "ExistsUnique",
+      kind: "prefix",
+      latexTrigger: ["\\exists", "!"],
+      precedence: 200,
+      // Has to be lower than COMPARISON_PRECEDENCE,
+      serialize: serializeQuantifier("\\exists!"),
+      parse: parseQuantifier("ExistsUnique")
+    },
+    {
+      name: "NotForAll",
+      kind: "prefix",
+      latexTrigger: ["\\lnot", "\\forall"],
+      precedence: 200,
+      // Has to be lower than COMPARISON_PRECEDENCE
+      serialize: serializeQuantifier("\\lnot\\forall"),
+      parse: parseQuantifier("NotForAll")
+    },
+    {
+      name: "NotExists",
+      kind: "prefix",
+      latexTrigger: ["\\lnot", "\\exists"],
+      precedence: 200,
+      // Has to be lower than COMPARISON_PRECEDENCE,
+      serialize: serializeQuantifier("\\lnot\\exists"),
+      parse: parseQuantifier("NotExists")
+    },
+    {
+      name: "KroneckerDelta",
+      kind: "prefix",
+      latexTrigger: ["\\delta", "_"],
+      precedence: 200,
+      serialize: (serializer, expr2) => {
+        const args = operands(expr2);
+        if (args.length === 0) return "\\delta";
+        if (args.every((x) => symbol(x)))
+          return `\\delta_{${args.map((arg) => serializer.serialize(arg)).join("")}}`;
+        return `\\delta_{${args.map((arg) => serializer.serialize(arg)).join(", ")}}`;
+      },
+      parse: (parser) => {
+        const group = parser.parseGroup();
+        if (group === null) {
+          const token = parser.parseToken();
+          if (!token) return null;
+          return ["KroneckerDelta", token];
+        }
+        const seq = getSequence(group);
+        if (seq && seq.length <= 2) return ["KroneckerDelta", ...seq];
+        if (operator(group) === "InvisibleOperator")
+          return ["KroneckerDelta", ...operands(group)];
+        if (group !== null) return ["KroneckerDelta", group];
+        return null;
+      }
+    },
+    // Iverson brackets. Also called the "indicator function"
+    // Must have a single argument, a relational expression, i.e.
+    // `[ a = b ]` or `[ x \leq 0 ]`
+    // Otherwise, it gets rejected, it could be something else, like a list or
+    // tuple.
+    {
+      name: "Boole",
+      kind: "matchfix",
+      openTrigger: "[",
+      closeTrigger: "]",
+      // serialize: (serializer: Serializer, expr: MathJsonExpression) => {
+      //   const args = ops(expr);
+      //   return `[${serializer.serialize(arg)}]`;
+      // },
+      parse: (_parser, body) => {
+        const h = operator(body);
+        if (!h) return null;
+        if (!DEFINITIONS_INEQUALITIES.some((x) => x.name === h)) return null;
+        return ["Boole", body];
+      }
+    },
+    {
+      kind: "matchfix",
+      openTrigger: "\\llbracket",
+      closeTrigger: "\\rrbracket",
+      parse: (_parser, body) => {
+        const h = operator(body);
+        if (!h) return null;
+        if (!DEFINITIONS_INEQUALITIES.some((x) => x.name === h)) return null;
+        return ["Boole", body];
+      }
+    },
+    // Predicate application in First-Order Logic.
+    // ["Predicate", "P", "x", "y"] serializes to "P(x, y)"
+    {
+      name: "Predicate",
+      serialize: (serializer, expr2) => {
+        const args = operands(expr2);
+        if (args.length === 0) return "";
+        const pred = args[0];
+        const predStr = typeof pred === "string" ? pred : serializer.serialize(pred);
+        if (args.length === 1) return predStr;
+        const argStrs = args.slice(1).map((arg) => serializer.serialize(arg));
+        return `${predStr}(${argStrs.join(", ")})`;
+      }
+    }
+  ];
+  function serializeQuantifier(quantifierSymbol) {
+    return (serializer, expr2) => {
+      const args = operands(expr2);
+      if (args.length === 0) return quantifierSymbol;
+      if (args.length === 1)
+        return `${quantifierSymbol} ${serializer.serialize(args[0])}`;
+      const boundVar = serializer.serialize(args[0]);
+      const body = serializer.serialize(args[1]);
+      return `${quantifierSymbol} ${boundVar}, ${body}`;
+    };
+  }
+  function tightBindingCondition(p, terminator) {
+    return p.peek === "\\to" || p.peek === "\\rightarrow" || p.peek === "\\implies" || p.peek === "\\Rightarrow" || p.peek === "\\iff" || p.peek === "\\Leftrightarrow" || p.peek === "\\land" || p.peek === "\\wedge" || p.peek === "\\lor" || p.peek === "\\vee" || (terminator.condition?.(p) ?? false);
+  }
+  function parseQuantifier(kind) {
+    return (parser, terminator) => {
+      const index = parser.index;
+      const useTightBinding = parser.options.quantifierScope !== "loose";
+      const symbol2 = parser.parseSymbol(terminator);
+      if (symbol2) {
+        parser.skipSpace();
+        if (parser.match(",") || parser.match("\\mid") || parser.match(".") || parser.match(":") || parser.match("\\colon")) {
+          const bodyTerminator = useTightBinding ? {
+            ...terminator,
+            condition: (p) => tightBindingCondition(p, terminator)
+          } : terminator;
+          parser.enterQuantifierScope();
+          const body2 = parser.parseExpression(bodyTerminator);
+          parser.exitQuantifierScope();
+          return [kind, symbol2, missingIfEmpty(body2)];
+        }
+        parser.enterQuantifierScope();
+        const body = parser.parseEnclosure();
+        parser.exitQuantifierScope();
+        if (body) return [kind, symbol2, missingIfEmpty(body)];
+      }
+      parser.index = index;
+      const condTerminator = {
+        ...terminator,
+        condition: (p) => p.peek === ":" || p.peek === "\\colon" || (terminator.condition?.(p) ?? false)
+      };
+      const condition = parser.parseExpression(condTerminator);
+      if (condition === null) return null;
+      parser.skipSpace();
+      if (parser.matchAny([",", "\\mid", ":", "\\colon"])) {
+        const bodyTerminator = useTightBinding ? {
+          ...terminator,
+          condition: (p) => tightBindingCondition(p, terminator)
+        } : terminator;
+        parser.enterQuantifierScope();
+        const body = parser.parseExpression(bodyTerminator);
+        parser.exitQuantifierScope();
+        return [kind, condition, missingIfEmpty(body)];
+      }
+      if (parser.match("(")) {
+        parser.enterQuantifierScope();
+        const body = parser.parseExpression(terminator);
+        parser.exitQuantifierScope();
+        if (!parser.match(")")) return null;
+        return [kind, condition, missingIfEmpty(body)];
+      }
+      return null;
+    };
+  }
+
   // src/compute-engine/latex-syntax/dictionary/definitions-core.ts
   function parseSequence(parser, terminator, lhs, prec, sep) {
     if (terminator && terminator.minPrec >= prec) return null;
@@ -10211,6 +10657,120 @@ var ComputeEngine = (() => {
       precedence: 21,
       parse: (parser, lhs, until) => parseWhereExpression(parser, lhs, until)
     },
+    // \text{and} — logical conjunction infix
+    {
+      latexTrigger: ["\\text"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 235,
+      // Same as \land
+      parse: (parser, lhs, until) => {
+        const start = parser.index;
+        if (!matchTextKeyword(parser, "and")) {
+          parser.index = start;
+          return null;
+        }
+        const rhs = parser.parseExpression({ ...until, minPrec: 235 });
+        return ["And", lhs, rhs ?? "Nothing"];
+      }
+    },
+    // \text{or} — logical disjunction infix
+    {
+      latexTrigger: ["\\text"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 230,
+      // Same as \lor
+      parse: (parser, lhs, until) => {
+        const start = parser.index;
+        if (!matchTextKeyword(parser, "or")) {
+          parser.index = start;
+          return null;
+        }
+        const rhs = parser.parseExpression({ ...until, minPrec: 230 });
+        return ["Or", lhs, rhs ?? "Nothing"];
+      }
+    },
+    // \text{iff} — biconditional (if and only if)
+    {
+      latexTrigger: ["\\text"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 219,
+      // Same as \iff
+      parse: (parser, lhs, until) => {
+        const start = parser.index;
+        if (!matchTextKeyword(parser, "iff")) {
+          parser.index = start;
+          return null;
+        }
+        const rhs = parser.parseExpression({ ...until, minPrec: 219 });
+        return ["Equivalent", lhs, rhs ?? "Nothing"];
+      }
+    },
+    // \text{if and only if} — verbose biconditional
+    {
+      latexTrigger: ["\\text"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 219,
+      parse: (parser, lhs, until) => {
+        const start = parser.index;
+        if (!matchTextKeyword(parser, "if and only if")) {
+          parser.index = start;
+          return null;
+        }
+        const rhs = parser.parseExpression({ ...until, minPrec: 219 });
+        return ["Equivalent", lhs, rhs ?? "Nothing"];
+      }
+    },
+    // \text{such that} — constraint separator (like : in set-builder notation)
+    {
+      latexTrigger: ["\\text"],
+      kind: "infix",
+      associativity: "right",
+      precedence: 21,
+      // Low precedence to capture full condition (same as 'where')
+      parse: (parser, lhs, until) => {
+        const start = parser.index;
+        if (!matchTextKeyword(parser, "such that")) {
+          parser.index = start;
+          return null;
+        }
+        const rhs = parser.parseExpression({ ...until, minPrec: 21 });
+        return ["Colon", lhs, rhs ?? "Nothing"];
+      }
+    },
+    // \text{for all} — universal quantifier
+    {
+      latexTrigger: ["\\text"],
+      kind: "prefix",
+      precedence: 200,
+      // Same as \forall
+      parse: (parser, until) => {
+        const start = parser.index;
+        if (!matchTextKeyword(parser, "for all")) {
+          parser.index = start;
+          return null;
+        }
+        return parseQuantifier("ForAll")(parser, until);
+      }
+    },
+    // \text{there exists} — existential quantifier
+    {
+      latexTrigger: ["\\text"],
+      kind: "prefix",
+      precedence: 200,
+      // Same as \exists
+      parse: (parser, until) => {
+        const start = parser.index;
+        if (!matchTextKeyword(parser, "there exists")) {
+          parser.index = start;
+          return null;
+        }
+        return parseQuantifier("Exists")(parser, until);
+      }
+    },
     // Block serializer — used by both `where` and semicolon blocks
     {
       name: "Block",
@@ -10326,6 +10886,39 @@ var ComputeEngine = (() => {
         parser.parseExpression(until) ?? "Nothing"
       ]
     },
+    // Text serializer — reconstructs \text{...} with inline $...$ for math
+    {
+      name: "Text",
+      serialize: (serializer, expr2) => {
+        const args = operands(expr2);
+        if (args.length === 0) return "";
+        let firstStr = -1;
+        let lastStr = -1;
+        for (let i = 0; i < args.length; i++) {
+          if (stringValue(args[i]) !== null) {
+            if (firstStr < 0) firstStr = i;
+            lastStr = i;
+          }
+        }
+        if (firstStr < 0)
+          return joinLatex(args.map((a) => serializer.serialize(a)));
+        const parts = [];
+        for (let i = 0; i < firstStr; i++)
+          parts.push(serializer.serialize(args[i]));
+        let textContent = "";
+        for (let i = firstStr; i <= lastStr; i++) {
+          const s = stringValue(args[i]);
+          if (s !== null) textContent += sanitizeLatex(s);
+          else if (operator(args[i]) === "Annotated" || operator(args[i]) === "Text")
+            textContent += serializer.serialize(args[i]);
+          else textContent += "$" + serializer.serialize(args[i]) + "$";
+        }
+        parts.push("\\text{" + textContent + "}");
+        for (let i = lastStr + 1; i < args.length; i++)
+          parts.push(serializer.serialize(args[i]));
+        return joinLatex(parts);
+      }
+    },
     {
       name: "String",
       latexTrigger: ["\\text"],
@@ -10716,9 +11309,10 @@ var ComputeEngine = (() => {
       } else if (parser.match("\\textcolor")) {
         const pos = parser.index;
         const color = parser.parseStringGroup();
-        const body2 = parser.parseExpression();
-        if (color !== null && body2 !== null) {
-          runs.push(["Annotated", body2, { dict: { color } }]);
+        if (color !== null) {
+          flush();
+          const body2 = parseTextRun(parser);
+          runs.push(["Annotated", body2, dictionaryFromEntries({ color })]);
         } else {
           parser.index = pos;
           text += "\\textcolor";
@@ -10736,6 +11330,7 @@ var ComputeEngine = (() => {
         const expr2 = parser.parseExpression() ?? "Nothing";
         parser.skipSpace();
         if (parser.match("<$>")) {
+          flush();
           runs.push(expr2);
         } else {
           text += "$";
@@ -10746,6 +11341,7 @@ var ComputeEngine = (() => {
         const expr2 = parser.parseExpression() ?? "Nothing";
         parser.skipSpace();
         if (parser.match("<$$>")) {
+          flush();
           runs.push(expr2);
         } else {
           text += "$$";
@@ -11096,14 +11692,20 @@ var ComputeEngine = (() => {
     }
     while (parser.match("<space>")) {
     }
-    let text = "";
-    while (!parser.atEnd && parser.peek !== "<}>" && parser.peek !== "<space>") {
-      const tok = parser.peek;
-      if (/^[a-zA-Z]$/.test(tok)) {
-        text += tok;
-        parser.nextToken();
+    for (let i = 0; i < keyword.length; i++) {
+      if (keyword[i] === " ") {
+        if (!parser.match("<space>")) {
+          parser.index = start;
+          return false;
+        }
+        while (parser.match("<space>")) {
+        }
       } else {
-        break;
+        if (parser.peek !== keyword[i]) {
+          parser.index = start;
+          return false;
+        }
+        parser.nextToken();
       }
     }
     while (parser.match("<space>")) {
@@ -11112,10 +11714,6 @@ var ComputeEngine = (() => {
       parser.index = start;
       return false;
     }
-    if (text !== keyword) {
-      parser.index = start;
-      return false;
-    }
     return true;
   }
   function matchKeyword(parser, keyword) {
@@ -11290,554 +11888,108 @@ var ComputeEngine = (() => {
     //GREEK SMALL LETTER FINAL SIGMA
     ["tau", "\\tau", 964],
     ["phi", "\\phi", 981],
-    // Note GREEK PHI SYMBOL, but common usage in math
-    ["phiLetter", "\\varphi", 966],
-    ["upsilon", "\\upsilon", 965],
-    ["chi", "\\chi", 967],
-    ["psi", "\\psi", 968],
-    ["omega", "\\omega", 969],
-    ["Alpha", "\\Alpha", 913],
-    ["Beta", "\\Beta", 914],
-    ["Gamma", "\\Gamma", 915],
-    ["Delta", "\\Delta", 916],
-    ["Epsilon", "\\Epsilon", 917],
-    ["Zeta", "\\Zeta", 918],
-    ["Eta", "\\Eta", 919],
-    ["Theta", "\\Theta", 920],
-    ["Iota", "\\Iota", 921],
-    ["Kappa", "\\Kappa", 922],
-    ["Lambda", "\\Lambda", 923],
-    ["Mu", "\\Mu", 924],
-    ["Nu", "\\Nu", 925],
-    ["Xi", "\\Xi", 926],
-    ["Omicron", "\\Omicron", 927],
-    // ['Pi', '\\Pi', 0x03a0],
-    ["Rho", "\\Rho", 929],
-    ["Sigma", "\\Sigma", 931],
-    ["Tau", "\\Tau", 932],
-    ["Phi", "\\Phi", 934],
-    ["Upsilon", "\\Upsilon", 933],
-    ["Chi", "\\Chi", 935],
-    ["Psi", "\\Psi", 936],
-    ["Omega", "\\Omega", 937],
-    ["digamma", "\\digamma", 989],
-    // Hebrew
-    ["aleph", "\\aleph", 8501],
-    // Unicode ALEF SYMBOL
-    ["bet", "\\beth", 8502],
-    ["gimel", "\\gimel", 8503],
-    ["dalet", "\\daleth", 8504],
-    // Letter-like
-    ["ell", "\\ell", 8499],
-    // Unicode SCRIPT SMALL L
-    ["turnedCapitalF", "\\Finv", 8498],
-    // Unicode TURNED CAPITAL F'
-    ["turnedCapitalG", "\\Game", 8513],
-    // TURNED SANS-SERIF CAPITAL G
-    ["weierstrass", "\\wp", 8472],
-    // Unicode SCRIPT CAPITAL P
-    ["eth", "\\eth", 240],
-    ["invertedOhm", "\\mho", 8487],
-    // Unicode INVERTED OHM SIGN
-    ["hBar", "\\hbar", 295],
-    // Unicode LATIN SMALL LETTER H WITH STROKE
-    ["hSlash", "\\hslash", 8463],
-    // Unicode PLANCK CONSTANT OVER TWO PI
-    // Symbols
-    ["blackClubSuit", "\\clubsuit", 9827],
-    ["whiteHeartSuit", "\\heartsuit", 9825],
-    ["blackSpadeSuit", "\\spadesuit", 9824],
-    ["whiteDiamondSuit", "\\diamondsuit", 9826],
-    ["sharp", "\\sharp", 9839],
-    ["flat", "\\flat", 9837],
-    ["natural", "\\natural", 9838]
-  ];
-  var DEFINITIONS_SYMBOLS = [
-    ...SYMBOLS2.map(([symbol2, latex, _codepoint]) => {
-      return {
-        kind: "symbol",
-        name: symbol2,
-        latexTrigger: [latex],
-        parse: symbol2
-      };
-    }),
-    ...SYMBOLS2.map(([symbol2, _latex, codepoint]) => {
-      return {
-        kind: "symbol",
-        latexTrigger: [String.fromCodePoint(codepoint)],
-        parse: symbol2
-      };
-    })
-  ];
-
-  // src/compute-engine/latex-syntax/dictionary/definitions-algebra.ts
-  var DEFINITIONS_ALGEBRA = [
-    {
-      name: "To",
-      latexTrigger: ["\\to"],
-      kind: "infix",
-      precedence: 270
-      // MathML rightwards arrow
-    },
-    {
-      // Non-strict mode: -> for maps-to arrow
-      latexTrigger: ["-", ">"],
-      kind: "infix",
-      precedence: 270,
-      parse: (parser, lhs, until) => {
-        if (parser.options.strict !== false) return null;
-        const rhs = parser.parseExpression({ ...until, minPrec: 270 });
-        if (rhs === null) return null;
-        return ["To", lhs, rhs];
-      }
-    }
-  ];
-
-  // src/compute-engine/latex-syntax/dictionary/definitions-logic.ts
-  var DEFINITIONS_LOGIC = [
-    // Constants
-    {
-      name: "True",
-      kind: "symbol",
-      latexTrigger: ["\\top"]
-      // ⊤ U+22A4
-    },
-    {
-      kind: "symbol",
-      latexTrigger: "\\mathrm{True}",
-      parse: "True"
-    },
-    {
-      kind: "symbol",
-      latexTrigger: "\\operatorname{True}",
-      parse: "True"
-    },
-    {
-      kind: "symbol",
-      latexTrigger: "\\mathsf{T}",
-      parse: "True"
-    },
-    {
-      name: "False",
-      kind: "symbol",
-      latexTrigger: ["\\bot"]
-      // ⊥ U+22A5
-    },
-    {
-      kind: "symbol",
-      latexTrigger: "\\operatorname{False}",
-      parse: "False"
-    },
-    {
-      kind: "symbol",
-      latexTrigger: "\\mathsf{F}",
-      parse: "False"
-    },
-    // Operators
-    // Logic operators have lower precedence than comparisons (245)
-    // so that `x = 1 \lor x = 2` parses as `(x = 1) \lor (x = 2)`
-    // See https://github.com/cortex-js/compute-engine/issues/243
-    {
-      name: "And",
-      kind: "infix",
-      latexTrigger: ["\\land"],
-      precedence: 235
-      // serialize: '\\land',
-    },
-    { kind: "infix", latexTrigger: ["\\wedge"], parse: "And", precedence: 235 },
-    { kind: "infix", latexTrigger: "\\&", parse: "And", precedence: 235 },
-    {
-      kind: "infix",
-      latexTrigger: "\\operatorname{and}",
-      parse: "And",
-      precedence: 235
-    },
-    {
-      name: "Or",
-      kind: "infix",
-      latexTrigger: ["\\lor"],
-      precedence: 230
-    },
-    { kind: "infix", latexTrigger: ["\\vee"], parse: "Or", precedence: 230 },
-    { kind: "infix", latexTrigger: "\\parallel", parse: "Or", precedence: 230 },
-    {
-      kind: "infix",
-      latexTrigger: "\\operatorname{or}",
-      parse: "Or",
-      precedence: 230
-    },
-    {
-      name: "Xor",
-      kind: "infix",
-      latexTrigger: ["\\veebar"],
-      precedence: 232
-    },
-    // Possible alt: \oplus ⊕ U+2295
-    {
-      name: "Not",
-      kind: "prefix",
-      latexTrigger: ["\\lnot"],
-      precedence: 880
-    },
-    {
-      kind: "prefix",
-      latexTrigger: ["\\neg"],
-      parse: "Not",
-      precedence: 880
-    },
-    {
-      name: "Nand",
-      kind: "infix",
-      latexTrigger: ["\\barwedge"],
-      precedence: 232
-      // serialize: '\\mid',
-    },
-    {
-      name: "Nor",
-      kind: "infix",
-      latexTrigger: ["\u22BD"],
-      // bar vee
-      precedence: 232
-      // serialize: '\\downarrow',
-    },
-    // Functions
-    {
-      kind: "function",
-      symbolTrigger: "and",
-      parse: "And"
-    },
-    {
-      kind: "function",
-      symbolTrigger: "or",
-      parse: "Or"
-    },
-    {
-      kind: "function",
-      symbolTrigger: "not",
-      parse: "Not"
-    },
-    // Relations
-    {
-      name: "Implies",
-      kind: "infix",
-      precedence: 220,
-      associativity: "right",
-      latexTrigger: ["\\implies"],
-      serialize: "\\implies"
-    },
-    {
-      latexTrigger: ["\\Rightarrow"],
-      kind: "infix",
-      precedence: 220,
-      associativity: "right",
-      parse: "Implies"
-    },
-    {
-      latexTrigger: ["\\rightarrow"],
-      kind: "infix",
-      precedence: 220,
-      associativity: "right",
-      parse: "Implies"
-    },
-    {
-      latexTrigger: ["\\Longrightarrow"],
-      kind: "infix",
-      precedence: 220,
-      associativity: "right",
-      parse: "Implies"
-    },
-    {
-      latexTrigger: ["\\longrightarrow"],
-      kind: "infix",
-      precedence: 220,
-      associativity: "right",
-      parse: "Implies"
-    },
-    {
-      // Non-strict mode: => for implies
-      latexTrigger: ["=", ">"],
-      kind: "infix",
-      precedence: 220,
-      associativity: "right",
-      parse: (parser, lhs, until) => {
-        if (parser.options.strict !== false) return null;
-        const rhs = parser.parseExpression({ ...until, minPrec: 220 });
-        if (rhs === null) return null;
-        return ["Implies", lhs, rhs];
-      }
-    },
-    {
-      name: "Equivalent",
-      // MathML: identical to, Mathematica: Congruent
-      latexTrigger: ["\\iff"],
-      kind: "infix",
-      associativity: "right",
-      precedence: 219
-    },
-    {
-      latexTrigger: ["\\Leftrightarrow"],
-      kind: "infix",
-      associativity: "right",
-      precedence: 219,
-      parse: "Equivalent"
-    },
-    {
-      latexTrigger: ["\\leftrightarrow"],
-      kind: "infix",
-      associativity: "right",
-      precedence: 219,
-      parse: "Equivalent"
-    },
-    {
-      latexTrigger: ["\\Longleftrightarrow"],
-      kind: "infix",
-      associativity: "right",
-      precedence: 219,
-      parse: "Equivalent"
-    },
+    // Note GREEK PHI SYMBOL, but common usage in math
+    ["phiLetter", "\\varphi", 966],
+    ["upsilon", "\\upsilon", 965],
+    ["chi", "\\chi", 967],
+    ["psi", "\\psi", 968],
+    ["omega", "\\omega", 969],
+    ["Alpha", "\\Alpha", 913],
+    ["Beta", "\\Beta", 914],
+    ["Gamma", "\\Gamma", 915],
+    ["Delta", "\\Delta", 916],
+    ["Epsilon", "\\Epsilon", 917],
+    ["Zeta", "\\Zeta", 918],
+    ["Eta", "\\Eta", 919],
+    ["Theta", "\\Theta", 920],
+    ["Iota", "\\Iota", 921],
+    ["Kappa", "\\Kappa", 922],
+    ["Lambda", "\\Lambda", 923],
+    ["Mu", "\\Mu", 924],
+    ["Nu", "\\Nu", 925],
+    ["Xi", "\\Xi", 926],
+    ["Omicron", "\\Omicron", 927],
+    // ['Pi', '\\Pi', 0x03a0],
+    ["Rho", "\\Rho", 929],
+    ["Sigma", "\\Sigma", 931],
+    ["Tau", "\\Tau", 932],
+    ["Phi", "\\Phi", 934],
+    ["Upsilon", "\\Upsilon", 933],
+    ["Chi", "\\Chi", 935],
+    ["Psi", "\\Psi", 936],
+    ["Omega", "\\Omega", 937],
+    ["digamma", "\\digamma", 989],
+    // Hebrew
+    ["aleph", "\\aleph", 8501],
+    // Unicode ALEF SYMBOL
+    ["bet", "\\beth", 8502],
+    ["gimel", "\\gimel", 8503],
+    ["dalet", "\\daleth", 8504],
+    // Letter-like
+    ["ell", "\\ell", 8499],
+    // Unicode SCRIPT SMALL L
+    ["turnedCapitalF", "\\Finv", 8498],
+    // Unicode TURNED CAPITAL F'
+    ["turnedCapitalG", "\\Game", 8513],
+    // TURNED SANS-SERIF CAPITAL G
+    ["weierstrass", "\\wp", 8472],
+    // Unicode SCRIPT CAPITAL P
+    ["eth", "\\eth", 240],
+    ["invertedOhm", "\\mho", 8487],
+    // Unicode INVERTED OHM SIGN
+    ["hBar", "\\hbar", 295],
+    // Unicode LATIN SMALL LETTER H WITH STROKE
+    ["hSlash", "\\hslash", 8463],
+    // Unicode PLANCK CONSTANT OVER TWO PI
+    // Symbols
+    ["blackClubSuit", "\\clubsuit", 9827],
+    ["whiteHeartSuit", "\\heartsuit", 9825],
+    ["blackSpadeSuit", "\\spadesuit", 9824],
+    ["whiteDiamondSuit", "\\diamondsuit", 9826],
+    ["sharp", "\\sharp", 9839],
+    ["flat", "\\flat", 9837],
+    ["natural", "\\natural", 9838]
+  ];
+  var DEFINITIONS_SYMBOLS = [
+    ...SYMBOLS2.map(([symbol2, latex, _codepoint]) => {
+      return {
+        kind: "symbol",
+        name: symbol2,
+        latexTrigger: [latex],
+        parse: symbol2
+      };
+    }),
+    ...SYMBOLS2.map(([symbol2, _latex, codepoint]) => {
+      return {
+        kind: "symbol",
+        latexTrigger: [String.fromCodePoint(codepoint)],
+        parse: symbol2
+      };
+    })
+  ];
+
+  // src/compute-engine/latex-syntax/dictionary/definitions-algebra.ts
+  var DEFINITIONS_ALGEBRA = [
     {
-      latexTrigger: ["\\longleftrightarrow"],
+      name: "To",
+      latexTrigger: ["\\to"],
       kind: "infix",
-      associativity: "right",
-      precedence: 219,
-      parse: "Equivalent"
+      precedence: 270
+      // MathML rightwards arrow
     },
     {
-      // Non-strict mode: <=> for equivalence
-      latexTrigger: ["<", "=", ">"],
+      // Non-strict mode: -> for maps-to arrow
+      latexTrigger: ["-", ">"],
       kind: "infix",
-      precedence: 219,
-      associativity: "right",
+      precedence: 270,
       parse: (parser, lhs, until) => {
         if (parser.options.strict !== false) return null;
-        const rhs = parser.parseExpression({ ...until, minPrec: 219 });
+        const rhs = parser.parseExpression({ ...until, minPrec: 270 });
         if (rhs === null) return null;
-        return ["Equivalent", lhs, rhs];
-      }
-    },
-    {
-      latexTrigger: ["\\equiv"],
-      kind: "infix",
-      associativity: "right",
-      precedence: 219,
-      parse: (parser, lhs, terminator) => {
-        const rhs = parser.parseExpression({ ...terminator, minPrec: 219 });
-        const index = parser.index;
-        const modulus = parser.parseExpression({ ...terminator, minPrec: 219 });
-        if (modulus !== null && operator(modulus) === "Mod")
-          return ["Congruent", lhs, rhs, missingIfEmpty(operand(modulus, 1))];
-        parser.index = index;
-        return ["Equivalent", lhs, missingIfEmpty(rhs)];
-      }
-    },
-    {
-      name: "Proves",
-      kind: "infix",
-      latexTrigger: ["\\vdash"],
-      precedence: 220,
-      associativity: "right",
-      serialize: "\\vdash"
-    },
-    {
-      name: "Entails",
-      kind: "infix",
-      latexTrigger: ["\\vDash"],
-      precedence: 220,
-      associativity: "right",
-      serialize: "\\vDash"
-    },
-    {
-      name: "Satisfies",
-      kind: "infix",
-      latexTrigger: ["\\models"],
-      precedence: 220,
-      associativity: "right",
-      serialize: "\\models"
-    },
-    // Quantifiers: for all, exists
-    {
-      name: "ForAll",
-      kind: "prefix",
-      latexTrigger: ["\\forall"],
-      precedence: 200,
-      // Has to be lower than COMPARISON_PRECEDENCE
-      serialize: serializeQuantifier("\\forall"),
-      parse: parseQuantifier("ForAll")
-    },
-    {
-      name: "Exists",
-      kind: "prefix",
-      latexTrigger: ["\\exists"],
-      precedence: 200,
-      // Has to be lower than COMPARISON_PRECEDENCE,
-      serialize: serializeQuantifier("\\exists"),
-      parse: parseQuantifier("Exists")
-    },
-    {
-      name: "ExistsUnique",
-      kind: "prefix",
-      latexTrigger: ["\\exists", "!"],
-      precedence: 200,
-      // Has to be lower than COMPARISON_PRECEDENCE,
-      serialize: serializeQuantifier("\\exists!"),
-      parse: parseQuantifier("ExistsUnique")
-    },
-    {
-      name: "NotForAll",
-      kind: "prefix",
-      latexTrigger: ["\\lnot", "\\forall"],
-      precedence: 200,
-      // Has to be lower than COMPARISON_PRECEDENCE
-      serialize: serializeQuantifier("\\lnot\\forall"),
-      parse: parseQuantifier("NotForAll")
-    },
-    {
-      name: "NotExists",
-      kind: "prefix",
-      latexTrigger: ["\\lnot", "\\exists"],
-      precedence: 200,
-      // Has to be lower than COMPARISON_PRECEDENCE,
-      serialize: serializeQuantifier("\\lnot\\exists"),
-      parse: parseQuantifier("NotExists")
-    },
-    {
-      name: "KroneckerDelta",
-      kind: "prefix",
-      latexTrigger: ["\\delta", "_"],
-      precedence: 200,
-      serialize: (serializer, expr2) => {
-        const args = operands(expr2);
-        if (args.length === 0) return "\\delta";
-        if (args.every((x) => symbol(x)))
-          return `\\delta_{${args.map((arg) => serializer.serialize(arg)).join("")}}`;
-        return `\\delta_{${args.map((arg) => serializer.serialize(arg)).join(", ")}}`;
-      },
-      parse: (parser) => {
-        const group = parser.parseGroup();
-        if (group === null) {
-          const token = parser.parseToken();
-          if (!token) return null;
-          return ["KroneckerDelta", token];
-        }
-        const seq = getSequence(group);
-        if (seq && seq.length <= 2) return ["KroneckerDelta", ...seq];
-        if (operator(group) === "InvisibleOperator")
-          return ["KroneckerDelta", ...operands(group)];
-        if (group !== null) return ["KroneckerDelta", group];
-        return null;
-      }
-    },
-    // Iverson brackets. Also called the "indicator function"
-    // Must have a single argument, a relational expression, i.e.
-    // `[ a = b ]` or `[ x \leq 0 ]`
-    // Otherwise, it gets rejected, it could be something else, like a list or
-    // tuple.
-    {
-      name: "Boole",
-      kind: "matchfix",
-      openTrigger: "[",
-      closeTrigger: "]",
-      // serialize: (serializer: Serializer, expr: MathJsonExpression) => {
-      //   const args = ops(expr);
-      //   return `[${serializer.serialize(arg)}]`;
-      // },
-      parse: (_parser, body) => {
-        const h = operator(body);
-        if (!h) return null;
-        if (!DEFINITIONS_INEQUALITIES.some((x) => x.name === h)) return null;
-        return ["Boole", body];
-      }
-    },
-    {
-      kind: "matchfix",
-      openTrigger: "\\llbracket",
-      closeTrigger: "\\rrbracket",
-      parse: (_parser, body) => {
-        const h = operator(body);
-        if (!h) return null;
-        if (!DEFINITIONS_INEQUALITIES.some((x) => x.name === h)) return null;
-        return ["Boole", body];
-      }
-    },
-    // Predicate application in First-Order Logic.
-    // ["Predicate", "P", "x", "y"] serializes to "P(x, y)"
-    {
-      name: "Predicate",
-      serialize: (serializer, expr2) => {
-        const args = operands(expr2);
-        if (args.length === 0) return "";
-        const pred = args[0];
-        const predStr = typeof pred === "string" ? pred : serializer.serialize(pred);
-        if (args.length === 1) return predStr;
-        const argStrs = args.slice(1).map((arg) => serializer.serialize(arg));
-        return `${predStr}(${argStrs.join(", ")})`;
+        return ["To", lhs, rhs];
       }
     }
   ];
-  function serializeQuantifier(quantifierSymbol) {
-    return (serializer, expr2) => {
-      const args = operands(expr2);
-      if (args.length === 0) return quantifierSymbol;
-      if (args.length === 1)
-        return `${quantifierSymbol} ${serializer.serialize(args[0])}`;
-      const boundVar = serializer.serialize(args[0]);
-      const body = serializer.serialize(args[1]);
-      return `${quantifierSymbol} ${boundVar}, ${body}`;
-    };
-  }
-  function tightBindingCondition(p, terminator) {
-    return p.peek === "\\to" || p.peek === "\\rightarrow" || p.peek === "\\implies" || p.peek === "\\Rightarrow" || p.peek === "\\iff" || p.peek === "\\Leftrightarrow" || p.peek === "\\land" || p.peek === "\\wedge" || p.peek === "\\lor" || p.peek === "\\vee" || (terminator.condition?.(p) ?? false);
-  }
-  function parseQuantifier(kind) {
-    return (parser, terminator) => {
-      const index = parser.index;
-      const useTightBinding = parser.options.quantifierScope !== "loose";
-      const symbol2 = parser.parseSymbol(terminator);
-      if (symbol2) {
-        parser.skipSpace();
-        if (parser.match(",") || parser.match("\\mid") || parser.match(".") || parser.match(":") || parser.match("\\colon")) {
-          const bodyTerminator = useTightBinding ? {
-            ...terminator,
-            condition: (p) => tightBindingCondition(p, terminator)
-          } : terminator;
-          parser.enterQuantifierScope();
-          const body2 = parser.parseExpression(bodyTerminator);
-          parser.exitQuantifierScope();
-          return [kind, symbol2, missingIfEmpty(body2)];
-        }
-        parser.enterQuantifierScope();
-        const body = parser.parseEnclosure();
-        parser.exitQuantifierScope();
-        if (body) return [kind, symbol2, missingIfEmpty(body)];
-      }
-      parser.index = index;
-      const condTerminator = {
-        ...terminator,
-        condition: (p) => p.peek === ":" || p.peek === "\\colon" || (terminator.condition?.(p) ?? false)
-      };
-      const condition = parser.parseExpression(condTerminator);
-      if (condition === null) return null;
-      parser.skipSpace();
-      if (parser.matchAny([",", "\\mid", ":", "\\colon"])) {
-        const bodyTerminator = useTightBinding ? {
-          ...terminator,
-          condition: (p) => tightBindingCondition(p, terminator)
-        } : terminator;
-        parser.enterQuantifierScope();
-        const body = parser.parseExpression(bodyTerminator);
-        parser.exitQuantifierScope();
-        return [kind, condition, missingIfEmpty(body)];
-      }
-      if (parser.match("(")) {
-        parser.enterQuantifierScope();
-        const body = parser.parseExpression(terminator);
-        parser.exitQuantifierScope();
-        if (!parser.match(")")) return null;
-        return [kind, condition, missingIfEmpty(body)];
-      }
-      return null;
-    };
-  }
 
   // src/compute-engine/latex-syntax/dictionary/definitions-sets.ts
   function parseIntervalBody(body, openLeft, openRight) {
@@ -16343,7 +16495,7 @@ var ComputeEngine = (() => {
   var FLAG_SEQUENCE = "\\p{RI}\\p{RI}";
   var TAG_MOD = `(?:[\\u{E0020}-\\u{E007E}]+\\u{E007F})`;
   var EMOJI_MOD = `(?:\\p{EMod}|${VS16}${KEYCAP}?|${TAG_MOD})`;
-  var EMOJI_NOT_SYMBOL = `(?:(?=\\P{XIDC})\\p{Emoji})`;
+  var EMOJI_NOT_SYMBOL = `(?:(?=\\P{XIDC})(?=[^\\x23\\x2a\\x30-\\x39])\\p{Emoji})`;
   var ZWJ_ELEMENT = `(?:${EMOJI_NOT_SYMBOL}${EMOJI_MOD}*|\\p{Emoji}${EMOJI_MOD}+|${FLAG_SEQUENCE})`;
   var POSSIBLE_EMOJI = `(?:${ZWJ_ELEMENT})(${ZWJ2}${ZWJ_ELEMENT})*`;
   var SOME_EMOJI = new RegExp(`(?:${POSSIBLE_EMOJI})+`, "u");
@@ -17052,7 +17204,9 @@ var ComputeEngine = (() => {
       }
       return c;
     }
-    return parser.nextToken();
+    const raw = parser.peek;
+    if (raw && /^[\p{XIDC}\p{M}]/u.test(raw)) return parser.nextToken();
+    return null;
   }
   function parseSymbolBody(parser) {
     let id = matchPrefixedSymbol(parser);
@@ -18342,6 +18496,29 @@ var ComputeEngine = (() => {
       this.index = start;
       return null;
     }
+    /**
+     * Speculatively check if any \text infix entry (e.g. "and", "or", "where")
+     * would match the upcoming tokens. This is used to prevent InvisibleOperator
+     * from consuming \text{keyword} as a text run when the keyword is actually
+     * an infix operator that was skipped due to precedence constraints.
+     *
+     * Returns true if any entry's parse function would succeed (non-null result).
+     * The parser index is always restored to its original position.
+     */
+    wouldMatchTextInfix(opDefs) {
+      const start = this.index;
+      for (const [def, n] of opDefs) {
+        if (def.kind !== "infix") continue;
+        this.index = start + n;
+        const result = def.parse(this, "Nothing", { minPrec: 0 });
+        if (result !== null) {
+          this.index = start;
+          return true;
+        }
+      }
+      this.index = start;
+      return false;
+    }
     /**
      * This returns an array of arguments (as in a function application),
      * or null if there is no match.
@@ -18967,6 +19144,7 @@ var ComputeEngine = (() => {
       if (isDelimiterCommand(this))
         return this.error("unexpected-delimiter", start);
       if (command[0] !== "\\") {
+        this.nextToken();
         return this.error(
           ["unexpected-token", { str: tokensToString(command) }],
           start
@@ -19095,25 +19273,28 @@ var ComputeEngine = (() => {
           if (result === null && until.minPrec <= INVISIBLE_OP_PRECEDENCE) {
             const opDefs = this.peekDefinitions("operator");
             if (opDefs.length === 0 || opDefs.every(([def]) => def.latexTrigger === "\\text")) {
-              const rhs = this.parseExpression({
-                ...until,
-                minPrec: INVISIBLE_OP_PRECEDENCE + 1
-              });
-              if (rhs !== null) {
-                if (operator(lhs) === "InvisibleOperator") {
-                  if (operator(rhs) === "InvisibleOperator")
-                    result = [
-                      "InvisibleOperator",
-                      ...operands(lhs),
-                      ...operands(rhs)
-                    ];
-                  else result = ["InvisibleOperator", ...operands(lhs), rhs];
-                } else if (operator(rhs) === "InvisibleOperator") {
-                  result = ["InvisibleOperator", lhs, ...operands(rhs)];
-                } else result = ["InvisibleOperator", lhs, rhs];
+              if (opDefs.length > 0 && this.wouldMatchTextInfix(opDefs)) {
               } else {
-                if (result === null) {
-                  result = this.options.parseUnexpectedToken?.(lhs, this) ?? null;
+                const rhs = this.parseExpression({
+                  ...until,
+                  minPrec: INVISIBLE_OP_PRECEDENCE + 1
+                });
+                if (rhs !== null) {
+                  if (operator(lhs) === "InvisibleOperator") {
+                    if (operator(rhs) === "InvisibleOperator")
+                      result = [
+                        "InvisibleOperator",
+                        ...operands(lhs),
+                        ...operands(rhs)
+                      ];
+                    else result = ["InvisibleOperator", ...operands(lhs), rhs];
+                  } else if (operator(rhs) === "InvisibleOperator") {
+                    result = ["InvisibleOperator", lhs, ...operands(rhs)];
+                  } else result = ["InvisibleOperator", lhs, rhs];
+                } else {
+                  if (result === null) {
+                    result = this.options.parseUnexpectedToken?.(lhs, this) ?? null;
+                  }
                 }
               }
             }
@@ -30578,8 +30759,7 @@ ${lines.join("\n")}`;
         broadcastable: true,
         idempotent: true,
         complexity: 1200,
-        signature: "(number) -> number",
-        type: ([x]) => x.type,
+        signature: "(number) -> real",
         sgn: ([x]) => {
           if (x.isSame(0)) return "zero";
           if (isNumber(x)) return "positive";
@@ -37938,6 +38118,10 @@ ${e.message}
         scoped: true,
         lazy: true,
         signature: "(expression, variable:symbol, variables:symbol+) -> expression",
+        type: ([body]) => {
+          if (body && body.type.matches("number")) return body.type;
+          return void 0;
+        },
         canonical: (ops, { engine: ce, scope }) => {
           if (isSymbol2(ops[0]) && ops[0].canonical.operatorDefinition) {
             const vars = ops.slice(1);
@@ -42509,6 +42693,18 @@ ${e.message}
       }
     }
     ops = flattenInvisibleOperator(ops);
+    if (ops.some((op) => isFunction2(op, "Text") || isString(op))) {
+      const runs = [];
+      for (const op of ops) {
+        if (isFunction2(op, "Text")) {
+          runs.push(...op.ops);
+        } else if (op.operator !== "HorizontalSpacing") {
+          runs.push(op.canonical);
+        }
+      }
+      return ce._fn("Text", runs);
+    }
+    ops = combineFunctionApplications(ce, ops);
     {
       const significant = ops.filter((x) => x.operator !== "HorizontalSpacing");
       if (significant.length === 2) {
@@ -42523,7 +42719,7 @@ ${e.message}
     }
     ops = flatten(ops);
     if (ops.every(
-      (x) => x.isValid && (x.type.isUnknown || x.type.matches("number") || x.isIndexedCollection && !isString(x))
+      (x) => x.isValid && (x.type.isUnknown || x.type.type === "any" || x.type.type === "expression" || x.type.matches("number") || x.isIndexedCollection && !isString(x))
     )) {
       return ce._fn("Multiply", ops);
     }
@@ -42538,6 +42734,40 @@ ${e.message}
     }
     return ys;
   }
+  function combineFunctionApplications(ce, ops) {
+    const result = [];
+    let i = 0;
+    while (i < ops.length) {
+      const op = ops[i];
+      if (i < ops.length - 1 && isSymbol2(op) && isFunction2(ops[i + 1], "Delimiter")) {
+        const symName = op.symbol;
+        const def = ce.lookupDefinition(symName);
+        const delim = ops[i + 1];
+        if (def && (isOperatorDef(def) || def.value?.type?.matches("function"))) {
+          let args = delim.op1 ? isFunction2(delim.op1, "Sequence") ? delim.op1.ops : [delim.op1] : [];
+          args = flatten(args);
+          result.push(ce.function(symName, args));
+          i += 2;
+          continue;
+        }
+        if (delim.op1 && isFunction2(delim.op1, "Sequence")) {
+          let args = delim.op1.ops;
+          args = flatten(args);
+          if (args.length > 1) {
+            if (!def) ce.declare(symName, "function");
+            else if (!isOperatorDef(def) && def.value?.type?.isUnknown)
+              op.canonical.infer("function");
+            result.push(ce.function(symName, args));
+            i += 2;
+            continue;
+          }
+        }
+      }
+      result.push(ops[i]);
+      i++;
+    }
+    return result;
+  }
   function asInteger(expr2) {
     if (isNumber(expr2)) {
       const n = expr2.re;
@@ -43541,7 +43771,21 @@ ${e.message}
       },
       Text: {
         description: "A sequence of strings, annotated expressions and other Text expressions",
-        signature: "(any*) -> expression"
+        signature: "(any*) -> string",
+        evaluate: (ops, { engine: ce }) => {
+          if (ops.length === 0) return ce.string("");
+          const parts = [];
+          for (const op of ops) {
+            const unwrapped = op.operator === "Annotated" ? op.op1 : op;
+            if (isString(unwrapped)) parts.push(unwrapped.string);
+            else {
+              const evaluated = unwrapped.evaluate();
+              if (isString(evaluated)) parts.push(evaluated.string);
+              else parts.push(evaluated.toString());
+            }
+          }
+          return ce.string(parts.join(""));
+        }
       }
     },
     {
@@ -43636,7 +43880,16 @@ ${e.message}
           if (!isSymbol2(symbol2)) {
             symbol2 = checkType(ce, lhs, "symbol");
           }
-          return ce._fn("Assign", [symbol2, args[1].canonical]);
+          const canonRhs = args[1].canonical;
+          const result = ce._fn("Assign", [symbol2, canonRhs]);
+          const symbolName2 = sym(symbol2);
+          if (symbolName2 && isFunction2(canonRhs, "Function")) {
+            if (!ce.lookupDefinition(symbolName2)) ce.symbol(symbolName2);
+            const def = ce.lookupDefinition(symbolName2);
+            if (def && isValueDef(def) && def.value.inferredType)
+              def.value.type = ce.type("function");
+          }
+          return result;
         },
         evaluate: ([op1, op2], { engine: ce }) => {
           if (isFunction2(op1, "Subscript") && sym(op1.op1)) {
@@ -43833,6 +44086,7 @@ ${e.message}
         description: "Simplify an expression.",
         lazy: true,
         signature: "(any) -> expression",
+        type: ([x]) => x?.type ?? void 0,
         canonical: (ops, { engine: ce }) => ce._fn("Simplify", checkArity(ce, ops, 1)),
         evaluate: ([x]) => x.simplify() ?? void 0
       },
@@ -54056,8 +54310,11 @@ Error in definition of "${name}"`,
         for (const local of locals) {
           for (const arg of args) {
             if (isFunction2(arg, "Assign") && isSymbol2(arg.ops[0], local)) {
-              if (_BaseCompiler.isComplexValued(arg.ops[1])) {
+              const rhs = arg.ops[1];
+              if (_BaseCompiler.isComplexValued(rhs)) {
                 typeHints[local] = isWGSL ? "vec2f" : "vec2";
+              } else if (_BaseCompiler.isIntegerValued(rhs)) {
+                typeHints[local] = isWGSL ? "i32" : "int";
               }
               break;
             }
@@ -54262,12 +54519,9 @@ Error in definition of "${name}"`,
     /**
      * Determine at compile time whether an expression produces a complex value.
      *
-     * Rules:
-     * - Numbers: complex if im !== 0
-     * - Symbols: ImaginaryUnit is complex; others use expr.isReal
-     *   (undefined is treated as real -- assume-real policy)
-     * - Functions: Abs, Arg, Re, Im always return real.
-     *   All others: complex if any operand is complex.
+     * Uses the expression's declared type (from operator signatures) when
+     * available. Falls back to operand inspection for functions whose
+     * return type is unknown.
      */
     static isComplexValued(expr2) {
       if (isNumber(expr2)) return expr2.im !== 0;
@@ -54278,13 +54532,24 @@ Error in definition of "${name}"`,
         return t.matches("complex") && !t.matches("real");
       }
       if (isFunction2(expr2)) {
-        const op = expr2.operator;
-        if (op === "Abs" || op === "Arg" || op === "Re" || op === "Im")
-          return false;
+        const t = expr2.type;
+        if (t.matches("complex") && !t.matches("real")) return true;
+        if (t.matches("real")) return false;
         return expr2.ops.some((arg) => _BaseCompiler.isComplexValued(arg));
       }
       return false;
     }
+    /** True if the expression is provably integer-typed. */
+    static isIntegerValued(expr2) {
+      if (isNumber(expr2)) return expr2.im === 0 && Number.isInteger(expr2.re);
+      const t = expr2.type;
+      return t ? t.matches("integer") : false;
+    }
+    /** True if the expression is provably non-negative (sign ≥ 0). */
+    static isNonNegative(expr2) {
+      if (isNumber(expr2)) return expr2.im === 0 && expr2.re >= 0;
+      return expr2.isNonNegative === true;
+    }
     /**
      * Generate a temporary variable name
      */
@@ -54538,14 +54803,27 @@ Error in definition of "${name}"`,
     } catch (e) {
       if (options?.fallback ?? true) {
         console.warn(
-          `Compilation fallback for "${expr2.operator}": ${e.message}`
+          `Compilation fallback for "${expr2.operator}" (target: ${options?.to ?? "javascript"}): ${e.message}`
         );
+        const ce = expr2.engine;
+        const fallbackRun = ((vars) => {
+          ce.pushScope();
+          try {
+            if (vars && typeof vars === "object") {
+              for (const [k, v] of Object.entries(vars))
+                ce.assign(k, v);
+            }
+            return expr2.evaluate().re;
+          } finally {
+            ce.popScope();
+          }
+        });
         return {
           target: options?.to ?? "javascript",
           success: false,
           code: "",
           calling: "expression",
-          run: applicableN1(expr2)
+          run: fallbackRun
         };
       }
       throw e;
@@ -59695,6 +59973,86 @@ Error in definition of "${name}"`,
     for (const symbol2 of Object.values(commonSymbols)) symbol2?.reset();
   }
 
+  // src/compute-engine/compilation/constant-folding.ts
+  function formatFloat(n) {
+    const str = n.toString();
+    if (!str.includes(".") && !str.includes("e") && !str.includes("E")) {
+      return `${str}.0`;
+    }
+    return str;
+  }
+  function tryGetConstant(expr2) {
+    if (!isNumber(expr2)) return void 0;
+    if (expr2.im !== 0) return void 0;
+    const re = expr2.re;
+    if (!isFinite(re)) return void 0;
+    return re;
+  }
+  var NUMERIC_LITERAL_RE = /^-?\d+(\.\d+)?$/;
+  function foldTerms(terms, identity, op) {
+    const identityValue = op === "+" ? 0 : 1;
+    let numericAcc = null;
+    const symbolic = [];
+    for (const term of terms) {
+      if (NUMERIC_LITERAL_RE.test(term)) {
+        const val = parseFloat(term);
+        if (op === "*" && val === 0) return "0.0";
+        if (numericAcc === null) {
+          numericAcc = val;
+        } else {
+          numericAcc = op === "+" ? numericAcc + val : numericAcc * val;
+        }
+      } else {
+        symbolic.push(term);
+      }
+    }
+    if (numericAcc !== null && numericAcc !== identityValue) {
+      symbolic.unshift(formatFloat(numericAcc));
+    }
+    if (symbolic.length === 0) {
+      if (numericAcc !== null) return formatFloat(numericAcc);
+      return identity;
+    }
+    if (symbolic.length === 1) return symbolic[0];
+    return symbolic.join(op === "+" ? " + " : " * ");
+  }
+  function tryGetComplexParts(expr2, compile3) {
+    if (isSymbol2(expr2, "ImaginaryUnit")) {
+      return { re: null, im: "1.0" };
+    }
+    if (isNumber(expr2) && expr2.im !== 0) {
+      const re = expr2.re;
+      const im = expr2.im;
+      return {
+        re: re !== 0 ? formatFloat(re) : null,
+        im: formatFloat(im)
+      };
+    }
+    if (isFunction2(expr2, "Multiply")) {
+      const ops = expr2.ops;
+      const iIndex = ops.findIndex(
+        (op) => isSymbol2(op, "ImaginaryUnit") || isNumber(op) && op.re === 0 && op.im !== 0
+      );
+      if (iIndex >= 0) {
+        const iFactor = ops[iIndex];
+        const iScale = isSymbol2(iFactor, "ImaginaryUnit") ? 1 : iFactor.im;
+        const remaining = ops.filter((_, idx) => idx !== iIndex);
+        if (remaining.length === 0) {
+          return { re: null, im: formatFloat(iScale) };
+        }
+        const compiledFactors = remaining.map((r) => compile3(r));
+        if (iScale !== 1)
+          compiledFactors.unshift(formatFloat(iScale));
+        const imCode = foldTerms(compiledFactors, "1.0", "*");
+        return { re: null, im: imCode };
+      }
+    }
+    if (BaseCompiler.isComplexValued(expr2)) {
+      return null;
+    }
+    return { re: compile3(expr2), im: null };
+  }
+
   // src/compute-engine/compilation/javascript-target.ts
   var JAVASCRIPT_OPERATORS = {
     Add: ["+", 11],
@@ -59718,12 +60076,21 @@ Error in definition of "${name}"`,
     Abs: (args, compile3) => {
       if (BaseCompiler.isComplexValued(args[0]))
         return `_SYS.cabs(${compile3(args[0])})`;
+      if (BaseCompiler.isNonNegative(args[0])) return compile3(args[0]);
       return `Math.abs(${compile3(args[0])})`;
     },
     Add: (args, compile3) => {
       if (args.length === 1) return compile3(args[0]);
       const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
-      if (!anyComplex) return `(${args.map((x) => compile3(x)).join(" + ")})`;
+      if (!anyComplex) {
+        const constants = args.map(tryGetConstant);
+        if (constants.every((c) => c !== void 0))
+          return String(constants.reduce((a, b) => a + b, 0));
+        const nonZero = args.filter((a) => tryGetConstant(a) !== 0);
+        if (nonZero.length === 0) return "0";
+        if (nonZero.length === 1) return compile3(nonZero[0]);
+        return `(${nonZero.map((x) => compile3(x)).join(" + ")})`;
+      }
       const parts = args.map((a) => {
         const code = compile3(a);
         return { code, isComplex: BaseCompiler.isComplexValued(a) };
@@ -59780,7 +60147,10 @@ Error in definition of "${name}"`,
       return `Math.atan(${compile3(args[0])})`;
     },
     Artanh: "Math.atanh",
-    Ceil: "Math.ceil",
+    Ceil: (args, compile3) => {
+      if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+      return `Math.ceil(${compile3(args[0])})`;
+    },
     Chop: "_SYS.chop",
     Cos: (args, compile3) => {
       if (BaseCompiler.isComplexValued(args[0]))
@@ -59823,7 +60193,10 @@ Error in definition of "${name}"`,
         return `_SYS.cexp(${compile3(args[0])})`;
       return `Math.exp(${compile3(args[0])})`;
     },
-    Floor: "Math.floor",
+    Floor: (args, compile3) => {
+      if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+      return `Math.floor(${compile3(args[0])})`;
+    },
     Fract: ([x], compile3) => {
       if (x === null) throw new Error("Fract: no argument");
       return BaseCompiler.inlineExpression("${x} - Math.floor(${x})", compile3(x));
@@ -59919,12 +60292,20 @@ Error in definition of "${name}"`,
       if (BaseCompiler.isComplexValued(base) || BaseCompiler.isComplexValued(exp3)) {
         return `_SYS.cpow(${compile3(base)}, ${compile3(exp3)})`;
       }
-      const expVal = exp3.re;
-      if (expVal === 0.5) return `Math.sqrt(${compile3(base)})`;
-      if (expVal === 1 / 3) return `Math.cbrt(${compile3(base)})`;
-      if (expVal === 1) return compile3(base);
-      if (expVal === -1) return `(1 / (${compile3(base)}))`;
-      if (expVal === -0.5) return `(1 / Math.sqrt(${compile3(base)}))`;
+      const bConst = tryGetConstant(base);
+      const eConst = tryGetConstant(exp3);
+      if (bConst !== void 0 && eConst !== void 0)
+        return String(Math.pow(bConst, eConst));
+      if (eConst === 0) return "1";
+      if (eConst === 1) return compile3(base);
+      if (eConst === 2 && (isSymbol2(base) || isNumber(base))) {
+        const code = compile3(base);
+        return `(${code} * ${code})`;
+      }
+      if (eConst === -1) return `(1 / (${compile3(base)}))`;
+      if (eConst === 0.5) return `Math.sqrt(${compile3(base)})`;
+      if (eConst === 1 / 3) return `Math.cbrt(${compile3(base)})`;
+      if (eConst === -0.5) return `(1 / Math.sqrt(${compile3(base)}))`;
       return `Math.pow(${compile3(base)}, ${compile3(exp3)})`;
     },
     Range: (args, compile3) => {
@@ -59961,16 +60342,29 @@ Error in definition of "${name}"`,
     Root: ([arg, exp3], compile3) => {
       if (arg === null) throw new Error("Root: no argument");
       if (exp3 === null) return `Math.sqrt(${compile3(arg)})`;
-      if (exp3?.re === 2) return `Math.sqrt(${compile3(arg)})`;
-      if (exp3?.re === 3) return `Math.cbrt(${compile3(arg)})`;
-      if (!isNaN(exp3?.re)) return `Math.pow(${compile3(arg)},  ${1 / exp3.re})`;
+      const aConst = tryGetConstant(arg);
+      const nConst = tryGetConstant(exp3);
+      if (aConst !== void 0 && nConst !== void 0 && nConst !== 0)
+        return String(Math.pow(aConst, 1 / nConst));
+      if (nConst === 2) return `Math.sqrt(${compile3(arg)})`;
+      if (nConst === 3) return `Math.cbrt(${compile3(arg)})`;
+      if (nConst !== void 0) return `Math.pow(${compile3(arg)}, ${1 / nConst})`;
       return `Math.pow(${compile3(arg)}, 1 / (${compile3(exp3)}))`;
     },
     Random: "Math.random",
-    Round: "Math.round",
+    Round: (args, compile3) => {
+      if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+      return `Math.round(${compile3(args[0])})`;
+    },
     Square: (args, compile3) => {
       const arg = args[0];
       if (arg === null) throw new Error("Square: no argument");
+      const c = tryGetConstant(arg);
+      if (c !== void 0) return String(c * c);
+      if (isSymbol2(arg)) {
+        const code = compile3(arg);
+        return `(${code} * ${code})`;
+      }
       return `Math.pow(${compile3(arg)}, 2)`;
     },
     Sec: (args, compile3) => {
@@ -60003,6 +60397,8 @@ Error in definition of "${name}"`,
     Sqrt: (args, compile3) => {
       if (BaseCompiler.isComplexValued(args[0]))
         return `_SYS.csqrt(${compile3(args[0])})`;
+      const c = tryGetConstant(args[0]);
+      if (c !== void 0) return String(Math.sqrt(c));
       return `Math.sqrt(${compile3(args[0])})`;
     },
     Tan: (args, compile3) => {
@@ -60019,9 +60415,14 @@ Error in definition of "${name}"`,
       if (a === null || b === null) throw new Error("Mod: missing argument");
       const ca = compile3(a);
       const cb = compile3(b);
+      if (BaseCompiler.isIntegerValued(a) && BaseCompiler.isIntegerValued(b) && BaseCompiler.isNonNegative(a))
+        return `(${ca} % ${cb})`;
       return `((${ca} % ${cb}) + ${cb}) % ${cb}`;
     },
-    Truncate: "Math.trunc",
+    Truncate: (args, compile3) => {
+      if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+      return `Math.trunc(${compile3(args[0])})`;
+    },
     Remainder: ([a, b], compile3) => {
       if (a === null || b === null)
         throw new Error("Remainder: missing argument");
@@ -60029,25 +60430,20 @@ Error in definition of "${name}"`,
         a
       )} / ${compile3(b)}))`;
     },
-    // Arithmetic operators handled as functions for completeness
-    Subtract: ([a, b], compile3) => {
-      if (a === null || b === null) throw new Error("Subtract: missing argument");
-      const ac = BaseCompiler.isComplexValued(a);
-      const bc = BaseCompiler.isComplexValued(b);
-      if (!ac && !bc) return `(${compile3(a)} - ${compile3(b)})`;
-      const ca = compile3(a);
-      const cb = compile3(b);
-      const reA = ac ? `(${ca}).re` : ca;
-      const imA = ac ? `(${ca}).im` : "0";
-      const reB = bc ? `(${cb}).re` : cb;
-      const imB = bc ? `(${cb}).im` : "0";
-      return `({ re: ${reA} - ${reB}, im: ${imA} - ${imB} })`;
-    },
+    // No Subtract function handler — Subtract canonicalizes to Add+Negate.
+    // The operator entry in JAVASCRIPT_OPERATORS handles any edge cases.
     Divide: ([a, b], compile3) => {
       if (a === null || b === null) throw new Error("Divide: missing argument");
       const ac = BaseCompiler.isComplexValued(a);
       const bc = BaseCompiler.isComplexValued(b);
-      if (!ac && !bc) return `(${compile3(a)} / ${compile3(b)})`;
+      if (!ac && !bc) {
+        const ca = tryGetConstant(a);
+        const cb = tryGetConstant(b);
+        if (ca !== void 0 && cb !== void 0 && cb !== 0)
+          return String(ca / cb);
+        if (cb === 1) return compile3(a);
+        return `(${compile3(a)} / ${compile3(b)})`;
+      }
       if (ac && bc) {
         return `(() => { const _a = ${compile3(a)}, _b = ${compile3(
           b
@@ -60064,13 +60460,26 @@ Error in definition of "${name}"`,
     },
     Negate: ([x], compile3) => {
       if (x === null) throw new Error("Negate: no argument");
-      if (!BaseCompiler.isComplexValued(x)) return `(-${compile3(x)})`;
+      if (!BaseCompiler.isComplexValued(x)) {
+        const c = tryGetConstant(x);
+        if (c !== void 0) return String(-c);
+        return `(-${compile3(x)})`;
+      }
       return `_SYS.cneg(${compile3(x)})`;
     },
     Multiply: (args, compile3) => {
       if (args.length === 1) return compile3(args[0]);
       const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
-      if (!anyComplex) return `(${args.map((x) => compile3(x)).join(" * ")})`;
+      if (!anyComplex) {
+        if (args.some((a) => tryGetConstant(a) === 0)) return "0";
+        const constants = args.map(tryGetConstant);
+        if (constants.every((c) => c !== void 0))
+          return String(constants.reduce((a, b) => a * b, 1));
+        const nonOne = args.filter((a) => tryGetConstant(a) !== 1);
+        if (nonOne.length === 0) return "1";
+        if (nonOne.length === 1) return compile3(nonOne[0]);
+        return `(${nonOne.map((x) => compile3(x)).join(" * ")})`;
+      }
       if (args.length === 2) {
         const ac = BaseCompiler.isComplexValued(args[0]);
         const bc = BaseCompiler.isComplexValued(args[1]);
@@ -60155,20 +60564,30 @@ Error in definition of "${name}"`,
     AiryAi: "_SYS.airyAi",
     AiryBi: "_SYS.airyBi",
     // Combinatorics
+    Mandelbrot: ([c, maxIter], compile3) => {
+      if (c === null || maxIter === null)
+        throw new Error("Mandelbrot: missing arguments");
+      return `_SYS.mandelbrot(${compile3(c)}, ${compile3(maxIter)})`;
+    },
+    Julia: ([z, c, maxIter], compile3) => {
+      if (z === null || c === null || maxIter === null)
+        throw new Error("Julia: missing arguments");
+      return `_SYS.julia(${compile3(z)}, ${compile3(c)}, ${compile3(maxIter)})`;
+    },
     Binomial: (args, compile3) => `_SYS.binomial(${compile3(args[0])}, ${compile3(args[1])})`,
     Fibonacci: "_SYS.fibonacci",
     // Complex-specific functions
-    Re: (args, compile3) => {
+    Real: (args, compile3) => {
       if (BaseCompiler.isComplexValued(args[0]))
         return `(${compile3(args[0])}).re`;
       return compile3(args[0]);
     },
-    Im: (args, compile3) => {
+    Imaginary: (args, compile3) => {
       if (BaseCompiler.isComplexValued(args[0]))
         return `(${compile3(args[0])}).im`;
       return "0";
     },
-    Arg: (args, compile3) => {
+    Argument: (args, compile3) => {
       if (BaseCompiler.isComplexValued(args[0]))
         return `_SYS.carg(${compile3(args[0])})`;
       return `(${compile3(args[0])} >= 0 ? 0 : Math.PI)`;
@@ -60504,6 +60923,41 @@ Error in definition of "${name}"`,
     sinc,
     fresnelS,
     fresnelC,
+    mandelbrot: (c, maxIter) => {
+      let zx = 0, zy = 0;
+      const cx = typeof c === "number" ? c : c.re;
+      const cy = typeof c === "number" ? 0 : c.im;
+      const n = Math.round(maxIter);
+      for (let i = 0; i < n; i++) {
+        const newZx = zx * zx - zy * zy + cx;
+        zy = 2 * zx * zy + cy;
+        zx = newZx;
+        const mag2 = zx * zx + zy * zy;
+        if (mag2 > 4) {
+          const smooth = (i - Math.log2(Math.log2(mag2)) + 4) / n;
+          return Math.max(0, Math.min(1, smooth));
+        }
+      }
+      return 1;
+    },
+    julia: (z, c, maxIter) => {
+      let zx = typeof z === "number" ? z : z.re;
+      let zy = typeof z === "number" ? 0 : z.im;
+      const cx = typeof c === "number" ? c : c.re;
+      const cy = typeof c === "number" ? 0 : c.im;
+      const n = Math.round(maxIter);
+      for (let i = 0; i < n; i++) {
+        const newZx = zx * zx - zy * zy + cx;
+        zy = 2 * zx * zy + cy;
+        zx = newZx;
+        const mag2 = zx * zx + zy * zy;
+        if (mag2 > 4) {
+          const smooth = (i - Math.log2(Math.log2(mag2)) + 4) / n;
+          return Math.max(0, Math.min(1, smooth));
+        }
+      }
+      return 1;
+    },
     binomial: choose,
     fibonacci,
     // Complex helpers
@@ -60849,6 +61303,7 @@ Error in definition of "${name}"`,
     Add: ["+", 11],
     Negate: ["-", 14],
     Subtract: ["-", 11],
+    // Subtract canonicalizes to Add+Negate; kept as fallback
     Multiply: ["*", 12],
     Divide: ["/", 13],
     Equal: ["==", 8],
@@ -60864,6 +61319,12 @@ Error in definition of "${name}"`,
   function gpuVec2(target) {
     return target?.language === "wgsl" ? "vec2f" : "vec2";
   }
+  function compileIntArg(expr2, compile3, target) {
+    const c = tryGetConstant(expr2);
+    if (c !== void 0 && Number.isInteger(c)) return c.toString();
+    const intCast = target?.language === "wgsl" ? "i32" : "int";
+    return `${intCast}(${compile3(expr2)})`;
+  }
   var GPU_UNROLL_LIMIT = 100;
   function compileGPUSumProduct(kind, args, _compile2, target) {
     if (!args[0]) throw new Error(`${kind}: no body`);
@@ -60926,88 +61387,113 @@ Error in definition of "${name}"`,
       if (args.length === 0) return "0.0";
       if (args.length === 1) return compile3(args[0]);
       const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
-      if (!anyComplex) return args.map((x) => compile3(x)).join(" + ");
-      const v2 = gpuVec2(target);
-      return args.map((a) => {
-        const code = compile3(a);
-        return BaseCompiler.isComplexValued(a) ? code : `${v2}(${code}, 0.0)`;
-      }).join(" + ");
-    },
-    Multiply: (args, compile3, _target) => {
-      if (args.length === 0) return "1.0";
-      if (args.length === 1) return compile3(args[0]);
-      const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
-      if (!anyComplex) return args.map((x) => compile3(x)).join(" * ");
-      let result = compile3(args[0]);
-      let resultIsComplex = BaseCompiler.isComplexValued(args[0]);
-      for (let i = 1; i < args.length; i++) {
-        const code = compile3(args[i]);
-        const argIsComplex = BaseCompiler.isComplexValued(args[i]);
-        if (!resultIsComplex && !argIsComplex) {
-          result = `(${result} * ${code})`;
-        } else if (resultIsComplex && !argIsComplex) {
-          result = `(${code} * ${result})`;
-        } else if (!resultIsComplex && argIsComplex) {
-          result = `(${result} * ${code})`;
-          resultIsComplex = true;
-        } else {
-          result = `_gpu_cmul(${result}, ${code})`;
-        }
+      if (!anyComplex) {
+        return foldTerms(
+          args.map((x) => compile3(x)),
+          "0.0",
+          "+"
+        );
       }
-      return result;
-    },
-    Subtract: (args, compile3, target) => {
-      if (args.length === 0) return "0.0";
+      const parts = args.map((a) => tryGetComplexParts(a, compile3));
+      if (parts.some((p) => p === null)) {
+        const v2 = gpuVec2(target);
+        return args.map((a) => {
+          const code = compile3(a);
+          return BaseCompiler.isComplexValued(a) ? code : `${v2}(${code}, 0.0)`;
+        }).join(" + ");
+      }
+      const reParts = [];
+      const imParts = [];
+      for (const p of parts) {
+        if (p.re !== null) reParts.push(p.re);
+        if (p.im !== null) imParts.push(p.im);
+      }
+      const reSum = foldTerms(reParts, "0.0", "+");
+      const imSum = foldTerms(imParts, "0.0", "+");
+      return `${gpuVec2(target)}(${reSum}, ${imSum})`;
+    },
+    Multiply: (args, compile3, target) => {
+      if (args.length === 0) return "1.0";
       if (args.length === 1) return compile3(args[0]);
       const anyComplex = args.some((a) => BaseCompiler.isComplexValued(a));
       if (!anyComplex) {
-        if (args.length === 2) return `${compile3(args[0])} - ${compile3(args[1])}`;
-        let result2 = compile3(args[0]);
-        for (let i = 1; i < args.length; i++) {
-          result2 = `${result2} - ${compile3(args[i])}`;
-        }
-        return result2;
-      }
-      const v2 = gpuVec2(target);
-      const promote = (a) => {
-        const code = compile3(a);
-        return BaseCompiler.isComplexValued(a) ? code : `${v2}(${code}, 0.0)`;
-      };
-      if (args.length === 2) return `${promote(args[0])} - ${promote(args[1])}`;
-      let result = promote(args[0]);
-      for (let i = 1; i < args.length; i++) {
-        result = `${result} - ${promote(args[i])}`;
+        return foldTerms(
+          args.map((x) => compile3(x)),
+          "1.0",
+          "*"
+        );
       }
+      const iIndex = args.findIndex(
+        (op) => isSymbol2(op, "ImaginaryUnit") || isNumber(op) && op.re === 0 && op.im !== 0
+      );
+      if (iIndex >= 0) {
+        const iFactor = args[iIndex];
+        const iScale = isSymbol2(iFactor, "ImaginaryUnit") ? 1 : iFactor.im;
+        const realFactors = args.filter((_, i) => i !== iIndex);
+        const v2 = gpuVec2(target);
+        if (realFactors.length === 0)
+          return `${v2}(0.0, ${formatFloat(iScale)})`;
+        const factors = realFactors.map((f) => compile3(f));
+        if (iScale !== 1) factors.unshift(formatFloat(iScale));
+        const imCode = foldTerms(factors, "1.0", "*");
+        return `${v2}(0.0, ${imCode})`;
+      }
+      const realCodes = [];
+      const complexCodes = [];
+      for (const a of args) {
+        if (BaseCompiler.isComplexValued(a)) complexCodes.push(compile3(a));
+        else realCodes.push(compile3(a));
+      }
+      const scalarCode = foldTerms(realCodes, "1.0", "*");
+      let result = complexCodes[0];
+      for (let i = 1; i < complexCodes.length; i++) {
+        result = `_gpu_cmul(${result}, ${complexCodes[i]})`;
+      }
+      if (scalarCode !== "1.0") result = `(${scalarCode} * ${result})`;
       return result;
     },
+    // No Subtract function handler — Subtract canonicalizes to Add+Negate.
+    // The operator entry in GPU_OPERATORS handles any edge cases.
     Divide: (args, compile3, target) => {
       if (args.length === 0) return "1.0";
       if (args.length === 1) return compile3(args[0]);
       const ac = BaseCompiler.isComplexValued(args[0]);
       const bc = args.length >= 2 && BaseCompiler.isComplexValued(args[1]);
       if (!ac && !bc) {
-        if (args.length === 2) return `${compile3(args[0])} / ${compile3(args[1])}`;
+        if (args.length === 2) {
+          const a = tryGetConstant(args[0]);
+          const b = tryGetConstant(args[1]);
+          if (a !== void 0 && b !== void 0 && b !== 0)
+            return formatFloat(a / b);
+          if (b === 1) return compile3(args[0]);
+          return `${compile3(args[0])} / ${compile3(args[1])}`;
+        }
         let result = compile3(args[0]);
-        for (let i = 1; i < args.length; i++) {
+        for (let i = 1; i < args.length; i++)
           result = `${result} / ${compile3(args[i])}`;
-        }
         return result;
       }
       if (ac && bc) return `_gpu_cdiv(${compile3(args[0])}, ${compile3(args[1])})`;
-      if (ac && !bc) {
-        return `(${compile3(args[0])} / ${compile3(args[1])})`;
-      }
+      if (ac && !bc) return `(${compile3(args[0])} / ${compile3(args[1])})`;
       const v2 = gpuVec2(target);
       return `_gpu_cdiv(${v2}(${compile3(args[0])}, 0.0), ${compile3(args[1])})`;
     },
-    Negate: ([x], compile3) => {
+    Negate: ([x], compile3, target) => {
       if (x === null) throw new Error("Negate: no argument");
+      const c = tryGetConstant(x);
+      if (c !== void 0) return formatFloat(-c);
+      if (isNumber(x) && x.im !== 0) {
+        return `${gpuVec2(target)}(${formatFloat(-x.re)}, ${formatFloat(-x.im)})`;
+      }
+      if (isSymbol2(x, "ImaginaryUnit"))
+        return `${gpuVec2(target)}(0.0, -1.0)`;
       return `(-${compile3(x)})`;
     },
     // Standard math functions with complex dispatch
     Abs: (args, compile3) => {
       if (BaseCompiler.isComplexValued(args[0]))
         return `length(${compile3(args[0])})`;
+      if (BaseCompiler.isNonNegative(args[0])) return compile3(args[0]);
       return `abs(${compile3(args[0])})`;
     },
     Arccos: (args, compile3) => {
@@ -61025,7 +61511,10 @@ Error in definition of "${name}"`,
         return `_gpu_catan(${compile3(args[0])})`;
       return `atan(${compile3(args[0])})`;
     },
-    Ceil: "ceil",
+    Ceil: (args, compile3) => {
+      if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+      return `ceil(${compile3(args[0])})`;
+    },
     Clamp: "clamp",
     Cos: (args, compile3) => {
       if (BaseCompiler.isComplexValued(args[0]))
@@ -61039,7 +61528,10 @@ Error in definition of "${name}"`,
       return `exp(${compile3(args[0])})`;
     },
     Exp2: "exp2",
-    Floor: "floor",
+    Floor: (args, compile3) => {
+      if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+      return `floor(${compile3(args[0])})`;
+    },
     Fract: "fract",
     Ln: (args, compile3) => {
       if (BaseCompiler.isComplexValued(args[0]))
@@ -61061,10 +61553,25 @@ Error in definition of "${name}"`,
         const eCode = BaseCompiler.isComplexValued(exp3) ? compile3(exp3) : `${v2}(${compile3(exp3)}, 0.0)`;
         return `_gpu_cpow(${bCode}, ${eCode})`;
       }
+      const bConst = tryGetConstant(base);
+      const eConst = tryGetConstant(exp3);
+      if (bConst !== void 0 && eConst !== void 0)
+        return formatFloat(Math.pow(bConst, eConst));
+      if (eConst === 0) return "1.0";
+      if (eConst === 1) return compile3(base);
+      if (eConst === 2 && (isSymbol2(base) || isNumber(base))) {
+        const code = compile3(base);
+        return `(${code} * ${code})`;
+      }
+      if (eConst === -1) return `(1.0 / ${compile3(base)})`;
+      if (eConst === 0.5) return `sqrt(${compile3(base)})`;
       return `pow(${compile3(base)}, ${compile3(exp3)})`;
     },
     Radians: "radians",
-    Round: "round",
+    Round: (args, compile3) => {
+      if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+      return `round(${compile3(args[0])})`;
+    },
     Sign: "sign",
     Sin: (args, compile3) => {
       if (BaseCompiler.isComplexValued(args[0]))
@@ -61075,6 +61582,8 @@ Error in definition of "${name}"`,
     Sqrt: (args, compile3) => {
       if (BaseCompiler.isComplexValued(args[0]))
         return `_gpu_csqrt(${compile3(args[0])})`;
+      const c = tryGetConstant(args[0]);
+      if (c !== void 0) return formatFloat(Math.sqrt(c));
       return `sqrt(${compile3(args[0])})`;
     },
     Step: "step",
@@ -61083,17 +61592,20 @@ Error in definition of "${name}"`,
         return `_gpu_ctan(${compile3(args[0])})`;
       return `tan(${compile3(args[0])})`;
     },
-    Truncate: "trunc",
+    Truncate: (args, compile3) => {
+      if (BaseCompiler.isIntegerValued(args[0])) return compile3(args[0]);
+      return `trunc(${compile3(args[0])})`;
+    },
     // Complex-specific functions
-    Re: (args, compile3) => {
+    Real: (args, compile3) => {
       if (BaseCompiler.isComplexValued(args[0])) return `(${compile3(args[0])}).x`;
       return compile3(args[0]);
     },
-    Im: (args, compile3) => {
+    Imaginary: (args, compile3) => {
       if (BaseCompiler.isComplexValued(args[0])) return `(${compile3(args[0])}).y`;
       return "0.0";
     },
-    Arg: (args, compile3) => {
+    Argument: (args, compile3) => {
       if (BaseCompiler.isComplexValued(args[0])) {
         const code = compile3(args[0]);
         return `atan(${code}.y, ${code}.x)`;
@@ -61308,13 +61820,20 @@ Error in definition of "${name}"`,
     },
     Square: ([x], compile3) => {
       if (x === null) throw new Error("Square: no argument");
-      const arg = compile3(x);
-      return `(${arg} * ${arg})`;
+      if (isSymbol2(x) || isNumber(x)) {
+        const arg = compile3(x);
+        return `(${arg} * ${arg})`;
+      }
+      return `pow(${compile3(x)}, 2.0)`;
     },
     Root: ([x, n], compile3) => {
       if (x === null) throw new Error("Root: no argument");
       if (n === null || n === void 0) return `sqrt(${compile3(x)})`;
-      if (n?.re === 2) return `sqrt(${compile3(x)})`;
+      const nConst = tryGetConstant(n);
+      if (nConst === 2) return `sqrt(${compile3(x)})`;
+      const xConst = tryGetConstant(x);
+      if (xConst !== void 0 && nConst !== void 0)
+        return formatFloat(Math.pow(xConst, 1 / nConst));
       return `pow(${compile3(x)}, 1.0 / ${compile3(n)})`;
     },
     // Color functions (pure-math, GPU-compilable)
@@ -61356,18 +61875,14 @@ Error in definition of "${name}"`,
     Mandelbrot: ([c, maxIter], compile3, target) => {
       if (c === null || maxIter === null)
         throw new Error("Mandelbrot: missing arguments");
-      const intCast = target?.language === "wgsl" ? "i32" : "int";
-      return `_fractal_mandelbrot(${compile3(c)}, ${intCast}(${compile3(
-        maxIter
-      )}))`;
+      const iterCode = compileIntArg(maxIter, compile3, target);
+      return `_fractal_mandelbrot(${compile3(c)}, ${iterCode})`;
     },
     Julia: ([z, c, maxIter], compile3, target) => {
       if (z === null || c === null || maxIter === null)
         throw new Error("Julia: missing arguments");
-      const intCast = target?.language === "wgsl" ? "i32" : "int";
-      return `_fractal_julia(${compile3(z)}, ${compile3(c)}, ${intCast}(${compile3(
-        maxIter
-      )}))`;
+      const iterCode = compileIntArg(maxIter, compile3, target);
+      return `_fractal_julia(${compile3(z)}, ${compile3(c)}, ${iterCode})`;
     },
     // Vector/Matrix operations
     Cross: "cross",
@@ -63999,6 +64514,7 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     Add: ["_IA.add", 20],
     Negate: ["_IA.negate", 20],
     Subtract: ["_IA.sub", 20],
+    // Subtract canonicalizes to Add+Negate; kept as fallback
     Multiply: ["_IA.mul", 20],
     Divide: ["_IA.div", 20],
     // Comparisons return BoolInterval
@@ -64023,17 +64539,7 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
       }
       return result;
     },
-    Subtract: (args, compile3) => {
-      if (args.length === 0) return "_IA.point(0)";
-      if (args.length === 1) return `_IA.negate(${compile3(args[0])})`;
-      if (args.length === 2)
-        return `_IA.sub(${compile3(args[0])}, ${compile3(args[1])})`;
-      let result = compile3(args[0]);
-      for (let i = 1; i < args.length; i++) {
-        result = `_IA.sub(${result}, ${compile3(args[i])})`;
-      }
-      return result;
-    },
+    // No Subtract handler — canonicalizes to Add+Negate before compilation.
     Multiply: (args, compile3) => {
       if (args.length === 0) return "_IA.point(1)";
       if (args.length === 1) return compile3(args[0]);
@@ -64969,6 +65475,7 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
     Negate: ["-", 14],
     // Unary operator
     Subtract: ["-", 11],
+    // Subtract canonicalizes to Add+Negate; kept as fallback
     Multiply: ["*", 12],
     Divide: ["/", 13],
     Power: ["**", 15],
@@ -64996,16 +65503,7 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
       if (args.length === 1) return compile3(args[0]);
       return args.map((x) => compile3(x)).join(" * ");
     },
-    Subtract: (args, compile3) => {
-      if (args.length === 0) return "0";
-      if (args.length === 1) return compile3(args[0]);
-      if (args.length === 2) return `${compile3(args[0])} - ${compile3(args[1])}`;
-      let result = compile3(args[0]);
-      for (let i = 1; i < args.length; i++) {
-        result = `${result} - ${compile3(args[i])}`;
-      }
-      return result;
-    },
+    // No Subtract handler — canonicalizes to Add+Negate before compilation.
     Divide: (args, compile3) => {
       if (args.length === 0) return "1";
       if (args.length === 1) return compile3(args[0]);
@@ -67437,7 +67935,9 @@ ${code}`;
         }
         return new ExactNumericValue(value, makeNumericValue);
       }
-      throw Error("Unexpected value");
+      throw Error(
+        `Unexpected value: ${typeof value === "object" ? JSON.stringify(value) : String(value)}`
+      );
     }
     /**
      * The cost function is used to determine the "cost" of an expression. For example, when simplifying an expression, the simplification that results in the lowest cost is chosen.
@@ -67908,14 +68408,14 @@ ${code}`;
   _setDefaultEngineFactory(() => new ComputeEngine());
 
   // src/compute-engine.ts
-  var version = "0.55.0";
+  var version = "0.55.3";
   ComputeEngine._latexSyntaxFactory = () => new LatexSyntax();
   _setDefaultEngineFactory(
     () => new ComputeEngine({ latexSyntax: new LatexSyntax() })
   );
   globalThis[/* @__PURE__ */ Symbol.for("io.cortexjs.compute-engine")] = {
     ComputeEngine: ComputeEngine.prototype.constructor,
-    version: "0.55.0"
+    version: "0.55.3"
   };
   return __toCommonJS(compute_engine_exports);
 })();