@cortex-js/compute-engine 0.55.6 → 0.57.0

package/dist/interval.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.55.6 */
+/** Compute Engine 0.57.0 */
 
 // src/compute-engine/interval/util.ts
 function ok(value) {
@@ -3119,6 +3119,7 @@ var SCALAR_TYPES = [
 ];
 var VALUE_TYPES = [
   "value",
+  "color",
   ...COLLECTION_TYPES,
   ...SCALAR_TYPES
 ];
@@ -4770,6 +4771,7 @@ var PRIMITIVE_SUBTYPES = {
   symbol: [],
   boolean: [],
   string: [],
+  color: [],
   expression: EXPRESSION_TYPES
 };
 function isPrimitiveSubtype(lhs, rhs) {
@@ -5920,6 +5922,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"];
@@ -6391,6 +6451,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",
@@ -6411,6 +6480,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: ["_"],
@@ -6493,6 +6585,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",
@@ -6677,13 +6792,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),
@@ -6695,13 +6821,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
       ]);
     }
   },
@@ -6734,6 +6874,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",
@@ -6938,7 +7090,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];
     }
@@ -7379,7 +7534,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 === ".;.") {
@@ -7392,12 +7552,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);
@@ -7649,6 +7834,35 @@ 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;
+      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,
@@ -9537,6 +9751,8 @@ var DEFINITIONS_ARITHMETIC = [
     precedence: DIVISION_PRECEDENCE,
     parse: "Mod"
   },
+  // Function-style alias: `\operatorname{mod}(a, b)`
+  { latexTrigger: "\\operatorname{mod}", parse: "Mod" },
   {
     latexTrigger: "\\pmod",
     kind: "prefix",
@@ -9777,6 +9993,13 @@ var DEFINITIONS_ARITHMETIC = [
       const rhs = serializer.wrap(operand(expr, 2), ADDITION_PRECEDENCE + 3);
       return joinLatex([lhs, "-", rhs]);
     }
+  },
+  // Euclidean distance between two points (tuples of numbers).
+  {
+    name: "Distance",
+    latexTrigger: ["\\operatorname{distance}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{distance}" + serializer.wrapArguments(expr)
   }
 ];
 function getIndexAssignment(expr, upper) {
@@ -11201,7 +11424,9 @@ var DEFINITIONS_STATISTICS = [
       if (!expr || !symbol(expr)) return null;
       return ["Mean", expr];
     }
-  }
+  },
+  // Function-style alias: `\operatorname{var}(...)`
+  { latexTrigger: "\\operatorname{var}", parse: "Variance" }
 ];
 
 // src/compute-engine/numerics/unit-data.ts
@@ -12209,7 +12434,7 @@ var DEFINITIONS_OTHERS = [
         36: "\\qquad"
       }[v] ?? "";
     }
-  }
+  },
   // if (
   //   [
   //     '\\!',
@@ -12233,6 +12458,121 @@ var DEFINITIONS_OTHERS = [
   //     name: '',
   //     trigger: '\\check',
   // },
+  // ---------------------------------------------------------------------------
+  // Function-style aliases for collection / random operators that some
+  // notations write in lowercase (e.g. `\operatorname{shuffle}(L)`).
+  // The capitalized library entries already exist; these are pure parse
+  // aliases so the lowercase names don't land in `unsupported-operator`.
+  // ---------------------------------------------------------------------------
+  { latexTrigger: "\\operatorname{random}", parse: "Random" },
+  { latexTrigger: "\\operatorname{shuffle}", parse: "Shuffle" },
+  { latexTrigger: "\\operatorname{repeat}", parse: "Repeat" },
+  { latexTrigger: "\\operatorname{join}", parse: "Join" },
+  // ---------------------------------------------------------------------------
+  // Geometric primitive heads. Registered as known typed heads so consumers
+  // can branch on the operator name; CE itself doesn't render them. The
+  // library entries (with no evaluator) live in `library/core.ts`.
+  // ---------------------------------------------------------------------------
+  {
+    name: "Triangle",
+    latexTrigger: ["\\operatorname{triangle}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{triangle}" + serializer.wrapArguments(expr)
+  },
+  // Desmos's geometric `vector(p1, p2)` — a directed segment between two
+  // points. Routed to a dedicated head (not the existing column-vector
+  // `Vector`, which has a narrower `(number+) -> vector` signature).
+  {
+    name: "GeometricVector",
+    latexTrigger: ["\\operatorname{vector}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{vector}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "Sphere",
+    latexTrigger: ["\\operatorname{sphere}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{sphere}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "Segment",
+    latexTrigger: ["\\operatorname{segment}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{segment}" + serializer.wrapArguments(expr)
+  }
+];
+
+// src/compute-engine/latex-syntax/dictionary/definitions-colors.ts
+var DEFINITIONS_COLORS = [
+  // Color constructors (one per colorspace, preserves space on evaluation)
+  {
+    name: "Rgb",
+    latexTrigger: ["\\operatorname{rgb}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{rgb}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "Hsv",
+    latexTrigger: ["\\operatorname{hsv}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{hsv}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "Hsl",
+    latexTrigger: ["\\operatorname{hsl}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{hsl}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "Oklab",
+    latexTrigger: ["\\operatorname{oklab}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{oklab}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "Oklch",
+    latexTrigger: ["\\operatorname{oklch}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{oklch}" + serializer.wrapArguments(expr)
+  },
+  // Conversion functions (color → color in the named space)
+  {
+    name: "AsRgb",
+    latexTrigger: ["\\operatorname{asRgb}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{asRgb}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "AsHsv",
+    latexTrigger: ["\\operatorname{asHsv}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{asHsv}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "AsHsl",
+    latexTrigger: ["\\operatorname{asHsl}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{asHsl}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "AsOklab",
+    latexTrigger: ["\\operatorname{asOklab}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{asOklab}" + serializer.wrapArguments(expr)
+  },
+  {
+    name: "AsOklch",
+    latexTrigger: ["\\operatorname{asOklch}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{asOklch}" + serializer.wrapArguments(expr)
+  },
+  // Perceptual difference (returns a scalar in [0, ~1])
+  {
+    name: "ColorDelta",
+    latexTrigger: ["\\operatorname{colorDelta}"],
+    kind: "function",
+    serialize: (serializer, expr) => "\\operatorname{colorDelta}" + serializer.wrapArguments(expr)
+  }
 ];
 
 // src/compute-engine/latex-syntax/dictionary/default-dictionary.ts
@@ -12263,7 +12603,8 @@ var LATEX_DICTIONARY = [
   ...DEFINITIONS_STATISTICS,
   ...DEFINITIONS_UNITS,
   ...DEFINITIONS_OTHERS,
-  ...DEFINITIONS_PHYSICS
+  ...DEFINITIONS_PHYSICS,
+  ...DEFINITIONS_COLORS
 ];
 
 // src/math-json/symbols.ts
@@ -13405,7 +13746,7 @@ var IntervalArithmetic = {
 };
 
 // src/interval.ts
-var version = "0.55.6";
+var version = "0.57.0";
 export {
   IntervalArithmetic,
   _mul,