@cortex-js/compute-engine 0.57.0 → 0.59.0

package/dist/latex-syntax.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.57.0 */
+/** Compute Engine 0.59.0 */
 
 // src/math-json/utils.ts
 var MISSING = ["Error", "'missing'"];
@@ -92,12 +92,14 @@ function dictionaryFromExpression(expr) {
   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";
       }
@@ -436,11 +438,27 @@ var UNICODE_SUBSCRIPT_MAP = {
   "\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) => {
@@ -453,6 +471,19 @@ var Tokenizer = class {
     });
     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
@@ -476,12 +507,13 @@ var Tokenizer = class {
    * 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];
@@ -588,25 +620,13 @@ function expand(lex, args) {
       }
     }
   } 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") {
@@ -679,7 +699,7 @@ function tokensToString(tokens) {
   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);
       }
@@ -1164,172 +1184,23 @@ var PRIMITIVE_TYPES = [
   "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
@@ -2039,19 +1910,13 @@ var Parser = class {
     );
     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();
           }
         }
       }
@@ -2092,19 +1957,13 @@ var Parser = class {
     );
     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();
           }
         }
       }
@@ -2135,16 +1994,30 @@ var Parser = class {
     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;
   }
@@ -2158,35 +2031,11 @@ var Parser = class {
     }
     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") {
@@ -2371,6 +2220,18 @@ var Parser = class {
           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,
@@ -2385,7 +2246,7 @@ var Parser = class {
   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 });
       }
@@ -2719,14 +2580,32 @@ function buildTypeFromAST(node, typeResolver) {
 }
 
 // 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(
@@ -2801,19 +2680,36 @@ var PRIMITIVE_SUBTYPES = {
   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";
@@ -2828,7 +2724,7 @@ function isSubtype(lhs, rhs) {
       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);
@@ -3054,127 +2950,340 @@ function isSubtype(lhs, rhs) {
     }
     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
@@ -4014,15 +4123,16 @@ var DEFINITIONS_CORE = [
     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",
@@ -4033,7 +4143,7 @@ var DEFINITIONS_CORE = [
     latexTrigger: "\\colon",
     kind: "infix",
     associativity: "right",
-    precedence: 250,
+    precedence: 240,
     parse: "Colon"
   },
   {
@@ -5009,6 +5119,7 @@ var DEFINITIONS_CORE = [
         }
       }
       if (!variable) return null;
+      if (symbol(variable) === null) return null;
       parser.skipSpace();
       const fn = parser.parseExpression({ minPrec: 740 });
       if (!fn) return null;
@@ -5195,7 +5306,7 @@ function parseTextRun(parser, style) {
   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;
@@ -5603,7 +5714,10 @@ function parseForComprehension(parser, lhs, until) {
       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 = [];
@@ -5644,6 +5758,25 @@ function parseWhereExpression(parser, lhs, until) {
     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);
@@ -5857,6 +5990,17 @@ function parseIntervalBody(body, openLeft, openRight) {
   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
@@ -6115,18 +6259,58 @@ var DEFINITIONS_SETS = [
     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") {
@@ -6685,6 +6869,8 @@ function serializeMultiply(serializer, expr) {
       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 {
@@ -8130,7 +8316,9 @@ function parseTrig(op) {
       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];
   };
 }
@@ -10253,10 +10441,17 @@ var DEFINITIONS_OTHERS = [
   // 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
@@ -10629,10 +10824,41 @@ function indexLatexDictionary(dic, onError) {
     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"],
@@ -10997,7 +11223,7 @@ function isValidEntry(entry, onError) {
     }
   }
   if (isMatchfixEntry(entry)) {
-    if ("latexTrigger" in entry || "symbolTrigger" in isPrefixEntry) {
+    if ("latexTrigger" in entry || "symbolTrigger" in entry) {
       onError({
         severity: "warning",
         message: [
@@ -11096,6 +11322,15 @@ function isValidEntry(entry, onError) {
 }
 
 // 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.
@@ -11174,10 +11409,10 @@ function parseSymbolToken(parser, options) {
     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) {
@@ -11274,11 +11509,12 @@ function matchPrefixedSymbol(parser) {
       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;
   }
@@ -11489,6 +11725,7 @@ function fpexp(x, scale) {
   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);
@@ -12138,9 +12375,11 @@ var BigDecimal = class _BigDecimal {
     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;
@@ -12185,7 +12424,10 @@ var BigDecimal = class _BigDecimal {
         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;
@@ -12218,7 +12460,19 @@ var BigDecimal = class _BigDecimal {
       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. */
@@ -12459,6 +12713,20 @@ function fromFixedPoint(fp, scale, targetPrecision) {
   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;
@@ -12469,9 +12737,13 @@ BigDecimal.prototype.sqrt = function() {
   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;
@@ -12485,10 +12757,13 @@ BigDecimal.prototype.cbrt = function() {
   }
   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);
@@ -12517,7 +12792,8 @@ BigDecimal.prototype.cbrt = function() {
     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();
@@ -12532,11 +12808,27 @@ BigDecimal.prototype.exp = function() {
     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;
@@ -12548,10 +12840,16 @@ BigDecimal.prototype.ln = function() {
   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);
@@ -12571,7 +12869,10 @@ BigDecimal.prototype.sin = function() {
   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);
@@ -12582,6 +12883,8 @@ BigDecimal.prototype.cos = function() {
   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);
@@ -12591,7 +12894,10 @@ BigDecimal.prototype.tan = function() {
   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) {
@@ -12609,7 +12915,9 @@ BigDecimal.prototype.atan = function() {
     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);
@@ -12626,7 +12934,9 @@ BigDecimal.prototype.asin = function() {
     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;
@@ -12689,6 +12999,23 @@ BigDecimal.prototype.sinh = function() {
     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);
@@ -12699,6 +13026,9 @@ BigDecimal.prototype.cosh = function() {
   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);
@@ -12710,6 +13040,21 @@ BigDecimal.prototype.tanh = function() {
     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));
 };
@@ -12858,7 +13203,7 @@ function mayBeRepeatingDigits(parser) {
   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;
@@ -13025,6 +13370,106 @@ function parseNumber(parser, fmt) {
 }
 
 // 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) {
@@ -13126,7 +13571,7 @@ var _Parser = class __Parser {
   }
   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;
   }
@@ -13180,6 +13625,10 @@ var _Parser = class __Parser {
   // 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;
@@ -13336,9 +13785,6 @@ var _Parser = class __Parser {
   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);
   // }
@@ -13360,77 +13806,72 @@ var _Parser = class __Parser {
    *
    */
   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;
@@ -13468,17 +13909,7 @@ var _Parser = class __Parser {
   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();
     }
@@ -13491,23 +13922,8 @@ var _Parser = class __Parser {
       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();
     }
@@ -13760,13 +14176,7 @@ var _Parser = class __Parser {
   // 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();
   }
@@ -13833,7 +14243,7 @@ var _Parser = class __Parser {
     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;
@@ -14220,66 +14630,6 @@ var _Parser = class __Parser {
       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;
@@ -14460,9 +14810,7 @@ var _Parser = class __Parser {
     }
     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",
@@ -14478,9 +14826,7 @@ var _Parser = class __Parser {
       }
     }
     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)
@@ -14694,6 +15040,15 @@ var _Parser = class __Parser {
     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);
       }
@@ -14840,14 +15195,6 @@ var _Parser = class __Parser {
     }
   }
 };
-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]) {
@@ -15344,9 +15691,9 @@ var Serializer5 = class {
     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) {
@@ -15423,6 +15770,55 @@ var Serializer5 = class {
     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) {
@@ -15431,51 +15827,18 @@ function specialName(s) {
     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) {
@@ -15710,7 +16073,7 @@ function serialize(expr) {
 }
 
 // src/latex-syntax.ts
-var version = "0.57.0";
+var version = "0.59.0";
 export {
   DEFINITIONS_ALGEBRA as ALGEBRA_DICTIONARY,
   DEFINITIONS_ARITHMETIC as ARITHMETIC_DICTIONARY,