@cortex-js/compute-engine 0.56.0 → 0.58.0

package/dist/latex-syntax.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.56.0 */
+/** Compute Engine 0.58.0 */
 
 // src/math-json/utils.ts
 var MISSING = ["Error", "'missing'"];
@@ -3126,7 +3126,42 @@ function widen2(a, b) {
   if (b === "nothing") return a;
   if (isSubtype(a, b)) return b;
   if (isSubtype(b, a)) return a;
-  return superType(a, b);
+  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 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 (!members.some(
+      (m) => (typeof m === "string" ? m : JSON.stringify(m)) === 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";
@@ -3681,6 +3716,64 @@ function parseQuantifier(kind) {
 }
 
 // src/compute-engine/latex-syntax/dictionary/definitions-core.ts
+var COMPONENT_ACCESS_HEADS = {
+  x: "First",
+  y: "Second",
+  z: "Third",
+  real: "Real",
+  re: "Real",
+  imag: "Imaginary",
+  im: "Imaginary",
+  count: "Length",
+  total: "Sum",
+  max: "Max",
+  min: "Min"
+};
+function memberHead(name) {
+  return COMPONENT_ACCESS_HEADS[name] ?? null;
+}
+function parseComponentAccess(parser, lhs) {
+  parser.skipVisualSpace();
+  if (parser.match("\\operatorname")) {
+    const name = parser.parseStringGroup();
+    if (name === null) return null;
+    const head = memberHead(name.trim());
+    if (head === null) return null;
+    return [head, lhs];
+  }
+  const tok = parser.peek;
+  if (typeof tok === "string" && tok.startsWith("\\")) {
+    const bare = tok.slice(1);
+    const head = memberHead(bare);
+    if (head !== null) {
+      parser.nextToken();
+      return [head, lhs];
+    }
+    return null;
+  }
+  if (typeof tok === "string" && /^[a-zA-Z]$/.test(tok)) {
+    const head = memberHead(tok);
+    if (head === null) return null;
+    parser.nextToken();
+    return [head, lhs];
+  }
+  return null;
+}
+function parseWhenRestriction(parser, lhs, close) {
+  parser.addBoundary(close);
+  parser.skipVisualSpace();
+  const cond = parser.parseExpression({ minPrec: 0 });
+  if (cond === null) {
+    parser.removeBoundary();
+    return null;
+  }
+  parser.skipVisualSpace();
+  if (!parser.matchBoundary()) {
+    parser.removeBoundary();
+    return null;
+  }
+  return ["When", lhs, cond];
+}
 function parseSequence(parser, terminator, lhs, prec, sep) {
   if (terminator && terminator.minPrec >= prec) return null;
   const result = lhs ? [lhs] : ["Nothing"];
@@ -3956,15 +4049,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",
@@ -3975,7 +4069,7 @@ var DEFINITIONS_CORE = [
     latexTrigger: "\\colon",
     kind: "infix",
     associativity: "right",
-    precedence: 250,
+    precedence: 240,
     parse: "Colon"
   },
   {
@@ -4152,6 +4246,15 @@ var DEFINITIONS_CORE = [
     }
   },
   { name: "LatexTokens", serialize: serializeLatexTokens },
+  // Component-access postfix: expr.member  (C3)
+  // The '.' trigger is consumed before the parse function is called.
+  // Precedence 850 > 810 (At/indexing) so .x chains tightly.
+  {
+    kind: "postfix",
+    precedence: 850,
+    latexTrigger: ["."],
+    parse: parseComponentAccess
+  },
   {
     name: "At",
     kind: "postfix",
@@ -4172,6 +4275,29 @@ var DEFINITIONS_CORE = [
     latexTrigger: ["\\left", "\\lbrack"],
     parse: parseAt("\\right", "\\rbrack")
   },
+  // When-restriction: `expr\left\{cond\right\}` → `When(expr, cond)` (D3)
+  {
+    name: "When",
+    kind: "postfix",
+    precedence: 800,
+    latexTrigger: ["\\left", "\\{"],
+    parse: (parser, lhs) => parseWhenRestriction(parser, lhs, ["\\right", "\\}"]),
+    serialize: (serializer, expr) => {
+      const e = operand(expr, 1);
+      const cond = operand(expr, 2);
+      if (!e || !cond) return "";
+      const clauses = operator(cond) === "And" ? operands(cond) ?? [] : [cond];
+      const inner = clauses.map((c) => `\\left\\{${serializer.serialize(c)}\\right\\}`).join("");
+      return `${serializer.serialize(e)}${inner}`;
+    }
+  },
+  // When-restriction: bare `expr\{cond\}` → `When(expr, cond)`
+  {
+    kind: "postfix",
+    precedence: 800,
+    latexTrigger: ["\\{"],
+    parse: (parser, lhs) => parseWhenRestriction(parser, lhs, ["\\}"])
+  },
   {
     kind: "postfix",
     latexTrigger: ["_"],
@@ -4254,6 +4380,29 @@ var DEFINITIONS_CORE = [
       return "";
     }
   },
+  // Additional triggers for Range: `...`, `\ldots`, and `\dots` are
+  // equivalent to `..` when used as infix operators (e.g. `[1...9]`).
+  // No `name` field here — names must be unique per the dictionary rules;
+  // the first Range entry owns the name. When there is no LHS the symbol
+  // entries near the top of the file still fire (ContinuationPlaceholder).
+  {
+    latexTrigger: [".", ".", "."],
+    kind: "infix",
+    precedence: 800,
+    parse: parseRange
+  },
+  {
+    latexTrigger: ["\\ldots"],
+    kind: "infix",
+    precedence: 800,
+    parse: parseRange
+  },
+  {
+    latexTrigger: ["\\dots"],
+    kind: "infix",
+    precedence: 800,
+    parse: parseRange
+  },
   {
     latexTrigger: [";"],
     kind: "infix",
@@ -4438,13 +4587,24 @@ var DEFINITIONS_CORE = [
       const args = operands(expr);
       if (!args || args.length < 2) return "";
       const body = args[0];
-      const indexing = args[1];
-      if (operator(indexing) === "Element") {
-        const index = operand(indexing, 1);
-        const range = operand(indexing, 2);
-        if (operator(range) === "Range") {
-          const lo = operand(range, 1);
-          const hi = operand(range, 2);
+      const elements = args.slice(1);
+      const allElements = elements.every((e) => operator(e) === "Element");
+      if (!allElements) {
+        return joinLatex([
+          "\\operatorname{Loop}(",
+          serializer.serialize(body),
+          ", ",
+          serializer.serialize(elements[0]),
+          ")"
+        ]);
+      }
+      if (elements.length === 1) {
+        const elem = elements[0];
+        const index = operand(elem, 1);
+        const coll = operand(elem, 2);
+        if (operator(coll) === "Range") {
+          const lo = operand(coll, 1);
+          const hi = operand(coll, 2);
           return joinLatex([
             "\\text{for }",
             serializer.serialize(index),
@@ -4456,13 +4616,27 @@ var DEFINITIONS_CORE = [
             serializer.serialize(body)
           ]);
         }
+        return joinLatex([
+          serializer.serialize(body),
+          " \\operatorname{for} ",
+          serializer.serialize(index),
+          " = ",
+          serializer.serialize(coll)
+        ]);
       }
+      const bindings = elements.map((elem) => {
+        const name = operand(elem, 1);
+        const coll = operand(elem, 2);
+        return joinLatex([
+          serializer.serialize(name),
+          " = ",
+          serializer.serialize(coll)
+        ]);
+      }).join(", ");
       return joinLatex([
-        "\\operatorname{Loop}(",
         serializer.serialize(body),
-        ", ",
-        serializer.serialize(indexing),
-        ")"
+        " \\operatorname{for} ",
+        bindings
       ]);
     }
   },
@@ -4495,6 +4669,18 @@ var DEFINITIONS_CORE = [
     precedence: 245,
     parse: (parser, until) => parseForExpression(parser, until)
   },
+  // \operatorname{for} as postfix infix (list comprehension):
+  //   `body \operatorname{for} x = L_1, y = L_2`
+  // Precedence 19 — just below comma (20) so the body is allowed to use
+  // any operator (including comma sequencing) up to the keyword, and the
+  // bindings can be comma-separated below us.
+  {
+    symbolTrigger: "for",
+    kind: "infix",
+    associativity: "none",
+    precedence: 19,
+    parse: (parser, lhs, until) => parseForComprehension(parser, lhs, until)
+  },
   // \operatorname{break}
   {
     symbolTrigger: "break",
@@ -4699,7 +4885,10 @@ var DEFINITIONS_CORE = [
       if (!sym || !parser.getSymbolType(sym).matches("function")) return null;
       parser.addBoundary([")"]);
       const expr = parser.parseExpression(until);
-      if (!parser.matchBoundary()) return null;
+      if (!parser.matchBoundary()) {
+        parser.removeBoundary();
+        return null;
+      }
       if (!parser.match("<}>")) return null;
       return ["Derivative", lhs, expr];
     }
@@ -5140,7 +5329,12 @@ function parseBrackets(parser, body) {
   if (isEmptySequence(body)) return ["List"];
   const h = operator(body);
   if (h === "Range" || h === "Linspace") return body;
-  if (h === "Sequence") return ["List", ...operands(body)];
+  if (h === "Sequence") {
+    const elems = operands(body);
+    const inferred = tryInferRangeFromElements(elems, parser);
+    if (inferred) return inferred;
+    return ["List", ...elems];
+  }
   if (h === "Delimiter") {
     const delim = stringValue(operand(body, 2)) ?? "...";
     if (delim === ";" || delim === ".;.") {
@@ -5153,12 +5347,37 @@ function parseBrackets(parser, body) {
     }
     if (delim === "," || delim === ".,.") {
       body = operand(body, 1);
-      if (operator(body) === "Sequence") return ["List", ...operands(body)];
+      if (operator(body) === "Sequence") {
+        const elems = operands(body);
+        const inferred = tryInferRangeFromElements(elems, parser);
+        if (inferred) return inferred;
+        return ["List", ...elems];
+      }
       return ["List", body ?? "Nothing"];
     }
   }
   return ["List", body];
 }
+function tryInferRangeFromElements(elems, parser) {
+  if (elems.length < 4) return null;
+  const penultimate = elems[elems.length - 2];
+  if (symbol(penultimate) !== "ContinuationPlaceholder") return null;
+  const samples = elems.slice(0, -2);
+  const endExpr = elems[elems.length - 1];
+  if (samples.length < 2) return null;
+  const sampleNums = samples.map(machineValue);
+  if (sampleNums.some((n) => n === null)) return null;
+  const nums = sampleNums;
+  const step = nums[nums.length - 1] - nums[nums.length - 2];
+  const tol = parser.options.tolerance;
+  if (Math.abs(step) < tol)
+    return parser.error("degenerate-range-step", parser.index);
+  for (let i = 1; i < nums.length; i++) {
+    if (Math.abs(nums[i] - nums[i - 1] - step) > tol)
+      return parser.error("inconsistent-range-samples", parser.index);
+  }
+  return ["Range", nums[0], endExpr, step];
+}
 function serializeList(serializer, expr) {
   if (nops(expr) > 1 && operands(expr).every((x) => {
     const op = operator(x);
@@ -5410,6 +5629,38 @@ function parseForExpression(parser, until) {
     ["Element", index, ["Range", lower, upper]]
   ];
 }
+function parseForComprehension(parser, lhs, until) {
+  const bindingTerminator = {
+    minPrec: 21,
+    // Above comma (20) and ; (19), so `x = L_1` is captured whole
+    condition: (p) => {
+      if (until?.condition?.(p)) return true;
+      const saved = p.index;
+      p.skipVisualSpace();
+      const isComma = p.peek === ",";
+      p.index = saved;
+      if (isComma) return true;
+      if (peekKeyword(p, "where")) return true;
+      if (peekKeyword(p, "with")) return true;
+      return false;
+    }
+  };
+  const elements = [];
+  do {
+    parser.skipVisualSpace();
+    const binding = parser.parseExpression(bindingTerminator);
+    if (binding === null) break;
+    const op = operator(binding);
+    if (op !== "Equal" && op !== "Assign") return null;
+    const name = operand(binding, 1);
+    const list = operand(binding, 2);
+    if (!name || !list) return null;
+    elements.push(["Element", name, list]);
+    parser.skipVisualSpace();
+  } while (parser.match(","));
+  if (elements.length === 0) return null;
+  return ["Loop", lhs, ...elements];
+}
 function parseWhereExpression(parser, lhs, until) {
   const bindingTerminator = {
     minPrec: 21,
@@ -5432,6 +5683,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);
@@ -5645,6 +5915,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
@@ -5903,18 +6184,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") {
@@ -7918,7 +8239,8 @@ 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 head = fn === "Arctan" && args?.length === 2 ? "Arctan2" : fn;
+    const appliedFn = args === null ? fn : typeof head === "string" ? [head, ...args] : ["Apply", head, ...args];
     return sup === null ? appliedFn : ["Power", appliedFn, sup];
   };
 }
@@ -10041,10 +10363,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
@@ -14466,6 +14795,19 @@ var _Parser = class __Parser {
       } while (postfix !== null);
     }
     if (result !== null) result = this.parseSupsub(result);
+    if (result !== null) {
+      let postfix = null;
+      let index = this.index;
+      do {
+        postfix = this.parsePostfixOperator(result, until);
+        result = postfix ?? result;
+        if (this.index === index && postfix !== null) {
+          console.assert(this.index !== index, "No token consumed");
+          break;
+        }
+        index = this.index;
+      } while (postfix !== null);
+    }
     if (result === null) {
       result = this.options.parseUnexpectedToken?.(null, this) ?? null;
       if (result === null && this.peek.startsWith("\\")) {
@@ -14974,6 +15316,28 @@ function toDecimalNumber(wholePart, fractionalPart, exp) {
 }
 
 // src/compute-engine/latex-syntax/serializer.ts
+var DOT_NOTATION_MAP = {
+  First: ".x",
+  Second: ".y",
+  Third: ".z",
+  Real: ".\\operatorname{real}",
+  Imaginary: ".\\operatorname{imag}",
+  Length: ".\\operatorname{count}",
+  Sum: ".\\operatorname{total}",
+  Max: ".\\max",
+  Min: ".\\min"
+};
+function trySerializeDotNotation(serializer, expr) {
+  if (!serializer.options.dotNotation) return null;
+  const ops = operands(expr);
+  if (!ops || ops.length !== 1) return null;
+  const head = operator(expr);
+  if (!head) return null;
+  const suffix = DOT_NOTATION_MAP[head];
+  if (suffix === void 0) return null;
+  const lhs = serializer.wrap(ops[0], 810);
+  return `${lhs}${suffix}`;
+}
 var ACCENT_MODIFIERS = {
   deg: (s) => `${s}\\degree`,
   prime: (s) => `${s}^{\\prime}`,
@@ -15017,6 +15381,7 @@ var Serializer5 = class {
   constructor(dictionary, options) {
     this.dictionary = dictionary;
     this.options = {
+      dotNotation: false,
       dmsFormat: false,
       angleNormalization: "none",
       ...options
@@ -15115,6 +15480,8 @@ var Serializer5 = class {
     return def?.serialize?.(this, expr) ?? serializeSymbol(symbol(expr)) ?? "";
   }
   serializeFunction(expr, def) {
+    const dotResult = trySerializeDotNotation(this, expr);
+    if (dotResult !== null) return dotResult;
     if (def?.serialize) return def.serialize(this, expr);
     const h = operator(expr);
     return serializeSymbol(h, "auto") + this.wrapArguments(expr);
@@ -15357,6 +15724,8 @@ function defaultParseOptions(opts) {
     preserveLatex: opts.preserveLatex ?? false,
     quantifierScope: opts.quantifierScope ?? "tight",
     timeDerivativeVariable: opts.timeDerivativeVariable ?? "t",
+    // Standalone mode has no engine; use the same default as ComputeEngine
+    tolerance: 1e-7,
     // Callbacks -- standalone mode has no engine, so these are stubs
     getSymbolType: (_id) => BoxedType.unknown,
     hasSubscriptEvaluate: (_id) => false,
@@ -15389,6 +15758,7 @@ function defaultSerializeOptions(opts) {
     invisiblePlus: "",
     multiply: "\\times",
     missingSymbol: "\\blacksquare",
+    dotNotation: false,
     dmsFormat: false,
     angleNormalization: "none",
     // Style callbacks -- use same defaults as the engine
@@ -15457,7 +15827,7 @@ function serialize(expr) {
 }
 
 // src/latex-syntax.ts
-var version = "0.56.0";
+var version = "0.58.0";
 export {
   DEFINITIONS_ALGEBRA as ALGEBRA_DICTIONARY,
   DEFINITIONS_ARITHMETIC as ARITHMETIC_DICTIONARY,