@cortex-js/compute-engine 0.57.0 → 0.59.0

package/dist/latex-syntax.umd.cjs

@@ -1,4 +1,4 @@
-/** LatexSyntax 0.57.0 */
+/** LatexSyntax 0.59.0 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.LatexSyntax = {}));})(this, (function (exports) { 'use strict';
 var LatexSyntax = (() => {
   var __defProp = Object.defineProperty;
@@ -136,12 +136,14 @@ var LatexSyntax = (() => {
     if (expr === null) return null;
     if (isDictionaryObject(expr)) return expr;
     const kv = keyValuePair(expr);
-    if (kv) return { [kv[0]]: kv[1] };
+    if (kv)
+      return {
+        dict: { [kv[0]]: expressionToDictionaryValue(kv[1]) ?? "Nothing" }
+      };
     if (operator(expr) === "Dictionary") {
       const dict = {};
-      const ops = operands(expr);
-      for (let i = 1; i < nops(expr); i++) {
-        const kv2 = keyValuePair(ops[i]);
+      for (const op of operands(expr)) {
+        const kv2 = keyValuePair(op);
         if (kv2) {
           dict[kv2[0]] = expressionToDictionaryValue(kv2[1]) ?? "Nothing";
         }
@@ -480,11 +482,27 @@ var LatexSyntax = (() => {
     "\u208B": "-"
     // ₋
   };
+  var STICKY_REGEX_CACHE = /* @__PURE__ */ new Map();
+  function stickyRegex(regEx) {
+    let result = STICKY_REGEX_CACHE.get(regEx.source);
+    if (!result) {
+      const source = regEx.source.startsWith("^") ? regEx.source.slice(1) : regEx.source;
+      result = new RegExp(source, "y");
+      STICKY_REGEX_CACHE.set(regEx.source, result);
+    }
+    return result;
+  }
   var Tokenizer = class {
     s;
     pos;
+    /** The input as a plain string (joined graphemes), used by `match()` */
+    joined;
+    /** For grapheme-array inputs: code-unit offset of each grapheme in
+     * `joined` (length `s.length + 1`, last entry is `joined.length`) */
+    offsets = null;
     obeyspaces = false;
     constructor(s) {
+      s = s.normalize("NFC");
       s = s.replace(/[\u200E\u200F\u2066-\u2069\u202A-\u202E]/g, "");
       s = s.replace(/\u2212/g, "-");
       s = s.replace(/[⁰¹²³⁴⁵⁶⁷⁸⁹⁻ⁱⁿ]+/g, (m) => {
@@ -497,6 +515,19 @@ var LatexSyntax = (() => {
       });
       this.s = splitGraphemes(s);
       this.pos = 0;
+      if (typeof this.s === "string") {
+        this.joined = this.s;
+      } else {
+        this.joined = this.s.join("");
+        const offsets = new Array(this.s.length + 1);
+        let offset = 0;
+        for (let i = 0; i < this.s.length; i++) {
+          offsets[i] = offset;
+          offset += this.s[i].length;
+        }
+        offsets[this.s.length] = offset;
+        this.offsets = offsets;
+      }
     }
     /**
      * @return True if we reached the end of the stream
@@ -520,12 +551,13 @@ var LatexSyntax = (() => {
      * Return the next substring matching regEx and advance.
      */
     match(regEx) {
-      let execResult;
+      const re = stickyRegex(regEx);
       if (typeof this.s === "string") {
-        execResult = regEx.exec(this.s.slice(this.pos));
+        re.lastIndex = this.pos;
       } else {
-        execResult = regEx.exec(this.s.slice(this.pos).join(""));
+        re.lastIndex = this.offsets[this.pos < this.s.length ? this.pos : this.s.length];
       }
+      const execResult = re.exec(this.joined);
       if (execResult?.[0]) {
         this.pos += execResult[0].length;
         return execResult[0];
@@ -632,25 +664,13 @@ var LatexSyntax = (() => {
         }
       }
     } else if (token === "\\csname") {
-      while (lex.peek() === "<space>") {
-        lex.next();
-      }
       let command = "";
       let done = false;
       let tokens = [];
       do {
         if (tokens.length === 0) {
-          if (/^#[0-9?]$/.test(lex.peek())) {
-            const param = lex.get().slice(1);
-            tokens = tokenize(
-              args?.[param] ?? args?.["?"] ?? "\\placeholder{}",
-              args
-            );
-            token = tokens[0];
-          } else {
-            token = lex.next();
-            tokens = token ? [token] : [];
-          }
+          token = lex.next();
+          tokens = token ? [token] : [];
         }
         done = tokens.length === 0;
         if (!done && token === "\\endcsname") {
@@ -723,7 +743,7 @@ var LatexSyntax = (() => {
     if (Array.isArray(tokens)) {
       for (const item of tokens) {
         if (Array.isArray(item)) {
-          flat = [...flat, ...item];
+          for (const token of item) flat.push(token);
         } else {
           flat.push(item);
         }
@@ -1208,172 +1228,23 @@ var LatexSyntax = (() => {
     "error",
     ...EXPRESSION_TYPES
   ];
+  var NUMERIC_TYPES_SET = new Set(
+    NUMERIC_TYPES
+  );
+  var COLLECTION_TYPES_SET = new Set(
+    COLLECTION_TYPES
+  );
+  var SCALAR_TYPES_SET = new Set(
+    SCALAR_TYPES
+  );
+  var PRIMITIVE_TYPES_SET = new Set(
+    PRIMITIVE_TYPES
+  );
   function isValidType(t) {
-    if (typeof t === "string")
-      return PRIMITIVE_TYPES.includes(t);
+    if (typeof t === "string") return PRIMITIVE_TYPES_SET.has(t);
     if (typeof t !== "object") return false;
     if (!("kind" in t)) return false;
-    return t.kind === "signature" || t.kind === "union" || t.kind === "intersection" || t.kind === "negation" || t.kind === "tuple" || t.kind === "list" || t.kind === "record" || t.kind === "dictionary" || t.kind === "set" || t.kind === "function" || t.kind === "collection" || t.kind === "indexed_collection" || t.kind === "reference";
-  }
-
-  // src/common/type/serialize.ts
-  var NEGATION_PRECEDENCE = 3;
-  var UNION_PRECEDENCE = 1;
-  var INTERSECTION_PRECEDENCE = 2;
-  var LIST_PRECEDENCE = 4;
-  var RECORD_PRECEDENCE = 5;
-  var DICTIONARY_PRECEDENCE = 6;
-  var SET_PRECEDENCE = 7;
-  var COLLECTION_PRECEDENCE = 8;
-  var TUPLE_PRECEDENCE = 9;
-  var SIGNATURE_PRECEDENCE = 10;
-  var VALUE_PRECEDENCE = 11;
-  function typeToString(type, precedence = 0) {
-    if (typeof type === "string") return type;
-    let result = "";
-    switch (type.kind) {
-      case "value":
-        if (typeof type.value === "string") result = `"${type.value}"`;
-        else if (typeof type.value === "boolean")
-          result = type.value ? "true" : "false";
-        else result = type.value.toString();
-        break;
-      case "reference":
-        result = type.name;
-        break;
-      case "negation":
-        result = `!${typeToString(type.type, NEGATION_PRECEDENCE)}`;
-        break;
-      case "union":
-        result = type.types.map((t) => typeToString(t, UNION_PRECEDENCE)).join(" | ");
-        break;
-      case "intersection":
-        result = type.types.map((t) => typeToString(t, INTERSECTION_PRECEDENCE)).join(" & ");
-        break;
-      case "expression":
-        result = `expression<${symbolName(type.operator)}>`;
-        break;
-      case "symbol":
-        result = `symbol<${symbolName(type.name)}>`;
-        break;
-      case "numeric":
-        if (Number.isFinite(type.lower) && Number.isFinite(type.upper)) {
-          result = `${type.type}<${type.lower}..${type.upper}>`;
-        } else if (Number.isFinite(type.lower)) {
-          result = `${type.type}<${type.lower}..>`;
-        } else if (Number.isFinite(type.upper)) {
-          result = `${type.type}<..${type.upper}>`;
-        } else {
-          result = `${type.type}`;
-        }
-        break;
-      case "list":
-        if (type.dimensions && typeof type.elements === "string" && NUMERIC_TYPES.includes(type.elements)) {
-          if (type.dimensions === void 0) {
-            if (type.elements === "number") result = "tensor";
-          } else if (type.dimensions.length === 1) {
-            if (type.elements === "number") {
-              if (type.dimensions[0] < 0) result = "vector";
-              else result = `vector<${type.dimensions[0]}>`;
-            } else {
-              if (type.dimensions[0] < 0)
-                result = `vector<${typeToString(type.elements)}>`;
-              else
-                result = `vector<${typeToString(type.elements)}^${type.dimensions[0]}>`;
-            }
-          } else if (type.dimensions.length === 2) {
-            const dims = type.dimensions;
-            if (type.elements === "number") {
-              if (dims[0] < 0 && dims[1] < 0) result = "matrix";
-              else result = `matrix<${dims[0]}x${dims[1]}>`;
-            } else {
-              if (dims[0] < 0 && dims[1] < 0)
-                result = `matrix<${typeToString(type.elements)}>`;
-              else
-                result = `matrix<${typeToString(type.elements)}^(${dims[0]}x${dims[1]})>`;
-            }
-          }
-        }
-        if (!result) {
-          const dimensions = type.dimensions ? type.dimensions.length === 1 ? `^${type.dimensions[0].toString()}` : `^(${type.dimensions.join("x")})` : "";
-          result = `list<${typeToString(type.elements)}${dimensions}>`;
-        }
-        break;
-      case "record":
-        const elements = Object.entries(type.elements).map(([key, value]) => `${key}: ${typeToString(value)}`).join(", ");
-        result = `record<${elements}>`;
-        break;
-      case "dictionary":
-        result = `dictionary<${typeToString(type.values)}>`;
-        break;
-      case "set":
-        result = `set<${typeToString(type.elements)}>`;
-        break;
-      case "collection":
-        result = `collection<${typeToString(type.elements)}>`;
-        break;
-      case "indexed_collection":
-        result = `indexed_collection<${typeToString(type.elements)}>`;
-        break;
-      case "tuple":
-        if (type.elements.length === 0) result = "tuple";
-        else if (type.elements.length === 1) {
-          const [el] = type.elements;
-          result = `tuple<${namedElement(el)}>`;
-        } else {
-          result = "tuple<" + type.elements.map((el) => namedElement(el)).join(", ") + ">";
-        }
-        break;
-      case "signature":
-        const args = type.args ? type.args.map((arg) => namedElement(arg)).join(", ") : "";
-        const optArgs = type.optArgs ? type.optArgs.map((arg) => namedElement(arg) + "?").join(", ") : "";
-        const varArg = type.variadicArg ? type.variadicMin === 0 ? `${namedElement(type.variadicArg)}*` : `${namedElement(type.variadicArg)}+` : "";
-        const argsList = [args, optArgs, varArg].filter((s) => s).join(", ");
-        result = `(${argsList}) -> ${typeToString(type.result)}`;
-        break;
-      default:
-        result = "error";
-    }
-    if (precedence > 0 && precedence > getPrecedence(type.kind))
-      return `(${result})`;
-    return result;
-  }
-  function namedElement(el) {
-    if (el.name) return `${el.name}: ${typeToString(el.type)}`;
-    return typeToString(el.type);
-  }
-  function symbolName(name) {
-    if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) return name;
-    return `\`${name}\``;
-  }
-  function getPrecedence(kind) {
-    switch (kind) {
-      case "negation":
-        return NEGATION_PRECEDENCE;
-      case "union":
-        return UNION_PRECEDENCE;
-      case "intersection":
-        return INTERSECTION_PRECEDENCE;
-      case "list":
-        return LIST_PRECEDENCE;
-      case "record":
-        return RECORD_PRECEDENCE;
-      case "dictionary":
-        return DICTIONARY_PRECEDENCE;
-      case "set":
-        return SET_PRECEDENCE;
-      case "collection":
-      case "indexed_collection":
-        return COLLECTION_PRECEDENCE;
-      case "tuple":
-        return TUPLE_PRECEDENCE;
-      case "signature":
-        return SIGNATURE_PRECEDENCE;
-      case "value":
-        return VALUE_PRECEDENCE;
-      default:
-        return 0;
-    }
+    return t.kind === "signature" || t.kind === "union" || t.kind === "intersection" || t.kind === "negation" || t.kind === "value" || t.kind === "tuple" || t.kind === "list" || t.kind === "record" || t.kind === "dictionary" || t.kind === "set" || t.kind === "symbol" || t.kind === "expression" || t.kind === "numeric" || t.kind === "collection" || t.kind === "indexed_collection" || t.kind === "reference";
   }
 
   // src/common/type/lexer.ts
@@ -2083,19 +1954,13 @@ var LatexSyntax = (() => {
       );
       let dimensions;
       if (this.match("<")) {
-        dimensions = this.parseDimensionWithX();
-        if (!dimensions) {
-          dimensions = this.parseDimensions();
-        }
+        dimensions = this.parseDimensions();
         if (!dimensions) {
           const type = this.parseUnionType();
           if (type) {
             elementType = type;
             if (this.match("^")) {
-              dimensions = this.parseDimensionWithX();
-              if (!dimensions) {
-                dimensions = this.parseDimensions();
-              }
+              dimensions = this.parseCaretDimensions();
             }
           }
         }
@@ -2136,19 +2001,13 @@ var LatexSyntax = (() => {
       );
       let dimensions;
       if (this.match("<")) {
-        dimensions = this.parseDimensionWithX();
-        if (!dimensions) {
-          dimensions = this.parseDimensions();
-        }
+        dimensions = this.parseDimensions();
         if (!dimensions) {
           const type = this.parseUnionType();
           if (type) {
             elementType = type;
             if (this.match("^")) {
-              dimensions = this.parseDimensionWithX();
-              if (!dimensions) {
-                dimensions = this.parseDimensions();
-              }
+              dimensions = this.parseCaretDimensions();
             }
           }
         }
@@ -2179,16 +2038,30 @@ var LatexSyntax = (() => {
       return this.createNode("tensor", { elementType });
     }
     parseDimensions() {
-      const dimensions = [];
       const firstDim = this.parseDimension();
       if (!firstDim) return void 0;
-      dimensions.push(firstDim);
-      while (this.match("x")) {
-        const dim = this.parseDimension();
-        if (!dim) {
-          this.error("Expected dimension after x");
+      const dimensions = [firstDim];
+      for (; ; ) {
+        const tok = this.current;
+        if (tok.type === "IDENTIFIER" && /^(x\d+)+$/.test(tok.value)) {
+          this.advance();
+          for (const m of tok.value.match(/x(\d+)/g))
+            dimensions.push(
+              this.createNode("dimension", {
+                size: parseInt(m.slice(1))
+              })
+            );
+        } else if (tok.type === "IDENTIFIER" && tok.value === "x") {
+          const next = this.lexer.peekToken();
+          if (next.type !== "NUMBER_LITERAL" && next.type !== "?")
+            this.error(
+              "Expected a positive integer literal or `?` after x. For example: `2x3` or `2x?`"
+            );
+          this.advance();
+          dimensions.push(this.parseDimension());
+        } else {
+          break;
         }
-        dimensions.push(dim);
       }
       return dimensions;
     }
@@ -2202,35 +2075,11 @@ var LatexSyntax = (() => {
       }
       return void 0;
     }
-    parseDimensionWithX() {
-      if (this.current.type === "NUMBER_LITERAL") {
-        const dimensions = [];
-        const firstDim = parseInt(this.advance().value);
-        dimensions.push(
-          this.createNode("dimension", { size: firstDim })
-        );
-        if (this.current.type === "IDENTIFIER" && this.current.value.startsWith("x")) {
-          const dimString = this.current.value;
-          const matches = dimString.match(/x(\d+)/g);
-          if (matches && matches.join("") === dimString) {
-            this.advance();
-            for (const match of matches) {
-              const dimValue = parseInt(match.substring(1));
-              dimensions.push(
-                this.createNode("dimension", { size: dimValue })
-              );
-            }
-          } else if (dimString === "x" || dimString.startsWith("x")) {
-            this.error(
-              "Expected a positive integer literal or `?` after x. For example: `2x3` or `2x?`"
-            );
-          }
-        }
-        if (dimensions.length > 1) {
-          return dimensions;
-        }
-      }
-      return void 0;
+    parseCaretDimensions() {
+      const paren = this.match("(");
+      const dimensions = this.parseDimensions();
+      if (paren) this.expect(")");
+      return dimensions;
     }
     parseTupleType() {
       if (this.current.type === "IDENTIFIER" && this.current.value === "tuple") {
@@ -2415,6 +2264,18 @@ var LatexSyntax = (() => {
             this.expect("..");
             const upperBound = this.parseValue();
             this.expect(">");
+            const lower = lowerBound?.value ?? -Infinity;
+            const upper = upperBound?.value ?? Infinity;
+            if (Number.isNaN(lower) || Number.isNaN(upper))
+              this.error(
+                "Invalid numeric type",
+                "Lower and upper bounds must be valid numbers"
+              );
+            if (lower > upper)
+              this.error(
+                `Invalid range: ${lower}..${upper}`,
+                "The lower bound must be less than the upper bound"
+              );
             return this.createNode("numeric", {
               baseType,
               lowerBound,
@@ -2429,7 +2290,7 @@ var LatexSyntax = (() => {
     parsePrimitiveType() {
       if (this.current.type === "IDENTIFIER") {
         const name = this.current.value;
-        if (PRIMITIVE_TYPES.includes(name)) {
+        if (PRIMITIVE_TYPES_SET.has(name)) {
           this.advance();
           return this.createNode("primitive", { name });
         }
@@ -2763,14 +2624,32 @@ var LatexSyntax = (() => {
   }
 
   // src/common/type/parse.ts
+  var TYPE_CACHE = /* @__PURE__ */ new Map();
+  var TYPE_CACHE_MAX_SIZE = 2048;
+  function deepFreeze(obj) {
+    if (obj === null || typeof obj !== "object") return obj;
+    if (Object.isFrozen(obj)) return obj;
+    Object.freeze(obj);
+    for (const value of Object.values(obj)) deepFreeze(value);
+    return obj;
+  }
   function parseType(s, typeResolver) {
     if (s === void 0) return void 0;
     if (isValidType(s)) return s;
     if (typeof s !== "string") return void 0;
+    const cacheable = typeResolver === void 0;
+    if (cacheable) {
+      const cached = TYPE_CACHE.get(s);
+      if (cached !== void 0) return cached;
+    }
     try {
       const parser = new Parser(s, { typeResolver });
       const ast = parser.parseType();
       const type = buildTypeFromAST(ast, typeResolver);
+      if (cacheable) {
+        if (TYPE_CACHE.size >= TYPE_CACHE_MAX_SIZE) TYPE_CACHE.clear();
+        TYPE_CACHE.set(s, deepFreeze(type));
+      }
       return type;
     } catch (error) {
       throw new Error(
@@ -2845,19 +2724,36 @@ var LatexSyntax = (() => {
     color: [],
     expression: EXPRESSION_TYPES
   };
+  var PRIMITIVE_SUBTYPES_CLOSURE = (() => {
+    const closure = {};
+    const closeOver = (t) => {
+      if (closure[t]) return closure[t];
+      const result = /* @__PURE__ */ new Set([t]);
+      closure[t] = result;
+      for (const sub of PRIMITIVE_SUBTYPES[t]) {
+        if (sub === t) continue;
+        for (const s of closeOver(sub)) result.add(s);
+      }
+      return result;
+    };
+    for (const t of Object.keys(PRIMITIVE_SUBTYPES))
+      closeOver(t);
+    return closure;
+  })();
   function isPrimitiveSubtype(lhs, rhs) {
     if (rhs === "any") return true;
     if (lhs === "never") return true;
     if (lhs === "unknown" || rhs === "unknown") return false;
     if (lhs === rhs) return true;
-    return PRIMITIVE_SUBTYPES[rhs].includes(lhs);
+    return PRIMITIVE_SUBTYPES_CLOSURE[rhs].has(lhs);
   }
   function isSubtype(lhs, rhs) {
-    if (typeof lhs === "string" && !PRIMITIVE_TYPES.includes(lhs))
+    if (typeof lhs === "string" && !PRIMITIVE_TYPES_SET.has(lhs))
       lhs = parseType(lhs);
-    if (typeof rhs === "string" && !PRIMITIVE_TYPES.includes(rhs))
+    if (typeof rhs === "string" && !PRIMITIVE_TYPES_SET.has(rhs))
       rhs = parseType(rhs);
     if (rhs === "any") return true;
+    if (lhs === "never") return true;
     if (rhs === "never") return false;
     if (rhs === "error") return lhs === "error";
     if (rhs === "nothing") return lhs === "nothing";
@@ -2872,7 +2768,7 @@ var LatexSyntax = (() => {
         if (typeof lhs.value === "number") {
           if (Number.isInteger(lhs.value))
             return isPrimitiveSubtype("integer", rhs);
-          return isPrimitiveSubtype("number", rhs);
+          return isPrimitiveSubtype("real", rhs);
         }
         if (typeof lhs.value === "boolean")
           return isPrimitiveSubtype("boolean", rhs);
@@ -3098,127 +2994,340 @@ var LatexSyntax = (() => {
       }
       if (typeof lhs.value === "string") return isSubtype("string", rhs);
     }
-    return false;
-  }
-  function isNumeric(type) {
-    if (typeof type === "string")
-      return NUMERIC_TYPES.includes(type);
-    if (type.kind === "value") return typeof type.value === "number";
-    if (type.kind === "numeric") return true;
-    return false;
-  }
-  function isScalar(type) {
-    if (isNumeric(type)) return true;
-    if (typeof type === "string")
-      return SCALAR_TYPES.includes(type);
-    if (type.kind === "value")
-      return ["string", "boolean", "number"].includes(typeof type.value);
-    return false;
-  }
-  function isCollection(type) {
-    if (isIndexedCollection(type)) return true;
-    if (typeof type === "string")
-      return COLLECTION_TYPES.includes(type);
-    return ["collection", "set", "record", "dictionary"].includes(type.kind);
-  }
-  function isIndexedCollection(type) {
-    if (typeof type === "string") return false;
-    return ["indexed_collection", "list", "tuple"].includes(type.kind);
-  }
-  function isValue(type) {
-    return isScalar(type) || isCollection(type);
-  }
-  function isFunction(type) {
-    return type === "function" || typeof type !== "string" && type.kind === "signature";
-  }
-  function isExpression(type) {
-    if (typeof type === "string" && ["expression", "symbol", "function"].includes(type))
-      return true;
-    if (isValue(type) || isFunction(type) || isSymbol(type)) return true;
-    if (typeof type === "string") return false;
-    if (type.kind === "expression") return true;
-    return false;
-  }
-  function isSymbol(type) {
-    if (type === "symbol") return true;
-    if (typeof type === "string") return false;
-    if (type.kind === "symbol") return true;
-    if (type.kind === "expression") return type.operator === "Symbol";
-    return false;
-  }
-  function narrow2(a, b) {
-    if (a === b) return a;
-    if (a === "nothing" || b === "nothing") return "nothing";
-    if (a === "any") return b;
-    if (b === "any") return a;
-    if (a === "never") return b;
-    if (b === "never") return a;
-    if (a === "unknown") return b;
-    if (b === "unknown") return a;
-    if (isSubtype(a, b)) return a;
-    if (isSubtype(b, a)) return b;
-    return superType(a, b);
-  }
-  function widen2(a, b) {
-    if (a === b) return a;
-    if (a === "any" || b === "any") return "any";
-    if (a === "never") return b;
-    if (b === "never") return a;
-    if (a === "unknown") return b;
-    if (b === "unknown") return a;
-    if (a === "nothing") return b;
-    if (b === "nothing") return a;
-    if (isSubtype(a, b)) return b;
-    if (isSubtype(b, a)) return a;
-    return superType(a, b);
-  }
-  function narrow(...types) {
-    if (types.length === 0) return "nothing";
-    if (types.length === 1) return types[0];
-    return types.reduce((a, b) => narrow2(a, b));
+    return false;
+  }
+  function isNumeric(type) {
+    if (typeof type === "string")
+      return NUMERIC_TYPES_SET.has(type);
+    if (type.kind === "value") return typeof type.value === "number";
+    if (type.kind === "numeric") return true;
+    return false;
+  }
+  function isScalar(type) {
+    if (isNumeric(type)) return true;
+    if (typeof type === "string")
+      return SCALAR_TYPES_SET.has(type);
+    if (type.kind === "value")
+      return ["string", "boolean", "number"].includes(typeof type.value);
+    return false;
+  }
+  function isCollection(type) {
+    if (isIndexedCollection(type)) return true;
+    if (typeof type === "string")
+      return COLLECTION_TYPES_SET.has(type);
+    return ["collection", "set", "record", "dictionary"].includes(type.kind);
+  }
+  function isIndexedCollection(type) {
+    if (typeof type === "string") return false;
+    return ["indexed_collection", "list", "tuple"].includes(type.kind);
+  }
+  function isValue(type) {
+    return isScalar(type) || isCollection(type);
+  }
+  function isFunction(type) {
+    return type === "function" || typeof type !== "string" && type.kind === "signature";
+  }
+  function isExpression(type) {
+    if (typeof type === "string" && ["expression", "symbol", "function"].includes(type))
+      return true;
+    if (isValue(type) || isFunction(type) || isSymbol(type)) return true;
+    if (typeof type === "string") return false;
+    if (type.kind === "expression") return true;
+    return false;
+  }
+  function isSymbol(type) {
+    if (type === "symbol") return true;
+    if (typeof type === "string") return false;
+    if (type.kind === "symbol") return true;
+    if (type.kind === "expression") return type.operator === "Symbol";
+    return false;
+  }
+  function narrow2(a, b) {
+    if (a === b) return a;
+    if (a === "nothing" || b === "nothing") return "nothing";
+    if (a === "any") return b;
+    if (b === "any") return a;
+    if (a === "never") return b;
+    if (b === "never") return a;
+    if (a === "unknown") return b;
+    if (b === "unknown") return a;
+    if (isSubtype(a, b)) return a;
+    if (isSubtype(b, a)) return b;
+    return "never";
+  }
+  function widen2(a, b) {
+    if (a === b) return a;
+    if (a === "any" || b === "any") return "any";
+    if (a === "never") return b;
+    if (b === "never") return a;
+    if (a === "unknown") return b;
+    if (b === "unknown") return a;
+    if (a === "nothing") return b;
+    if (b === "nothing") return a;
+    if (isSubtype(a, b)) return b;
+    if (isSubtype(b, a)) return a;
+    const sup = superType(a, b);
+    if (LOSSY_SUPERTYPE.has(sup)) return unionTypes(a, b);
+    return sup;
+  }
+  var LOSSY_SUPERTYPE = /* @__PURE__ */ new Set([
+    "scalar",
+    "value",
+    "function",
+    "expression",
+    "collection",
+    "indexed_collection",
+    "list",
+    "set",
+    "tuple",
+    "record",
+    "dictionary",
+    "map",
+    "any"
+  ]);
+  function unionTypes(a, b) {
+    const members = [];
+    const keys = /* @__PURE__ */ new Set();
+    const push = (t) => {
+      if (typeof t === "object" && t.kind === "union") {
+        for (const m of t.types) push(m);
+        return;
+      }
+      const key = typeof t === "string" ? t : JSON.stringify(t);
+      if (!keys.has(key)) {
+        keys.add(key);
+        members.push(t);
+      }
+    };
+    push(a);
+    push(b);
+    if (members.length === 1) return members[0];
+    return { kind: "union", types: members };
+  }
+  function narrow(...types) {
+    if (types.length === 0) return "nothing";
+    if (types.length === 1) return types[0];
+    return types.reduce((a, b) => narrow2(a, b));
+  }
+  function widen(...types) {
+    if (types.length === 0) return "nothing";
+    if (types.length === 1) return types[0];
+    return types.reduce((a, b) => widen2(a, b));
+  }
+  var SUPERTYPE_PROBE_ORDER = [
+    "non_finite_number",
+    "finite_integer",
+    "integer",
+    "finite_rational",
+    "rational",
+    "finite_real",
+    "real",
+    "imaginary",
+    "finite_complex",
+    "complex",
+    "finite_number",
+    "number",
+    "list",
+    "record",
+    "dictionary",
+    "set",
+    "tuple",
+    "indexed_collection",
+    "collection",
+    "scalar",
+    "value",
+    "function",
+    "expression"
+  ];
+  var PRIMITIVE_SUPERTYPE_CACHE = /* @__PURE__ */ new Map();
+  function superType(a, b) {
+    if (a === b) return a;
+    if (a === "any" || b === "any") return "any";
+    if (a === "never") return b;
+    if (b === "never") return a;
+    if (a === "unknown") return b;
+    if (b === "unknown") return a;
+    if (a === "nothing") return b;
+    if (b === "nothing") return a;
+    if (typeof a === "string" && typeof b === "string") {
+      const key = a < b ? `${a}|${b}` : `${b}|${a}`;
+      let result = PRIMITIVE_SUPERTYPE_CACHE.get(key);
+      if (result === void 0) {
+        result = "any";
+        for (const ancestor of SUPERTYPE_PROBE_ORDER) {
+          const subtypes = PRIMITIVE_SUBTYPES_CLOSURE[ancestor];
+          if (subtypes.has(a) && subtypes.has(b)) {
+            result = ancestor;
+            break;
+          }
+        }
+        PRIMITIVE_SUPERTYPE_CACHE.set(key, result);
+      }
+      return result;
+    }
+    for (const ancestor of SUPERTYPE_PROBE_ORDER)
+      if (isSubtype(a, ancestor) && isSubtype(b, ancestor)) return ancestor;
+    return "any";
+  }
+
+  // src/common/type/serialize.ts
+  var NEGATION_PRECEDENCE = 3;
+  var UNION_PRECEDENCE = 1;
+  var INTERSECTION_PRECEDENCE = 2;
+  var LIST_PRECEDENCE = 4;
+  var RECORD_PRECEDENCE = 5;
+  var DICTIONARY_PRECEDENCE = 6;
+  var SET_PRECEDENCE = 7;
+  var COLLECTION_PRECEDENCE = 8;
+  var TUPLE_PRECEDENCE = 9;
+  var SIGNATURE_PRECEDENCE = 10;
+  var VALUE_PRECEDENCE = 11;
+  function typeToString(type, precedence = 0) {
+    if (typeof type === "string") return type;
+    let result = "";
+    switch (type.kind) {
+      case "value":
+        if (typeof type.value === "string") result = `"${type.value}"`;
+        else if (typeof type.value === "boolean")
+          result = type.value ? "true" : "false";
+        else result = type.value.toString();
+        break;
+      case "reference":
+        result = type.name;
+        break;
+      case "negation":
+        result = `!${typeToString(type.type, NEGATION_PRECEDENCE)}`;
+        break;
+      case "union":
+        result = type.types.map((t) => typeToString(t, UNION_PRECEDENCE)).join(" | ");
+        break;
+      case "intersection":
+        result = type.types.map((t) => typeToString(t, INTERSECTION_PRECEDENCE)).join(" & ");
+        break;
+      case "expression":
+        result = `expression<${symbolName(type.operator)}>`;
+        break;
+      case "symbol":
+        result = `symbol<${symbolName(type.name)}>`;
+        break;
+      case "numeric":
+        if (Number.isFinite(type.lower) && Number.isFinite(type.upper)) {
+          result = `${type.type}<${type.lower}..${type.upper}>`;
+        } else if (Number.isFinite(type.lower)) {
+          result = `${type.type}<${type.lower}..>`;
+        } else if (Number.isFinite(type.upper)) {
+          result = `${type.type}<..${type.upper}>`;
+        } else {
+          result = `${type.type}`;
+        }
+        break;
+      case "list":
+        if (type.dimensions && typeof type.elements === "string" && NUMERIC_TYPES_SET.has(type.elements)) {
+          if (type.dimensions === void 0) {
+            if (type.elements === "number") result = "tensor";
+          } else if (type.dimensions.length === 1) {
+            if (type.elements === "number") {
+              if (type.dimensions[0] < 0) result = "vector";
+              else result = `vector<${type.dimensions[0]}>`;
+            } else {
+              if (type.dimensions[0] < 0)
+                result = `vector<${typeToString(type.elements)}>`;
+              else
+                result = `vector<${typeToString(type.elements)}^${type.dimensions[0]}>`;
+            }
+          } else if (type.dimensions.length === 2) {
+            const dims = type.dimensions;
+            if (type.elements === "number") {
+              if (dims[0] < 0 && dims[1] < 0) result = "matrix";
+              else result = `matrix<${dims[0]}x${dims[1]}>`;
+            } else {
+              if (dims[0] < 0 && dims[1] < 0)
+                result = `matrix<${typeToString(type.elements)}>`;
+              else
+                result = `matrix<${typeToString(type.elements)}^(${dims[0]}x${dims[1]})>`;
+            }
+          }
+        }
+        if (!result) {
+          const dimensions = type.dimensions ? type.dimensions.length === 1 ? `^${type.dimensions[0].toString()}` : `^(${type.dimensions.join("x")})` : "";
+          result = `list<${typeToString(type.elements)}${dimensions}>`;
+        }
+        break;
+      case "record":
+        const elements = Object.entries(type.elements).map(([key, value]) => `${key}: ${typeToString(value)}`).join(", ");
+        result = `record<${elements}>`;
+        break;
+      case "dictionary":
+        result = `dictionary<${typeToString(type.values)}>`;
+        break;
+      case "set":
+        result = `set<${typeToString(type.elements)}>`;
+        break;
+      case "collection":
+        result = `collection<${typeToString(type.elements)}>`;
+        break;
+      case "indexed_collection":
+        result = `indexed_collection<${typeToString(type.elements)}>`;
+        break;
+      case "tuple":
+        if (type.elements.length === 0) result = "tuple";
+        else if (type.elements.length === 1) {
+          const [el] = type.elements;
+          result = `tuple<${namedElement(el)}>`;
+        } else {
+          result = "tuple<" + type.elements.map((el) => namedElement(el)).join(", ") + ">";
+        }
+        break;
+      case "signature":
+        const args = type.args ? type.args.map((arg) => namedElement(arg)).join(", ") : "";
+        const optArgs = type.optArgs ? type.optArgs.map((arg) => namedElement(arg) + "?").join(", ") : "";
+        const varArg = type.variadicArg ? type.variadicMin === 0 ? `${namedElement(type.variadicArg)}*` : `${namedElement(type.variadicArg)}+` : "";
+        const argsList = [args, optArgs, varArg].filter((s) => s).join(", ");
+        result = `(${argsList}) -> ${typeToString(type.result)}`;
+        break;
+      default:
+        result = "error";
+    }
+    if (precedence > 0 && precedence > getPrecedence(type.kind))
+      return `(${result})`;
+    return result;
   }
-  function widen(...types) {
-    if (types.length === 0) return "nothing";
-    if (types.length === 1) return types[0];
-    return types.reduce((a, b) => widen2(a, b));
+  function namedElement(el) {
+    if (el.name) return `${el.name}: ${typeToString(el.type)}`;
+    return typeToString(el.type);
   }
-  function superType(a, b) {
-    if (a === b) return a;
-    if (a === "any" || b === "any") return "any";
-    if (a === "never") return b;
-    if (b === "never") return a;
-    if (a === "unknown") return b;
-    if (b === "unknown") return a;
-    if (a === "nothing") return b;
-    if (b === "nothing") return a;
-    if (commonSupertype(a, b, "non_finite_number")) return "non_finite_number";
-    if (commonSupertype(a, b, "finite_integer")) return "finite_integer";
-    if (commonSupertype(a, b, "integer")) return "integer";
-    if (commonSupertype(a, b, "finite_rational")) return "finite_rational";
-    if (commonSupertype(a, b, "rational")) return "rational";
-    if (commonSupertype(a, b, "finite_real")) return "finite_real";
-    if (commonSupertype(a, b, "real")) return "real";
-    if (commonSupertype(a, b, "imaginary")) return "imaginary";
-    if (commonSupertype(a, b, "finite_complex")) return "finite_complex";
-    if (commonSupertype(a, b, "complex")) return "complex";
-    if (commonSupertype(a, b, "finite_number")) return "finite_number";
-    if (commonSupertype(a, b, "number")) return "number";
-    if (commonSupertype(a, b, "list")) return "list";
-    if (commonSupertype(a, b, "record")) return "record";
-    if (commonSupertype(a, b, "dictionary")) return "dictionary";
-    if (commonSupertype(a, b, "set")) return "set";
-    if (commonSupertype(a, b, "tuple")) return "tuple";
-    if (commonSupertype(a, b, "indexed_collection")) return "indexed_collection";
-    if (commonSupertype(a, b, "collection")) return "collection";
-    if (commonSupertype(a, b, "scalar")) return "scalar";
-    if (commonSupertype(a, b, "value")) return "value";
-    if (commonSupertype(a, b, "function")) return "function";
-    if (commonSupertype(a, b, "expression")) return "expression";
-    return "any";
+  function symbolName(name) {
+    if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) return name;
+    return `\`${name}\``;
   }
-  function commonSupertype(a, b, ancestor) {
-    if (isSubtype(a, ancestor) && isSubtype(b, ancestor)) return true;
-    return false;
+  function getPrecedence(kind) {
+    switch (kind) {
+      case "negation":
+        return NEGATION_PRECEDENCE;
+      case "union":
+        return UNION_PRECEDENCE;
+      case "intersection":
+        return INTERSECTION_PRECEDENCE;
+      case "list":
+        return LIST_PRECEDENCE;
+      case "record":
+        return RECORD_PRECEDENCE;
+      case "dictionary":
+        return DICTIONARY_PRECEDENCE;
+      case "set":
+        return SET_PRECEDENCE;
+      case "collection":
+      case "indexed_collection":
+        return COLLECTION_PRECEDENCE;
+      case "tuple":
+        return TUPLE_PRECEDENCE;
+      case "signature":
+        return SIGNATURE_PRECEDENCE;
+      case "value":
+        return VALUE_PRECEDENCE;
+      default:
+        return 0;
+    }
   }
 
   // src/common/type/boxed-type.ts
@@ -4058,15 +4167,16 @@ var LatexSyntax = (() => {
       precedence: ASSIGNMENT_PRECEDENCE,
       parse: parseAssign
     },
-    // General colon operator (type annotation, mapping notation)
-    // Precedence below assignment (260) so `:=` takes priority,
-    // and below arrows (270) so `f: A \to B` parses as `Colon(f, To(A, B))`
+    // General colon operator (type annotation, mapping notation, Desmos piecewise)
+    // Precedence below comparisons (245) so `cond : val` (Desmos compact piecewise)
+    // parses as `Colon(cond, val)`, and below arrows (270) so
+    // `f: A \to B` parses as `Colon(f, To(A, B))`.
     {
       name: "Colon",
       latexTrigger: ":",
       kind: "infix",
       associativity: "right",
-      precedence: 250,
+      precedence: 240,
       serialize: (serializer, expr) => joinLatex([
         serializer.serialize(operand(expr, 1)),
         "\\colon",
@@ -4077,7 +4187,7 @@ var LatexSyntax = (() => {
       latexTrigger: "\\colon",
       kind: "infix",
       associativity: "right",
-      precedence: 250,
+      precedence: 240,
       parse: "Colon"
     },
     {
@@ -5053,6 +5163,7 @@ var LatexSyntax = (() => {
           }
         }
         if (!variable) return null;
+        if (symbol(variable) === null) return null;
         parser.skipSpace();
         const fn = parser.parseExpression({ minPrec: 740 });
         if (!fn) return null;
@@ -5239,7 +5350,7 @@ var LatexSyntax = (() => {
     if (runs.length === 1) body = runs[0];
     else {
       if (runs.every((x) => stringValue(x) !== null))
-        body = "'" + runs.map((x) => stringValue(x)).join() + "'";
+        body = "'" + runs.map((x) => stringValue(x)).join("") + "'";
       else body = ["Text", ...runs];
     }
     return style ? ["Annotated", body, dictionaryFromEntries(style)] : body;
@@ -5647,7 +5758,10 @@ var LatexSyntax = (() => {
         p.skipVisualSpace();
         const isComma = p.peek === ",";
         p.index = saved;
-        return isComma;
+        if (isComma) return true;
+        if (peekKeyword(p, "where")) return true;
+        if (peekKeyword(p, "with")) return true;
+        return false;
       }
     };
     const elements = [];
@@ -5688,6 +5802,25 @@ var LatexSyntax = (() => {
       parser.skipVisualSpace();
     } while (parser.match(","));
     if (bindings.length === 0) return null;
+    const forStart = parser.index;
+    if (matchKeyword(parser, "for")) {
+      const loop = parseForComprehension(parser, lhs, until);
+      if (loop) {
+        const block2 = [];
+        for (const b of bindings) {
+          const normalized = normalizeLocalAssign(b);
+          if (operator(normalized) === "Assign") {
+            block2.push(["Declare", operand(normalized, 1)]);
+            block2.push(normalized);
+          } else {
+            block2.push(normalized);
+          }
+        }
+        block2.push(loop);
+        return ["Block", ...block2];
+      }
+      parser.index = forStart;
+    }
     const block = [];
     for (const b of bindings) {
       const normalized = normalizeLocalAssign(b);
@@ -5901,6 +6034,17 @@ var LatexSyntax = (() => {
     const upperExpr = openRight ? ["Open", upper] : upper;
     return ["Interval", lowerExpr, upperExpr];
   }
+  var COMPARISON_HEADS = /* @__PURE__ */ new Set([
+    "Less",
+    "LessEqual",
+    "Greater",
+    "GreaterEqual",
+    "Equal",
+    "NotEqual",
+    "And",
+    "Or",
+    "Not"
+  ]);
   var DEFINITIONS_SETS = [
     //
     // Constants
@@ -6159,18 +6303,58 @@ var LatexSyntax = (() => {
       closeTrigger: "}",
       parse: (_parser, body) => {
         if (isEmptySequence(body)) return "EmptySet";
+        if (operator(body) == "Delimiter" && stringValue(operand(body, 2)) === ",") {
+          body = operand(body, 1);
+        }
         const h = operator(body);
-        if (h === "Divides" || h === "Colon") {
+        if (h === "Divides") {
           const expr = operand(body, 1);
           const condition = operand(body, 2);
           if (expr !== null && condition !== null)
             return ["Set", expr, ["Condition", condition]];
         }
-        if (operator(body) == "Delimiter" && stringValue(operand(body, 2)) === ",") {
-          body = operand(body, 1);
+        if (h === "Colon") {
+          const lhs = operand(body, 1);
+          const rhs = operand(body, 2);
+          if (lhs !== null && rhs !== null) {
+            const lhsOp = operator(lhs);
+            if (lhsOp !== null && COMPARISON_HEADS.has(lhsOp)) {
+              return ["Which", lhs, rhs];
+            }
+            return ["Set", lhs, ["Condition", rhs]];
+          }
+        }
+        if (h === "Sequence") {
+          const elements = operands(body);
+          const colonElements = elements.filter((el) => operator(el) === "Colon");
+          const allPiecewise = colonElements.length > 0 && colonElements.every((el) => {
+            const lhs = operand(el, 1);
+            const lhsOp = lhs !== null ? operator(lhs) : null;
+            return lhsOp !== null && COMPARISON_HEADS.has(lhsOp);
+          });
+          if (allPiecewise) {
+            const whichOps = [];
+            for (let i = 0; i < elements.length; i++) {
+              const el = elements[i];
+              if (operator(el) === "Colon") {
+                const cond = operand(el, 1);
+                const val = operand(el, 2);
+                if (cond === null || val === null) {
+                  return ["Set", ...elements];
+                }
+                whichOps.push(cond, val);
+              } else {
+                if (i !== elements.length - 1) {
+                  return ["Set", ...elements];
+                }
+                whichOps.push("True", el);
+              }
+            }
+            return ["Which", ...whichOps];
+          }
+          return ["Set", ...elements];
         }
-        if (operator(body) !== "Sequence") return ["Set", body];
-        return ["Set", ...operands(body)];
+        return ["Set", body];
       },
       serialize: (serializer, expr) => {
         if (nops(expr) === 2 && operator(operand(expr, 2)) === "Condition") {
@@ -6729,6 +6913,8 @@ var LatexSyntax = (() => {
         const h = operator(arg);
         if (prevWasNumber && (h === "Divide" || h === "Rational")) {
           result = latexTemplate(serializer.options.multiply, result, term);
+        } else if (/^\d/.test(term)) {
+          result = latexTemplate(serializer.options.multiply, result, term);
         } else if (!serializer.options.invisibleMultiply) {
           result = joinLatex([result, term]);
         } else {
@@ -8174,7 +8360,9 @@ var LatexSyntax = (() => {
         minPrec: MULTIPLICATION_PRECEDENCE,
         condition: (parser2) => trigCommands[parser2.peek] || (until?.condition?.(parser2) ?? false)
       });
-      const appliedFn = args === null ? fn : typeof fn === "string" ? [fn, ...args] : ["Apply", fn, ...args];
+      const isTwoArgArctan = args?.length === 2 && (fn === "Arctan" || Array.isArray(fn) && fn[0] === "InverseFunction" && fn[1] === "Tan");
+      const head = isTwoArgArctan ? "Arctan2" : fn;
+      const appliedFn = args === null ? fn : typeof head === "string" ? [head, ...args] : ["Apply", head, ...args];
       return sup === null ? appliedFn : ["Power", appliedFn, sup];
     };
   }
@@ -10297,10 +10485,17 @@ var LatexSyntax = (() => {
     // The capitalized library entries already exist; these are pure parse
     // aliases so the lowercase names don't land in `unsupported-operator`.
     // ---------------------------------------------------------------------------
+    { latexTrigger: "\\operatorname{count}", parse: "Length" },
     { latexTrigger: "\\operatorname{random}", parse: "Random" },
     { latexTrigger: "\\operatorname{shuffle}", parse: "Shuffle" },
     { latexTrigger: "\\operatorname{repeat}", parse: "Repeat" },
     { latexTrigger: "\\operatorname{join}", parse: "Join" },
+    { latexTrigger: "\\operatorname{range}", parse: "Range" },
+    // Note: `\operatorname{with}` (Desmos's local-binding clause) is intentionally
+    // NOT registered here. Use the math-notation equivalent `\operatorname{where}`
+    // (with `\coloneq` for bindings), or register `with` as a custom dictionary
+    // entry at the integration layer — see the "Desmos-Specific Syntax — Prefer
+    // Custom LaTeX Dictionary" section in COMPUTE_ENGINE.md for a worked example.
     // ---------------------------------------------------------------------------
     // Geometric primitive heads. Registered as known typed heads so consumers
     // can branch on the operator name; CE itself doesn't render them. The
@@ -10673,10 +10868,41 @@ var LatexSyntax = (() => {
       postfixByTrigger: /* @__PURE__ */ new Map(),
       functionByTrigger: /* @__PURE__ */ new Map(),
       symbolByTrigger: /* @__PURE__ */ new Map(),
-      expressionByTrigger: /* @__PURE__ */ new Map()
+      expressionByTrigger: /* @__PURE__ */ new Map(),
+      operatorByTrigger: /* @__PURE__ */ new Map(),
+      universalDefs: /* @__PURE__ */ new Map(),
+      symbolTriggerDefs: /* @__PURE__ */ new Map()
     };
     for (const entry of dic)
       addEntry(result, entry, onError);
+    for (let i = result.defs.length - 1; i >= 0; i--) {
+      const def = result.defs[i];
+      const isOperator = def.kind === "infix" || def.kind === "prefix" || def.kind === "postfix";
+      const kinds = isOperator ? [def.kind, "operator"] : [def.kind];
+      for (const kind of kinds) {
+        if (def.latexTrigger === "") {
+          const defs = result.universalDefs.get(kind);
+          if (defs) defs.push(def);
+          else result.universalDefs.set(kind, [def]);
+        }
+        if (def.symbolTrigger) {
+          let byTrigger = result.symbolTriggerDefs.get(kind);
+          if (!byTrigger) {
+            byTrigger = /* @__PURE__ */ new Map();
+            result.symbolTriggerDefs.set(kind, byTrigger);
+          }
+          const defs = byTrigger.get(def.symbolTrigger);
+          if (defs) defs.push(def);
+          else byTrigger.set(def.symbolTrigger, [def]);
+        }
+        if (kind === "operator" && def.latexTrigger && def.latexTrigger !== "") {
+          const operatorDef = def;
+          const defs = result.operatorByTrigger.get(def.latexTrigger);
+          if (defs) defs.push(operatorDef);
+          else result.operatorByTrigger.set(def.latexTrigger, [operatorDef]);
+        }
+      }
+    }
     const COMPLEMENTARY_PAIRS = {
       "(": [")", "\\rparen"],
       "\\lparen": [")", "\\rparen"],
@@ -11041,7 +11267,7 @@ var LatexSyntax = (() => {
       }
     }
     if (isMatchfixEntry(entry)) {
-      if ("latexTrigger" in entry || "symbolTrigger" in isPrefixEntry) {
+      if ("latexTrigger" in entry || "symbolTrigger" in entry) {
         onError({
           severity: "warning",
           message: [
@@ -11140,6 +11366,15 @@ var LatexSyntax = (() => {
   }
 
   // src/compute-engine/latex-syntax/parse-symbol.ts
+  var _symbolNameByLatex = null;
+  function getSymbolNameByLatex() {
+    if (!_symbolNameByLatex) {
+      _symbolNameByLatex = /* @__PURE__ */ new Map();
+      for (const [name, latex] of SYMBOLS)
+        if (!_symbolNameByLatex.has(latex)) _symbolNameByLatex.set(latex, name);
+    }
+    return _symbolNameByLatex;
+  }
   var SYMBOL_PREFIX = {
     // Those are "grouping" prefix that also specify spacing
     // around the symbol. We ignore the spacing, though.
@@ -11218,10 +11453,10 @@ var LatexSyntax = (() => {
       parser.nextToken();
       return special;
     }
-    const i = SYMBOLS.findIndex((x) => x[1] === token);
-    if (i >= 0) {
+    const symbolName2 = getSymbolNameByLatex().get(token);
+    if (symbolName2 !== void 0) {
       parser.nextToken();
-      return SYMBOLS[i][0];
+      return symbolName2;
     }
     const c = parser.parseChar();
     if (c !== null) {
@@ -11318,11 +11553,12 @@ var LatexSyntax = (() => {
         body = digit;
         parser.nextToken();
       }
-      body += parseSymbolBody(parser);
-      if (body === null || !parser.match("<}>")) {
+      const rest = parseSymbolBody(parser);
+      if (rest === null || !parser.match("<}>")) {
         parser.index = start;
         return null;
       }
+      body += rest;
       if (prefix === "_upright" && body.length > 1) return body;
       return body + prefix;
     }
@@ -11533,6 +11769,7 @@ var LatexSyntax = (() => {
     return sum;
   }
   function fpln(x, scale) {
+    if (x <= 0n) throw new RangeError("fpln: input must be positive");
     if (x === scale) return 0n;
     const xNum = Number(x);
     const scaleNum = Number(scale);
@@ -12182,9 +12419,11 @@ var LatexSyntax = (() => {
       if (Number.isFinite(thisExp) && Number.isFinite(otherExp)) {
         if (other.significand === 0n) return _BigDecimal.NAN;
         if (this.significand === 0n) return fromRaw(0n, 0);
-        return this.sub(this.div(other).trunc().mul(other)).toPrecision(
-          _BigDecimal.precision
-        );
+        const ediff = thisExp - otherExp;
+        const num = ediff >= 0 ? this.significand * pow10(ediff) : this.significand;
+        const den = ediff >= 0 ? other.significand : other.significand * pow10(-ediff);
+        const q = num / den;
+        return this.sub(fromRaw(q, 0).mul(other));
       }
       if (thisExp !== thisExp || otherExp !== otherExp) return _BigDecimal.NAN;
       if (!Number.isFinite(thisExp)) return _BigDecimal.NAN;
@@ -12229,7 +12468,10 @@ var LatexSyntax = (() => {
           return this.pow(n.neg()).inv();
         }
         const absSig = this.significand < 0n ? -this.significand : this.significand;
-        const thisLog10 = bigintDigits(absSig) + this.exponent;
+        const sigDigits = bigintDigits(absSig);
+        const dropped = sigDigits > 15 ? sigDigits - 15 : 0;
+        const lead = dropped > 0 ? Number(absSig / 10n ** BigInt(dropped)) : Number(absSig);
+        const thisLog10 = Math.log10(lead) + dropped + this.exponent;
         const resultLog10 = Number(expValue) * thisLog10;
         if (resultLog10 > 9e15) {
           return this.significand < 0n && expValue % 2n !== 0n ? _BigDecimal.NEGATIVE_INFINITY : _BigDecimal.POSITIVE_INFINITY;
@@ -12262,7 +12504,19 @@ var LatexSyntax = (() => {
         return _BigDecimal.POSITIVE_INFINITY;
       }
       if (this.significand < 0n) return _BigDecimal.NAN;
-      return n.mul(this.ln()).exp();
+      const baseSig = this.significand;
+      const decExpBase = this.exponent + bigintDigits(baseSig) - 1;
+      const nSig = n.significand < 0n ? -n.significand : n.significand;
+      const decExpN = n.exponent + bigintDigits(nSig) - 1;
+      const argMag = decExpN + Math.log10(Math.abs(decExpBase) * 2.303 + 3) + 1;
+      const extra = Math.min(20, Math.max(2, Math.ceil(argMag) + 2));
+      const savedPrec = _BigDecimal.precision;
+      _BigDecimal.precision = savedPrec + extra;
+      try {
+        return n.mul(this.ln()).exp().toPrecision(savedPrec);
+      } finally {
+        _BigDecimal.precision = savedPrec;
+      }
     }
     // ---------- Conversion methods ----------
     /** Convert to a JavaScript number. May lose precision for large values. */
@@ -12503,6 +12757,20 @@ var LatexSyntax = (() => {
     const sig = negative ? -absFp : absFp;
     return fromRaw(sig, resultExp);
   }
+  function decimalExponent(x) {
+    const sig = x.significand < 0n ? -x.significand : x.significand;
+    return x.exponent + bigintDigits(sig) - 1;
+  }
+  var MAX_SAFE_EXPONENT = BigInt(Number.MAX_SAFE_INTEGER);
+  var _ln10Fp = null;
+  var _ln10Scale = null;
+  function ln10Fixed(scale) {
+    if (_ln10Scale !== scale) {
+      _ln10Fp = fpln(10n * scale, scale);
+      _ln10Scale = scale;
+    }
+    return _ln10Fp;
+  }
   BigDecimal.prototype.sqrt = function() {
     if (this.isNaN()) return BigDecimal.NAN;
     if (this.isZero()) return BigDecimal.ZERO;
@@ -12513,9 +12781,13 @@ var LatexSyntax = (() => {
     if (this.significand < 0n) return BigDecimal.NAN;
     const targetPrec = BigDecimal.precision;
     const workingPrec = targetPrec + 10;
-    const [fp, scale] = toFixedPoint(this, workingPrec);
+    const e = decimalExponent(this);
+    const k = Math.floor(e / 2);
+    const m = fromRaw(this.significand, this.exponent - 2 * k);
+    const [fp, scale] = toFixedPoint(m, workingPrec);
     const sqrtFp = fpsqrt(fp, scale);
-    return fromFixedPoint(sqrtFp, scale, targetPrec);
+    const root = fromFixedPoint(sqrtFp, scale, targetPrec);
+    return fromRaw(root.significand, root.exponent + k);
   };
   BigDecimal.prototype.cbrt = function() {
     if (this.isNaN()) return BigDecimal.NAN;
@@ -12529,10 +12801,13 @@ var LatexSyntax = (() => {
     }
     const targetPrec = BigDecimal.precision;
     const workingPrec = targetPrec + 10;
-    const [fp, scale] = toFixedPoint(this, workingPrec);
+    const e = decimalExponent(this);
+    const k = Math.floor(e / 3);
+    const m = fromRaw(this.significand, this.exponent - 3 * k);
+    const [fp, scale] = toFixedPoint(m, workingPrec);
     const C = fp * scale * scale;
     let x;
-    const numVal = this.toNumber();
+    const numVal = m.toNumber();
     const scaleNum = Number(scale);
     if (Number.isFinite(numVal) && numVal > 0 && Number.isFinite(scaleNum)) {
       const approx = Math.cbrt(numVal);
@@ -12561,7 +12836,8 @@ var LatexSyntax = (() => {
       const diffNext = bigintAbs(next * next * next - C);
       if (diffNext < diffX) x = next;
     }
-    return fromFixedPoint(x, scale, targetPrec);
+    const root = fromFixedPoint(x, scale, targetPrec);
+    return fromRaw(root.significand, root.exponent + k);
   };
   BigDecimal.sqrt = function(x) {
     return x.sqrt();
@@ -12576,11 +12852,27 @@ var LatexSyntax = (() => {
       return BigDecimal.ZERO;
     }
     if (this.isZero()) return BigDecimal.ONE;
+    if (decimalExponent(this) >= 17)
+      return this.significand > 0n ? BigDecimal.POSITIVE_INFINITY : BigDecimal.ZERO;
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
-    const [fp, scale] = toFixedPoint(this, workingPrec);
-    const expFp = fpexp(fp, scale);
-    return fromFixedPoint(expFp, scale, targetPrec);
+    const absSig = this.significand < 0n ? -this.significand : this.significand;
+    const magnitude = Math.max(0, this.exponent + bigintDigits(absSig));
+    const workingPrec = targetPrec + 20 + magnitude;
+    const [xFp, scale] = toFixedPoint(this, workingPrec);
+    const l10 = ln10Fixed(scale);
+    let k = xFp / l10;
+    let rFp = xFp - k * l10;
+    if (rFp < 0n) {
+      k -= 1n;
+      rFp += l10;
+    }
+    if (k > MAX_SAFE_EXPONENT || k < -MAX_SAFE_EXPONENT)
+      return k > 0n ? BigDecimal.POSITIVE_INFINITY : BigDecimal.ZERO;
+    const expR = fromFixedPoint(fpexp(rFp, scale), scale, targetPrec);
+    const newExp = expR.exponent + Number(k);
+    if (!Number.isSafeInteger(newExp))
+      return k > 0n ? BigDecimal.POSITIVE_INFINITY : BigDecimal.ZERO;
+    return fromRaw(expR.significand, newExp);
   };
   BigDecimal.prototype.ln = function() {
     if (this.isNaN()) return BigDecimal.NAN;
@@ -12592,10 +12884,16 @@ var LatexSyntax = (() => {
     if (this.significand < 0n) return BigDecimal.NAN;
     if (this.eq(1)) return BigDecimal.ZERO;
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
-    const [fp, scale] = toFixedPoint(this, workingPrec);
-    const lnFp = fpln(fp, scale);
-    return fromFixedPoint(lnFp, scale, targetPrec);
+    const sig = this.significand;
+    const digits = bigintDigits(sig);
+    const e = this.exponent + digits - 1;
+    const m = fromRaw(sig, -(digits - 1));
+    const eDigits = Math.abs(e).toString().length;
+    const workingPrec = targetPrec + 20 + eDigits;
+    const [mFp, scale] = toFixedPoint(m, workingPrec);
+    const l10 = ln10Fixed(scale);
+    const resultFp = fpln(mFp, scale) + BigInt(e) * l10;
+    return fromFixedPoint(resultFp, scale, targetPrec);
   };
   BigDecimal.prototype.log = function(base) {
     const b = base instanceof BigDecimal ? base : new BigDecimal(base);
@@ -12615,7 +12913,10 @@ var LatexSyntax = (() => {
     if (!this.isFinite()) return BigDecimal.NAN;
     if (this.isZero()) return BigDecimal.ZERO;
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
+    const e = decimalExponent(this);
+    if (e < 0 && -2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+    const workingPrec = targetPrec + 15 + (e < 0 ? -e : 0);
+    if (e > PI_DIGITS.length - workingPrec - 30) return BigDecimal.NAN;
     const [fp, scale] = toFixedPoint(this, workingPrec);
     const [sinFp] = fpsincos(fp, scale);
     return fromFixedPoint(sinFp, scale, targetPrec);
@@ -12626,6 +12927,8 @@ var LatexSyntax = (() => {
     if (this.isZero()) return BigDecimal.ONE;
     const targetPrec = BigDecimal.precision;
     const workingPrec = targetPrec + 15;
+    const e = decimalExponent(this);
+    if (e > PI_DIGITS.length - workingPrec - 30) return BigDecimal.NAN;
     const [fp, scale] = toFixedPoint(this, workingPrec);
     const [, cosFp] = fpsincos(fp, scale);
     return fromFixedPoint(cosFp, scale, targetPrec);
@@ -12635,7 +12938,10 @@ var LatexSyntax = (() => {
     if (!this.isFinite()) return BigDecimal.NAN;
     if (this.isZero()) return BigDecimal.ZERO;
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
+    const e = decimalExponent(this);
+    if (e < 0 && -2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+    const workingPrec = targetPrec + 15 + (e < 0 ? -e : 0);
+    if (e > PI_DIGITS.length - workingPrec - 30) return BigDecimal.NAN;
     const [fp, scale] = toFixedPoint(this, workingPrec);
     const [sinFp, cosFp] = fpsincos(fp, scale);
     if (cosFp === 0n) {
@@ -12653,7 +12959,9 @@ var LatexSyntax = (() => {
       return piHalf.neg();
     }
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 15;
+    const e = decimalExponent(this);
+    if (e < 0 && -2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+    const workingPrec = targetPrec + 15 + (e < 0 ? -e : 0);
     const [fp, scale] = toFixedPoint(this, workingPrec);
     const atanFp = fpatan(fp, scale);
     return fromFixedPoint(atanFp, scale, targetPrec);
@@ -12670,7 +12978,9 @@ var LatexSyntax = (() => {
       return this.significand > 0n ? piHalf : piHalf.neg();
     }
     const targetPrec = BigDecimal.precision;
-    const workingPrec = targetPrec + 20;
+    const e = decimalExponent(this);
+    if (e < 0 && -2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+    const workingPrec = targetPrec + 20 + (e < 0 ? -e : 0);
     const [xFp, scale] = toFixedPoint(this, workingPrec);
     const x2 = fpmul(xFp, xFp, scale);
     const oneMinusX2 = scale - x2;
@@ -12733,6 +13043,23 @@ var LatexSyntax = (() => {
       if (this.significand > 0n) return BigDecimal.POSITIVE_INFINITY;
       return BigDecimal.NEGATIVE_INFINITY;
     }
+    const targetPrec = BigDecimal.precision;
+    const e = decimalExponent(this);
+    if (e < 0) {
+      if (-2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+      const saved = BigDecimal.precision;
+      BigDecimal.precision = targetPrec - e + 5;
+      try {
+        const expX2 = this.exp();
+        return expX2.sub(expX2.inv()).div(BigDecimal.TWO).toPrecision(targetPrec);
+      } finally {
+        BigDecimal.precision = saved;
+      }
+    }
+    if (Math.abs(this.toNumber()) > 1.16 * (targetPrec + 3)) {
+      const h = this.abs().exp().div(BigDecimal.TWO);
+      return this.significand > 0n ? h : h.neg();
+    }
     const expX = this.exp();
     const expNegX = expX.inv();
     return expX.sub(expNegX).div(BigDecimal.TWO);
@@ -12743,6 +13070,9 @@ var LatexSyntax = (() => {
     if (!this.isFinite()) {
       return BigDecimal.POSITIVE_INFINITY;
     }
+    const targetPrec = BigDecimal.precision;
+    if (Math.abs(this.toNumber()) > 1.16 * (targetPrec + 3))
+      return this.abs().exp().div(BigDecimal.TWO);
     const expX = this.exp();
     const expNegX = expX.inv();
     return expX.add(expNegX).div(BigDecimal.TWO);
@@ -12754,6 +13084,21 @@ var LatexSyntax = (() => {
       if (this.significand > 0n) return BigDecimal.ONE;
       return BigDecimal.NEGATIVE_ONE;
     }
+    const targetPrec = BigDecimal.precision;
+    const e = decimalExponent(this);
+    if (e < 0) {
+      if (-2 * e >= targetPrec + 4) return this.toPrecision(targetPrec);
+      const saved = BigDecimal.precision;
+      BigDecimal.precision = targetPrec - e + 5;
+      try {
+        const exp2x2 = this.mul(BigDecimal.TWO).exp();
+        return exp2x2.sub(BigDecimal.ONE).div(exp2x2.add(BigDecimal.ONE)).toPrecision(targetPrec);
+      } finally {
+        BigDecimal.precision = saved;
+      }
+    }
+    if (Math.abs(this.toNumber()) > 1.16 * (targetPrec + 3))
+      return this.significand > 0n ? BigDecimal.ONE : BigDecimal.NEGATIVE_ONE;
     const exp2x = this.mul(BigDecimal.TWO).exp();
     return exp2x.sub(BigDecimal.ONE).div(exp2x.add(BigDecimal.ONE));
   };
@@ -12902,7 +13247,7 @@ var LatexSyntax = (() => {
     const peek = parser.peek;
     if (peek === "\\overline") return true;
     if (peek === "\\overset") return true;
-    if (peek === "\\wideparent" || peek === "\\overarc") return true;
+    if (peek === "\\wideparen" || peek === "\\overarc") return true;
     if (peek === "(") return true;
     if (peek === "\\left") return true;
     return false;
@@ -13069,6 +13414,106 @@ var LatexSyntax = (() => {
   }
 
   // src/compute-engine/latex-syntax/parse.ts
+  var PARSE_TOKEN_EXCLUDED = /* @__PURE__ */ new Set([
+    ...'!"#$%&(),/;:?@[]\\`|~'.split(""),
+    "\\left",
+    "\\bigl",
+    "\\mleft"
+  ]);
+  var VISUAL_SPACE_COMMANDS = /* @__PURE__ */ new Set([
+    "\\!",
+    "\\,",
+    "\\:",
+    "\\;",
+    "\\enskip",
+    "\\enspace",
+    "\\space",
+    "\\quad",
+    "\\qquad"
+  ]);
+  var TEX_UNIT_TOKENS = [
+    "pt",
+    "em",
+    "mu",
+    "ex",
+    "mm",
+    "cm",
+    "in",
+    "bp",
+    "sp",
+    "dd",
+    "cc",
+    "pc",
+    "nc",
+    "nd"
+  ].map((unit) => [...unit]);
+  var BARE_FUNCTION_MAP = {
+    // Trigonometric
+    sin: "Sin",
+    cos: "Cos",
+    tan: "Tan",
+    cot: "Cot",
+    sec: "Sec",
+    csc: "Csc",
+    // Hyperbolic
+    sinh: "Sinh",
+    cosh: "Cosh",
+    tanh: "Tanh",
+    coth: "Coth",
+    sech: "Sech",
+    csch: "Csch",
+    // Inverse trigonometric
+    arcsin: "Arcsin",
+    arccos: "Arccos",
+    arctan: "Arctan",
+    arccot: "Arccot",
+    arcsec: "Arcsec",
+    arccsc: "Arccsc",
+    asin: "Arcsin",
+    acos: "Arccos",
+    atan: "Arctan",
+    // Inverse hyperbolic
+    arcsinh: "Arsinh",
+    arccosh: "Arcosh",
+    arctanh: "Artanh",
+    arccoth: "Arcoth",
+    arcsech: "Arsech",
+    arccsch: "Arcsch",
+    asinh: "Arsinh",
+    acosh: "Arcosh",
+    atanh: "Artanh",
+    // Logarithms and exponentials
+    log: "Log",
+    ln: "Ln",
+    exp: "Exp",
+    lg: "Lg",
+    lb: "Lb",
+    // Other common functions
+    sqrt: "Sqrt",
+    abs: "Abs",
+    sgn: "Sgn",
+    sign: "Sgn",
+    floor: "Floor",
+    ceil: "Ceil",
+    round: "Round",
+    max: "Max",
+    min: "Min",
+    gcd: "Gcd",
+    lcm: "Lcm",
+    // Roots
+    cbrt: "Root",
+    // Special-cased in `tryParseBareFunction` to add index 3
+    // Combinatorics
+    binom: "Binomial",
+    nCr: "Binomial"
+  };
+  var LOOKAHEAD_TOKEN_TO_STRING = {
+    "<space>": " ",
+    "<$$>": "$$",
+    "<$>": "$",
+    "<{>": "{",
+    "<}>": "}"
+  };
   var _symbolToUnicode = null;
   function getSymbolToUnicode() {
     if (!_symbolToUnicode) {
@@ -13170,7 +13615,7 @@ var LatexSyntax = (() => {
     }
     addSymbol(id, type) {
       if (typeof type === "string") type = new BoxedType(type);
-      if (id in this.symbolTable.ids && this.symbolTable.ids[id].is(type.type))
+      if (id in this.symbolTable.ids && !this.symbolTable.ids[id].is(type.type))
         throw new Error(`Symbol ${id} already declared as a different type`);
       this.symbolTable.ids[id] = type;
     }
@@ -13224,6 +13669,10 @@ var LatexSyntax = (() => {
     // Those two properties are used to detect infinite loops while parsing
     _lastPeek = "";
     _peekCounter = 0;
+    // Cache for `lookAhead()`: the token stream and the dictionary are
+    // immutable, so the result only depends on the current index
+    _lookAheadCache = null;
+    _lookAheadIndex = -1;
     constructor(tokens, dictionary, options) {
       this._tokens = tokens;
       this.options = options;
@@ -13380,9 +13829,6 @@ var LatexSyntax = (() => {
     latex(start, end) {
       return tokensToString(this._tokens.slice(start, end));
     }
-    latexAhead(n) {
-      return this.latex(this.index, this.index + n);
-    }
     // latexBefore(): string {
     //   return this.latex(0, this.index);
     // }
@@ -13404,77 +13850,72 @@ var LatexSyntax = (() => {
      *
      */
     lookAhead() {
-      let n = Math.min(
+      if (this._lookAheadIndex === this.index && this._lookAheadCache !== null)
+        return this._lookAheadCache;
+      const n = Math.min(
         this._dictionary.lookahead,
         this._tokens.length - this.index
       );
-      if (n <= 0) return [];
       const result = [];
-      while (n > 0) result.push([n, this.latexAhead(n--)]);
+      let s = "";
+      let sep = "";
+      for (let i = 0; i < n; i++) {
+        const token = this._tokens[this.index + i];
+        const segment = LOOKAHEAD_TOKEN_TO_STRING[token] ?? token;
+        if (/[a-zA-Z]/.test(segment[0])) s += sep;
+        sep = /\\[a-zA-Z]+\*?$/.test(segment) ? " " : "";
+        s += segment;
+        result[n - 1 - i] = [i + 1, s];
+      }
+      this._lookAheadCache = result;
+      this._lookAheadIndex = this.index;
       return result;
     }
     peekDefinitions(kind) {
       if (this.atEnd) return [];
       const result = [];
+      const dictionary = this._dictionary;
       let triggerIndex;
       switch (kind) {
         case "infix":
-          triggerIndex = this._dictionary.infixByTrigger;
+          triggerIndex = dictionary.infixByTrigger;
           break;
         case "prefix":
-          triggerIndex = this._dictionary.prefixByTrigger;
+          triggerIndex = dictionary.prefixByTrigger;
           break;
         case "postfix":
-          triggerIndex = this._dictionary.postfixByTrigger;
+          triggerIndex = dictionary.postfixByTrigger;
           break;
         case "function":
-          triggerIndex = this._dictionary.functionByTrigger;
+          triggerIndex = dictionary.functionByTrigger;
           break;
         case "symbol":
-          triggerIndex = this._dictionary.symbolByTrigger;
+          triggerIndex = dictionary.symbolByTrigger;
           break;
         case "expression":
-          triggerIndex = this._dictionary.expressionByTrigger;
+          triggerIndex = dictionary.expressionByTrigger;
           break;
         case "operator":
-          triggerIndex = void 0;
+          triggerIndex = dictionary.operatorByTrigger;
           break;
       }
-      if (triggerIndex) {
-        const defsNeedingIteration = [];
-        for (const def of this.getDefs(kind)) {
-          if (def.latexTrigger === "" || def.symbolTrigger) {
-            defsNeedingIteration.push(def);
-          }
-        }
-        for (const def of defsNeedingIteration) {
-          if (def.latexTrigger === "") result.push([def, 0]);
-        }
-        for (const [n, tokens] of this.lookAhead()) {
-          const defs = triggerIndex.get(tokens);
-          if (defs) {
-            for (const def of defs) result.push([def, n]);
-          }
-        }
-        for (const def of defsNeedingIteration) {
-          if (def.symbolTrigger) {
-            const n = parseComplexId(this, def.symbolTrigger);
-            if (n > 0) result.push([def, n]);
-          }
+      const universalDefs = dictionary.universalDefs.get(kind);
+      if (universalDefs) for (const def of universalDefs) result.push([def, 0]);
+      for (const [n, tokens] of this.lookAhead()) {
+        const defs = triggerIndex.get(tokens);
+        if (defs) {
+          for (const def of defs) result.push([def, n]);
         }
-      } else {
-        const defs = [...this.getDefs(kind)];
-        for (const def of defs)
-          if (def.latexTrigger === "") result.push([def, 0]);
-        for (const [n, tokens] of this.lookAhead()) {
-          for (const def of defs)
-            if (def.latexTrigger === tokens) result.push([def, n]);
-        }
-        for (const def of defs) {
-          if (def.symbolTrigger) {
-            const n = parseComplexId(this, def.symbolTrigger);
-            if (n > 0) result.push([def, n]);
-          }
+      }
+      const symbolTriggerDefs = dictionary.symbolTriggerDefs.get(kind);
+      if (symbolTriggerDefs) {
+        const start = this.index;
+        const candidate = parseSymbol(this)?.trim();
+        const n = this.index - start;
+        this.index = start;
+        if (candidate && n > 0) {
+          const defs = symbolTriggerDefs.get(candidate);
+          if (defs) for (const def of defs) result.push([def, n]);
         }
       }
       return result;
@@ -13512,17 +13953,7 @@ var LatexSyntax = (() => {
     skipVisualSpace() {
       if (!this.options.skipSpace) return;
       this.skipSpace();
-      if ([
-        "\\!",
-        "\\,",
-        "\\:",
-        "\\;",
-        "\\enskip",
-        "\\enspace",
-        "\\space",
-        "\\quad",
-        "\\qquad"
-      ].includes(this.peek)) {
+      if (VISUAL_SPACE_COMMANDS.has(this.peek)) {
         this.nextToken();
         this.skipVisualSpace();
       }
@@ -13535,23 +13966,8 @@ var LatexSyntax = (() => {
         this.skipSpace();
         if (!this.match("-")) this.match("+");
         while (/^[\d.]$/.test(this.peek)) this.nextToken();
-        for (const unit of [
-          "pt",
-          "em",
-          "mu",
-          "ex",
-          "mm",
-          "cm",
-          "in",
-          "bp",
-          "sp",
-          "dd",
-          "cc",
-          "pc",
-          "nc",
-          "nd"
-        ]) {
-          if (this.matchAll([...unit])) break;
+        for (const unit of TEX_UNIT_TOKENS) {
+          if (this.matchAll(unit)) break;
         }
         this.skipVisualSpace();
       }
@@ -13804,13 +14220,7 @@ var LatexSyntax = (() => {
     // tokens (e.g. `\sqrt\frac12` or `\sqrt\operatorname{speed}`).
     parseToken() {
       this.skipSpace();
-      const excluding = [
-        ...'!"#$%&(),/;:?@[]\\`|~'.split(""),
-        "\\left",
-        "\\bigl",
-        "\\mleft"
-      ];
-      if (excluding.includes(this.peek)) return null;
+      if (PARSE_TOKEN_EXCLUDED.has(this.peek)) return null;
       if (/^[0-9]$/.test(this.peek)) return parseInt(this.nextToken(), 10);
       return this.parseGenericExpression() ?? this.parseSymbol();
     }
@@ -13877,7 +14287,7 @@ var LatexSyntax = (() => {
       const start = this.index;
       let result = "";
       let level = 0;
-      while (!this.atBoundary || level > 0) {
+      while (!this.atEnd && (!this.atBoundary || level > 0)) {
         const token = this.nextToken();
         if (token === "<$>" || token === "<$$>") {
           this.index = start;
@@ -14264,66 +14674,6 @@ var LatexSyntax = (() => {
         this.index = start;
         return null;
       }
-      const BARE_FUNCTION_MAP = {
-        // Trigonometric
-        sin: "Sin",
-        cos: "Cos",
-        tan: "Tan",
-        cot: "Cot",
-        sec: "Sec",
-        csc: "Csc",
-        // Hyperbolic
-        sinh: "Sinh",
-        cosh: "Cosh",
-        tanh: "Tanh",
-        coth: "Coth",
-        sech: "Sech",
-        csch: "Csch",
-        // Inverse trigonometric
-        arcsin: "Arcsin",
-        arccos: "Arccos",
-        arctan: "Arctan",
-        arccot: "Arccot",
-        arcsec: "Arcsec",
-        arccsc: "Arccsc",
-        asin: "Arcsin",
-        acos: "Arccos",
-        atan: "Arctan",
-        // Inverse hyperbolic
-        arcsinh: "Arsinh",
-        arccosh: "Arcosh",
-        arctanh: "Artanh",
-        arccoth: "Arcoth",
-        arcsech: "Arsech",
-        arccsch: "Arcsch",
-        asinh: "Arsinh",
-        acosh: "Arcosh",
-        atanh: "Artanh",
-        // Logarithms and exponentials
-        log: "Log",
-        ln: "Ln",
-        exp: "Exp",
-        lg: "Lg",
-        lb: "Lb",
-        // Other common functions
-        sqrt: "Sqrt",
-        abs: "Abs",
-        sgn: "Sgn",
-        sign: "Sgn",
-        floor: "Floor",
-        ceil: "Ceil",
-        round: "Round",
-        max: "Max",
-        min: "Min",
-        gcd: "Gcd",
-        lcm: "Lcm",
-        // Roots
-        cbrt: "Root",
-        // Special-cased below to add index 3
-        // Combinatorics
-        binom: "Binomial",
-        nCr: "Binomial"
-      };
       const fnName = BARE_FUNCTION_MAP[name];
       if (!fnName) {
         this.index = start;
@@ -14504,9 +14854,7 @@ var LatexSyntax = (() => {
       }
       let result = lhs;
       if (subscripts.length > 0) {
-        const defs = [...this.getDefs("infix")].filter(
-          (x) => x.latexTrigger === "_"
-        );
+        const defs = this._dictionary.infixByTrigger.get("_") ?? [];
         if (defs) {
           const arg = [
             "Subscript",
@@ -14522,9 +14870,7 @@ var LatexSyntax = (() => {
         }
       }
       if (superscripts.length > 0) {
-        const defs = [...this.getDefs("infix")].filter(
-          (x) => x.latexTrigger === "^"
-        );
+        const defs = this._dictionary.infixByTrigger.get("^") ?? [];
         if (defs) {
           const nonEmptySuperscripts = superscripts.filter(
             (x) => !isEmptySequence(x)
@@ -14738,6 +15084,15 @@ var LatexSyntax = (() => {
       if (result === null) {
         result = this.options.parseUnexpectedToken?.(null, this) ?? null;
         if (result === null && this.peek.startsWith("\\")) {
+          if (this.peek === "\\") {
+            const saved = this.index;
+            this.nextToken();
+            this.skipVisualSpace();
+            if (this.atEnd) {
+              return this.decorate(null, start);
+            }
+            this.index = saved;
+          }
           this.nextToken();
           result = this.error("unexpected-command", start);
         }
@@ -14884,14 +15239,6 @@ var LatexSyntax = (() => {
       }
     }
   };
-  function parseComplexId(parser, id) {
-    const start = parser.index;
-    const candidate = parseSymbol(parser)?.trim();
-    if (candidate === null) return 0;
-    const result = candidate !== id ? 0 : parser.index - start;
-    parser.index = start;
-    return result;
-  }
   function isDelimiterCommand(parser) {
     const command = parser.peek;
     if (Object.values(CLOSE_DELIMITER).includes(command) || CLOSE_DELIMITER[command]) {
@@ -15388,9 +15735,9 @@ var LatexSyntax = (() => {
       if ((openFence === "." || closeFence === ".") && style === "normal")
         style = "scaled";
       if (style === "scaled")
-        return `\\left${openFence}${s}\\right${closeFence}}`;
+        return `\\left${openFence}${s}\\right${closeFence}`;
       if (style === "big")
-        return `${`\\Bigl${openFence}`}${s}${`\\Bigr${closeFence}`})`;
+        return `\\Bigl${openFence}${s}\\Bigr${closeFence}`;
       return openFence + s + closeFence;
     }
     wrapArguments(expr) {
@@ -15467,6 +15814,55 @@ var LatexSyntax = (() => {
       return this.options.numericSetStyle(expr, level);
     }
   };
+  var _latexBySymbolName = null;
+  function getLatexBySymbolName() {
+    if (!_latexBySymbolName) {
+      _latexBySymbolName = /* @__PURE__ */ new Map();
+      for (const [name, latex] of SYMBOLS)
+        if (!_latexBySymbolName.has(name)) _latexBySymbolName.set(name, latex);
+    }
+    return _latexBySymbolName;
+  }
+  var _latexByCodepoint = null;
+  function getLatexByCodepoint() {
+    if (!_latexByCodepoint) {
+      _latexByCodepoint = /* @__PURE__ */ new Map();
+      for (const [, latex, codepoint] of SYMBOLS)
+        if (!_latexByCodepoint.has(codepoint))
+          _latexByCodepoint.set(codepoint, latex);
+    }
+    return _latexByCodepoint;
+  }
+  var SPELLED_OUT_DIGITS = /* @__PURE__ */ new Map([
+    ["zero", "0"],
+    ["one", "1"],
+    ["two", "2"],
+    ["three", "3"],
+    ["four", "4"],
+    ["five", "5"],
+    ["six", "6"],
+    ["seven", "7"],
+    ["eight", "8"],
+    ["nine", "9"],
+    ["ten", "10"]
+  ]);
+  var EXTRA_SYMBOLS = /* @__PURE__ */ new Map([
+    ["plus", "+"],
+    ["minus", "-"],
+    ["pm", "\\pm"],
+    ["ast", "\\ast"],
+    ["dag", "\\dag"],
+    ["ddag", "\\ddag"],
+    ["hash", "\\#"],
+    ["bottom", "\\bot"],
+    ["top", "\\top"],
+    ["bullet", "\\bullet"],
+    ["circle", "\\circ"],
+    ["diamond", "\\diamond"],
+    ["times", "\\times"],
+    ["square", "\\square"],
+    ["star", "\\star"]
+  ]);
   function specialName(s) {
     const unicodeMatch = s.match(/^____([0-9A-Fa-f]{6})(.*)/s);
     if (unicodeMatch) {
@@ -15475,51 +15871,18 @@ var LatexSyntax = (() => {
       return [`\\unicode{"${paddedHex}}`, unicodeMatch[2]];
     }
     const prefix = s.match(/^([^_]+)/)?.[1] ?? "";
-    let i = SYMBOLS.findIndex((x) => prefix === x[0]);
-    if (i >= 0) return [SYMBOLS[i][1], s.substring(SYMBOLS[i][0].length)];
-    const DIGITS = {
-      zero: "0",
-      one: "1",
-      two: "2",
-      three: "3",
-      four: "4",
-      five: "5",
-      six: "6",
-      seven: "7",
-      eight: "8",
-      nine: "9",
-      ten: "10"
-    };
-    i = Object.keys(DIGITS).findIndex((x) => s.startsWith(x));
-    if (i >= 0) {
-      const key = Object.keys(DIGITS)[i];
-      return [DIGITS[key], s.substring(key.length)];
-    }
+    const symbolLatex = getLatexBySymbolName().get(prefix);
+    if (symbolLatex !== void 0)
+      return [symbolLatex, s.substring(prefix.length)];
+    const digit = SPELLED_OUT_DIGITS.get(prefix);
+    if (digit !== void 0) return [digit, s.substring(prefix.length)];
     const code = s.codePointAt(0);
-    i = SYMBOLS.findIndex((x) => x[2] === code);
-    if (i >= 0) return [SYMBOLS[i][1], s.substring(1)];
-    const EXTRA_SYMBOLS = {
-      plus: "+",
-      minus: "-",
-      pm: "\\pm",
-      ast: "\\ast",
-      dag: "\\dag",
-      ddag: "\\ddag",
-      hash: "\\#",
-      bottom: "\\bot",
-      top: "\\top",
-      bullet: "\\bullet",
-      circle: "\\circ",
-      diamond: "\\diamond",
-      times: "\\times",
-      square: "\\square",
-      star: "\\star"
-    };
-    i = Object.keys(EXTRA_SYMBOLS).findIndex((x) => prefix === x);
-    if (i >= 0) {
-      const key = Object.keys(EXTRA_SYMBOLS)[i];
-      return [EXTRA_SYMBOLS[key], s.substring(key.length)];
+    if (code !== void 0) {
+      const latex = getLatexByCodepoint().get(code);
+      if (latex !== void 0) return [latex, s.substring(1)];
     }
+    const extra = EXTRA_SYMBOLS.get(prefix);
+    if (extra !== void 0) return [extra, s.substring(prefix.length)];
     return [prefix, s.substring(prefix.length)];
   }
   function parseModifiers(s) {
@@ -15754,7 +16117,7 @@ var LatexSyntax = (() => {
   }
 
   // src/latex-syntax.ts
-  var version = "0.57.0";
+  var version = "0.59.0";
   return __toCommonJS(latex_syntax_exports);
 })();
 Object.assign(exports, LatexSyntax); Object.defineProperty(exports, '__esModule', { value: true });}));