@cortex-js/compute-engine 0.55.0 → 0.55.2

package/dist/core.umd.cjs

@@ -1,4 +1,4 @@
-/** ComputeEngineCore 0.55.0 */
+/** ComputeEngineCore 0.55.2 */
     (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.ComputeEngineCore = {}));})(this, (function (exports) { 'use strict';
 var ComputeEngineCore = (() => {
   var __defProp = Object.defineProperty;
@@ -9573,6 +9573,452 @@ var ComputeEngineCore = (() => {
     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;
@@ -10183,6 +10629,120 @@ var ComputeEngineCore = (() => {
       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",
@@ -10298,6 +10858,39 @@ var ComputeEngineCore = (() => {
         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"],
@@ -10688,9 +11281,10 @@ var ComputeEngineCore = (() => {
       } 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";
@@ -10708,6 +11302,7 @@ var ComputeEngineCore = (() => {
         const expr2 = parser.parseExpression() ?? "Nothing";
         parser.skipSpace();
         if (parser.match("<$>")) {
+          flush();
           runs.push(expr2);
         } else {
           text += "$";
@@ -10718,6 +11313,7 @@ var ComputeEngineCore = (() => {
         const expr2 = parser.parseExpression() ?? "Nothing";
         parser.skipSpace();
         if (parser.match("<$$>")) {
+          flush();
           runs.push(expr2);
         } else {
           text += "$$";
@@ -11068,14 +11664,20 @@ var ComputeEngineCore = (() => {
     }
     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>")) {
@@ -11084,10 +11686,6 @@ var ComputeEngineCore = (() => {
       parser.index = start;
       return false;
     }
-    if (text !== keyword) {
-      parser.index = start;
-      return false;
-    }
     return true;
   }
   function matchKeyword(parser, keyword) {
@@ -11365,452 +11963,6 @@ var ComputeEngineCore = (() => {
     }
   ];
 
-  // 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-sets.ts
   function parseIntervalBody(body, openLeft, openRight) {
     if (isEmptySequence(body)) return null;
@@ -16315,7 +16467,7 @@ var ComputeEngineCore = (() => {
   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");
@@ -17024,7 +17176,9 @@ var ComputeEngineCore = (() => {
       }
       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);
@@ -18314,6 +18468,29 @@ var ComputeEngineCore = (() => {
       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.
@@ -18939,6 +19116,7 @@ var ComputeEngineCore = (() => {
       if (isDelimiterCommand(this))
         return this.error("unexpected-delimiter", start);
       if (command[0] !== "\\") {
+        this.nextToken();
         return this.error(
           ["unexpected-token", { str: tokensToString(command) }],
           start
@@ -19067,25 +19245,28 @@ var ComputeEngineCore = (() => {
           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;
+                  }
                 }
               }
             }
@@ -37910,6 +38091,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);
@@ -42481,6 +42666,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) {
@@ -42495,7 +42692,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);
     }
@@ -42510,6 +42707,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;
@@ -43513,7 +43744,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(""));
+        }
       }
     },
     {
@@ -43608,7 +43853,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)) {
@@ -43805,6 +44059,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
       },
@@ -67450,7 +67705,7 @@ ${workgroupAttr}fn main(${paramStr})${returnStr} {
   _setDefaultEngineFactory(() => new ComputeEngine());
 
   // src/core.ts
-  var version = "0.55.0";
+  var version = "0.55.2";
   return __toCommonJS(core_exports);
 })();
 /*! Bundled license information: