@cortex-js/compute-engine 0.56.0 → 0.57.0

package/dist/interval.umd.cjs

@@ -1,4 +1,4 @@
-/** Interval 0.56.0 */
+/** Interval 0.57.0 */
     (function(global,factory){typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'],factory):(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Interval = {}));})(this, (function (exports) { 'use strict';
 var Interval = (() => {
   var __defProp = Object.defineProperty;
@@ -6041,6 +6041,64 @@ var Interval = (() => {
   }
 
   // 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"];
@@ -6512,6 +6570,15 @@ var Interval = (() => {
       }
     },
     { 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",
@@ -6532,6 +6599,29 @@ var Interval = (() => {
       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: ["_"],
@@ -6614,6 +6704,29 @@ var Interval = (() => {
         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",
@@ -6798,13 +6911,24 @@ var Interval = (() => {
         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),
@@ -6816,13 +6940,27 @@ var Interval = (() => {
               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
         ]);
       }
     },
@@ -6855,6 +6993,18 @@ var Interval = (() => {
       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",
@@ -7059,7 +7209,10 @@ var Interval = (() => {
         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];
       }
@@ -7500,7 +7653,12 @@ var Interval = (() => {
     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 === ".;.") {
@@ -7513,12 +7671,37 @@ var Interval = (() => {
       }
       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);
@@ -7770,6 +7953,35 @@ var Interval = (() => {
       ["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;
+        return isComma;
+      }
+    };
+    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,
@@ -13653,7 +13865,7 @@ var Interval = (() => {
   };
 
   // src/interval.ts
-  var version = "0.56.0";
+  var version = "0.57.0";
   return __toCommonJS(interval_exports);
 })();
 /*! Bundled license information: