@cortex-js/compute-engine 0.17.0 → 0.18.0

package/dist/compute-engine.esm.js

@@ -1,4 +1,4 @@
-/** CortexJS Compute Engine 0.17.0 */
+/** CortexJS Compute Engine 0.18.0 */
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -1063,7 +1063,7 @@ function isEnvironmentEntry(entry) {
 }
 
 // src/compute-engine/compute-engine.ts
-var import_complex20 = __toESM(require_complex(), 1);
+var import_complex20 = __toESM(require_complex());
 
 // node_modules/decimal.js/decimal.mjs
 var EXP_LIMIT = 9e15;
@@ -4859,8 +4859,41 @@ var DEFINITIONS_ARITHMETIC = [
     identifierTrigger: "lcm",
     kind: "function"
   },
-  { name: "Max", identifierTrigger: "max", kind: "function" },
-  { name: "Min", identifierTrigger: "min", kind: "function" },
+  { identifierTrigger: "max", kind: "function", parse: "Max" },
+  { identifierTrigger: "min", kind: "function", parse: "Min" },
+  { name: "Max", latexTrigger: "\\max", kind: "function" },
+  { name: "Min", latexTrigger: "\\min", kind: "function" },
+  { name: "Supremum", latexTrigger: "\\sup", kind: "function" },
+  { name: "Infimum", latexTrigger: "\\inf", kind: "function" },
+  {
+    name: "Limit",
+    latexTrigger: "\\lim",
+    kind: "expression",
+    parse: (parser) => {
+      if (!parser.match("_"))
+        return void 0;
+      const base = parser.parseGroup();
+      if (head(base) !== "To")
+        return void 0;
+      const expr = parser.parseArguments("implicit");
+      if (!expr)
+        return void 0;
+      return ["Limit", ["Function", expr[0], op(base, 1)], op(base, 2)];
+    },
+    serialize: (serializer, expr) => {
+      const fn = op(expr, 1);
+      const fnVar = op(fn, 2);
+      const to = op(expr, 2);
+      return joinLatex([
+        "\\lim_{",
+        serializer.serialize(fnVar),
+        "\\to",
+        serializer.serialize(to),
+        "}",
+        serializer.serialize(op(fn, 1))
+      ]);
+    }
+  },
   {
     name: "MinusPlus",
     latexTrigger: ["\\mp"],
@@ -5298,13 +5331,14 @@ var DEFINITIONS_CORE = [
   },
   {
     name: "Assign",
-    kind: "function",
     latexTrigger: "\\coloneqq",
+    kind: "infix",
+    associativity: "right",
     precedence: 260,
-    parse: (parser, lhs) => {
-      const rhs = parser.parseExpression({ minPrec: 260 }) ?? "Nothing";
-      return ["Assign", lhs, rhs];
-    },
+    // parse: (parser: Parser, lhs: Expression) => {
+    //   const rhs = parser.parseExpression({ minPrec: 260 }) ?? 'Nothing';
+    //   return ['Assign', lhs, rhs];
+    // },
     serialize: (serializer, expr) => {
       return joinLatex([
         serializer.serialize(op(expr, 1)),
@@ -5314,22 +5348,31 @@ var DEFINITIONS_CORE = [
     }
   },
   {
-    kind: "function",
-    latexTrigger: ":=",
-    // \coloneqq
-    parse: (parser, lhs) => {
-      const rhs = parser.parseExpression({ minPrec: 270 }) ?? "Nothing";
-      return ["Assign", lhs, rhs];
-    }
+    latexTrigger: [":", "="],
+    kind: "infix",
+    associativity: "right",
+    precedence: 260,
+    parse: "Assign"
   },
+  // {
+  //   kind: 'function',
+  //   latexTrigger: ':=', // \coloneqq
+  //   parse: (parser: Parser, lhs: Expression) => {
+  //     const rhs = parser.parseExpression({ minPrec: 270 }) ?? 'Nothing';
+  //     return ['Assign', lhs, rhs];
+  //   },
+  // },
   {
-    kind: "function",
     latexTrigger: "\\colonequals",
     // \coloneqq
-    parse: (parser, lhs) => {
-      const rhs = parser.parseExpression({ minPrec: 270 }) ?? "Nothing";
-      return ["Assign", lhs, rhs];
-    }
+    kind: "infix",
+    associativity: "right",
+    precedence: 260,
+    parse: "Assign"
+    // parse: (parser: Parser, lhs: Expression) => {
+    //   const rhs = parser.parseExpression({ minPrec: 270 }) ?? 'Nothing';
+    //   return ['Assign', lhs, rhs];
+    // },
   },
   {
     name: "BaseForm",
@@ -6074,13 +6117,6 @@ var DEFINITIONS_INEQUALITIES = [
     associativity: "right",
     precedence: 260
   },
-  {
-    latexTrigger: [":", "="],
-    kind: "infix",
-    associativity: "right",
-    precedence: 260,
-    parse: "Assign"
-  },
   {
     name: "Approx",
     // Note: Mathematica TildeTilde
@@ -8672,7 +8708,7 @@ var DEFAULT_PARSE_LATEX_OPTIONS = {
   applyInvisibleOperator: "auto",
   skipSpace: true,
   parseArgumentsOfUnknownLatexCommands: true,
-  parseNumbers: true,
+  parseNumbers: "auto",
   parseUnknownIdentifier: (id, parser) => parser.computeEngine?.lookupFunction(id) !== void 0 ? "function" : "symbol",
   preserveLatex: false
 };
@@ -9282,27 +9318,27 @@ var _Parser = class {
     if (this.matchAny(["e", "E"])) {
       const exponent = this.parseSignedInteger({ withGrouping: false });
       if (exponent)
-        return "e" + exponent;
+        return exponent;
     }
     this.index = start;
     if (this.match("\\times")) {
       this.skipSpaceTokens();
       if (this.match("1") && this.match("0") && this.match("^")) {
         if (/^[0-9]$/.test(this.peek))
-          return "e" + this.nextToken();
+          return this.nextToken();
         if (this.match("<{>")) {
           this.skipSpaceTokens();
           const exponent = this.parseSignedInteger();
           this.skipSpaceTokens();
           if (this.match("<}>") && exponent)
-            return "e" + exponent;
+            return exponent;
         }
       }
     }
     this.index = start;
     this.skipSpaceTokens();
     if (this.match("\\%"))
-      return `e-2`;
+      return `-2`;
     this.index = start;
     if (this.matchAll(this._exponentProductTokens)) {
       this.skipSpaceTokens();
@@ -9311,7 +9347,7 @@ var _Parser = class {
         const exponent = this.parseSignedInteger();
         this.skipSpaceTokens();
         if (this.matchAll(this._endExponentMarkerTokens) && exponent)
-          return "e" + exponent;
+          return exponent;
       }
     }
     this.index = start;
@@ -9359,43 +9395,60 @@ var _Parser = class {
    * repeating decimals, etc...
    */
   parseNumber() {
-    if (!this.options.parseNumbers)
+    if (this.options.parseNumbers === false || this.options.parseNumbers === "never")
       return null;
     const start = this.index;
     this.skipVisualSpace();
     this.match("+");
-    let result = "";
-    let dotPrefix = false;
+    let wholePart = "";
+    let fractionalPart = "";
+    let startsWithDecimalMarker = false;
     if (this.match(".") || this.matchAll(this._decimalMarkerTokens)) {
       const peek = this.peek;
-      if (peek !== "\\overline" && peek !== this._beginRepeatingDigitsTokens[0] && !/[0-9\(]/.test(peek)) {
-        this.index = start;
-        return null;
-      }
-      dotPrefix = true;
-    } else {
-      result = this.parseDecimalDigits({ withGrouping: true });
-      if (!result) {
-        this.index = start;
-        return null;
+      if (peek === "\\overline" || peek === this._beginRepeatingDigitsTokens[0] || /[0-9\(]/.test(peek)) {
+        startsWithDecimalMarker = true;
+        wholePart = "0";
       }
+    } else
+      wholePart = this.parseDecimalDigits({ withGrouping: true });
+    if (!wholePart) {
+      this.index = start;
+      return null;
     }
-    let hasDecimal = true;
-    if (!dotPrefix && (this.match(".") || this.matchAll(this._decimalMarkerTokens)))
-      result += "." + this.parseDecimalDigits({ withGrouping: true });
-    else if (dotPrefix)
-      result = "0." + this.parseDecimalDigits({ withGrouping: true });
+    let hasFractionalPart = true;
+    if (startsWithDecimalMarker || this.match(".") || this.matchAll(this._decimalMarkerTokens))
+      fractionalPart = this.parseDecimalDigits({ withGrouping: true });
     else
-      hasDecimal = false;
-    if (hasDecimal) {
+      hasFractionalPart = false;
+    let hasRepeatingPart = false;
+    if (hasFractionalPart) {
       const repeat = this.parseRepeatingDecimal();
-      if (repeat)
-        result += repeat;
-      else if (this.match("\\ldots") || this.matchAll(this._truncationMarkerTokens)) {
+      if (repeat) {
+        fractionalPart += repeat;
+        hasRepeatingPart = true;
+      } else if (this.match("\\ldots") || this.matchAll(this._truncationMarkerTokens)) {
       }
     }
     this.skipVisualSpace();
-    return result + this.parseExponent();
+    const exponent = this.parseExponent();
+    if (!hasRepeatingPart && this.options.parseNumbers === "rational") {
+      const whole = parseInt(wholePart, 10);
+      const fraction = parseInt(fractionalPart, 10);
+      const n = fractionalPart.length;
+      const numerator = whole * Math.pow(10, n) + fraction;
+      const denominator = Math.pow(10, n);
+      if (exponent) {
+        return [
+          "Multiply",
+          ["Rational", numerator, denominator],
+          ["Power", 10, exponent]
+        ];
+      }
+      return ["Rational", numerator, denominator];
+    }
+    return {
+      num: wholePart + (hasFractionalPart ? "." + fractionalPart : "") + (exponent ? "e" + exponent : "")
+    };
   }
   /**
    * A Latex number can be a decimal, hex or octal number.
@@ -9843,18 +9896,24 @@ var _Parser = class {
         (x) => x.latexTrigger === "^"
       );
       if (defs) {
-        const arg = [
-          "Superscript",
-          result,
-          superscripts.length === 1 ? superscripts[0] : ["List", ...superscripts]
-        ];
-        for (const def of defs) {
-          if (typeof def.parse === "function")
-            result = def.parse(this, arg, { minPrec: 0 });
-          else
-            result = arg;
-          if (result)
-            break;
+        let nonEmptySuperscripts = superscripts.filter(
+          (x) => head(x) !== "Sequence"
+        );
+        if (nonEmptySuperscripts.length !== 0) {
+          const superscriptExpression = nonEmptySuperscripts.length === 1 ? nonEmptySuperscripts[0] : ["List", ...nonEmptySuperscripts];
+          const arg = [
+            "Superscript",
+            result,
+            superscriptExpression
+          ];
+          for (const def of defs) {
+            if (typeof def.parse === "function")
+              result = def.parse(this, arg, { minPrec: 0 });
+            else
+              result = arg;
+            if (result)
+              break;
+          }
         }
       }
     }
@@ -10021,8 +10080,11 @@ var _Parser = class {
         const [def, n] = opDefs[0];
         if (this.peek === "^") {
           this.index += 1;
-          this.parseGroup();
-          this.error("unexpected-operator", start);
+          return [
+            "Superscript",
+            this.error("missing", start),
+            missingIfEmpty(this.parseGroup())
+          ];
         }
         this.index += n;
         if (typeof def.parse === "function") {
@@ -10129,11 +10191,7 @@ var _Parser = class {
         );
       }
     }
-    if (result === null) {
-      const num = this.parseNumber();
-      if (num !== null)
-        result = { num };
-    }
+    result ?? (result = this.parseNumber());
     result ?? (result = this.parseEnclosure());
     result ?? (result = this.parseEnvironment(until));
     if (result === null && this.matchAll(this._positiveInfinityTokens))
@@ -11061,10 +11119,65 @@ var LatexSyntax = class _LatexSyntax {
 };
 
 // src/compute-engine/boxed-expression/utils.ts
-var import_complex2 = __toESM(require_complex(), 1);
+var import_complex2 = __toESM(require_complex());
+
+// src/compute-engine/numerics/numeric.ts
+var import_complex = __toESM(require_complex());
+
+// src/compute-engine/numerics/richardson.ts
+function extrapolate(f, x0, options = {}) {
+  const {
+    contract = 0.125,
+    step = 1,
+    power = 2,
+    atol = 1e-16,
+    rtol = atol > 0 ? 0 : Math.sqrt(Number.EPSILON),
+    maxeval = 1e6,
+    // Number.MAX_SAFE_INTEGER
+    breaktol = 2
+  } = options;
+  if (!isFinite(x0)) {
+    return extrapolate((u) => f(1 / u), 1 / x0, {
+      rtol,
+      atol,
+      maxeval,
+      contract: Math.abs(contract) > 1 ? 1 / contract : contract,
+      step: 1 / step,
+      power
+    });
+  }
+  let h = step;
+  let invcontract = Math.pow(1 / contract, power);
+  let f0 = f(x0 + h);
+  let neville = [f0];
+  let err = Infinity;
+  let numeval = 1;
+  while (numeval < maxeval) {
+    numeval += 1;
+    h *= contract;
+    neville.push(f(x0 + h));
+    let c = invcontract;
+    let minerr = Infinity;
+    for (let i = neville.length - 2; i >= 0; i--) {
+      const old = neville[i];
+      neville[i] = neville[i + 1] + (neville[i + 1] - neville[i]) / (c - 1);
+      const err_ = Math.abs(neville[i] - old);
+      minerr = Math.min(minerr, err_);
+      if (err_ < err) {
+        f0 = neville[i];
+        err = err_;
+      }
+      c *= invcontract;
+    }
+    if (minerr > breaktol * err || !isFinite(minerr))
+      break;
+    if (err <= Math.max(rtol * Math.abs(f0), atol))
+      break;
+  }
+  return [f0, err];
+}
 
 // src/compute-engine/numerics/numeric.ts
-var import_complex = __toESM(require_complex(), 1);
 var MACHINE_PRECISION_BITS = 53;
 var MACHINE_PRECISION = Math.log10(
   Math.pow(2, MACHINE_PRECISION_BITS)
@@ -12428,6 +12541,19 @@ function monteCarloEstimate(f, a, b, n = 1e4) {
   }
   return sum2 / n * (b - a);
 }
+function limit(f, x, dir = 1) {
+  if (dir === 0) {
+    const left = limit(f, x, -1);
+    const right = limit(f, x, 1);
+    if (left === void 0 || right === void 0)
+      return NaN;
+    if (Math.abs(left - right) > 1e-5)
+      return NaN;
+    return (left + right) / 2;
+  }
+  const [val, err] = extrapolate(f, x, { step: dir > 0 ? 1 : -1 });
+  return val;
+}
 
 // src/compute-engine/numerics/numeric-bigint.ts
 function bigint(a) {
@@ -12748,7 +12874,7 @@ function getWildcardName(s) {
 }
 
 // src/compute-engine/boxed-expression/order.ts
-var import_complex3 = __toESM(require_complex(), 1);
+var import_complex3 = __toESM(require_complex());
 
 // src/compute-engine/symbolic/polynomials.ts
 function totalDegree(expr) {
@@ -12958,7 +13084,7 @@ function flattenSequence(xs) {
 }
 
 // src/compute-engine/numerics/rationals.ts
-var import_complex4 = __toESM(require_complex(), 1);
+var import_complex4 = __toESM(require_complex());
 function isRational(x) {
   return x !== null && Array.isArray(x);
 }
@@ -13268,7 +13394,7 @@ function signDiff(lhs, rhs, tolerance) {
 }
 
 // src/compute-engine/symbolic/sum.ts
-var import_complex5 = __toESM(require_complex(), 1);
+var import_complex5 = __toESM(require_complex());
 var Sum = class {
   constructor(ce, xs, options) {
     // If `false`, the running sums are not calculated
@@ -13704,7 +13830,7 @@ function domainSetsLibrary() {
 }
 
 // src/compute-engine/boxed-expression/abstract-boxed-expression.ts
-var import_complex6 = __toESM(require_complex(), 1);
+var import_complex6 = __toESM(require_complex());
 
 // src/compute-engine/library/utils.ts
 function normalizeLimits(range) {
@@ -13775,6 +13901,7 @@ var NATIVE_JS_FUNCTIONS = {
   Gcd: "_SYS.gcd",
   // Math.hypot
   Lcm: "_SYS.lcm",
+  Limit: (args, compile2) => `_SYS.limit(${compile2(args[0])}, ${compile2(args[1])})`,
   Ln: "Math.log",
   Log: "Math.log10",
   LogGamma: "_SYS.lngamma",
@@ -13809,7 +13936,7 @@ var NATIVE_JS_FUNCTIONS = {
   },
   Random: "Math.random",
   Round: "Math.round",
-  Sqaure: (args, compile2) => {
+  Square: (args, compile2) => {
     const arg = args[0];
     if (arg === null)
       throw new Error("Square: no argument");
@@ -13920,7 +14047,8 @@ var ComputeEngineFunction = class extends Function {
       lngamma: gammaln,
       gcd,
       lcm,
-      chop
+      chop,
+      limit
     };
     return new Proxy(this, {
       apply: (target, thisArg, argumentsList) => super.apply(thisArg, [this.sys, ...argumentsList]),
@@ -13967,7 +14095,9 @@ function compileToJavascript(expr) {
       return void 0;
     },
     string: (str) => JSON.stringify(str),
-    number: (n) => n.toString()
+    number: (n) => n.toString(),
+    indent: 0,
+    ws: (s) => s ?? ""
   });
 }
 function compileExpr(h, args, prec, target) {
@@ -13992,6 +14122,50 @@ function compileExpr(h, args, prec, target) {
     }
     return op3[1] < prec ? `(${resultStr})` : resultStr;
   }
+  if (h === "Function") {
+    const params = args.slice(1).map((x) => x.symbol);
+    return `((${params.join(", ")}) => ${compile(args[0], {
+      ...target,
+      var: (id) => params.includes(id) ? id : target.var(id)
+    })})`;
+  }
+  if (h === "Declare")
+    return `let ${args[0].symbol}`;
+  if (h === "Assign")
+    return `${args[0].symbol} = ${compile(args[1], target)}`;
+  if (h === "Return")
+    return `return ${compile(args[0], target)}`;
+  if (h === "If") {
+    if (args.length !== 3)
+      throw new Error("If: wrong number of arguments");
+    return `((${compile(args[0], target)}) ? (${compile(
+      args[1],
+      target
+    )}) : (${compile(args[2], target)}))`;
+  }
+  if (h === "Block") {
+    const locals = [];
+    for (const arg of args) {
+      if (arg.head === "Declare")
+        locals.push(arg.ops[0].symbol);
+    }
+    if (args.length === 1 && locals.length === 0)
+      return compile(args[0], target);
+    const result = args.map(
+      (arg) => compile(arg, {
+        ...target,
+        var: (id) => {
+          if (locals.includes(id))
+            return id;
+          return target.var(id);
+        }
+      })
+    );
+    result[result.length - 1] = `return ${result[result.length - 1]}`;
+    return `(() => {${target.ws("\n")}${result.join(
+      `;${target.ws("\n")}`
+    )}${target.ws("\n")}})()`;
+  }
   const fn = target.functions?.(h);
   if (!fn)
     throw new Error(`Unknown function ${h}`);
@@ -14383,7 +14557,7 @@ var _BoxedExpression = class {
   compile(to = "javascript", options) {
     if (to !== "javascript")
       return void 0;
-    options ?? (options = { optimize: ["simplify", "evaluate"] });
+    options ?? (options = { optimize: ["simplify"] });
     let expr = this;
     if (options.optimize.includes("simplify"))
       expr = expr.simplify();
@@ -14757,7 +14931,7 @@ function narrow(a, b) {
 }
 
 // src/compute-engine/symbolic/utils.ts
-var import_complex7 = __toESM(require_complex(), 1);
+var import_complex7 = __toESM(require_complex());
 function makePositive(expr) {
   if (expr.head === "Negate")
     return [-1, expr.op1];
@@ -15312,7 +15486,7 @@ function evalSummation(ce, expr, range, mode) {
 }
 
 // src/compute-engine/symbolic/negate.ts
-var import_complex8 = __toESM(require_complex(), 1);
+var import_complex8 = __toESM(require_complex());
 function negateLiteral(expr, metadata) {
   let n = expr.numericValue;
   if (n === null)
@@ -15844,10 +16018,10 @@ function isInequality(expr) {
 }
 
 // src/compute-engine/boxed-expression/box.ts
-var import_complex14 = __toESM(require_complex(), 1);
+var import_complex14 = __toESM(require_complex());
 
 // src/compute-engine/boxed-expression/serialize.ts
-var import_complex10 = __toESM(require_complex(), 1);
+var import_complex10 = __toESM(require_complex());
 
 // src/compute-engine/numerics/numeric-bignum.ts
 function factorial3(ce, n) {
@@ -15963,7 +16137,7 @@ function isInMachineRange(d) {
 }
 
 // src/compute-engine/symbolic/product.ts
-var import_complex9 = __toESM(require_complex(), 1);
+var import_complex9 = __toESM(require_complex());
 var Product = class {
   constructor(ce, xs, options) {
     this.options = options;
@@ -16902,7 +17076,7 @@ var BoxedDictionary = class _BoxedDictionary extends _BoxedExpression {
 };
 
 // src/compute-engine/boxed-expression/boxed-function.ts
-var import_complex11 = __toESM(require_complex(), 1);
+var import_complex11 = __toESM(require_complex());
 
 // src/compute-engine/simplify-rules.ts
 var SIMPLIFY_RULES = [];
@@ -17595,10 +17769,12 @@ var BoxedFunction = class _BoxedFunction extends _BoxedExpression {
     const sig = def?.signature;
     if (!result && sig) {
       const numericMode = options?.numericMode ?? false;
+      const context = this.engine.swapScope(this.scope);
       if (numericMode && sig.N)
         result = sig.N(this.engine, tail);
       if (!result && sig.evaluate)
         result = sig.evaluate(this.engine, tail);
+      this.engine.swapScope(context);
     }
     if (result) {
       const num = result.numericValue;
@@ -17791,10 +17967,10 @@ function cheapest(oldExpr, newExpr) {
 }
 
 // src/compute-engine/boxed-expression/boxed-number.ts
-var import_complex13 = __toESM(require_complex(), 1);
+var import_complex13 = __toESM(require_complex());
 
 // src/compute-engine/domain-utils.ts
-var import_complex12 = __toESM(require_complex(), 1);
+var import_complex12 = __toESM(require_complex());
 function inferNumericDomain(value) {
   if (typeof value === "number" && !isNaN(value)) {
     if (!isFinite(value))
@@ -18081,7 +18257,12 @@ var BoxedNumber = class _BoxedNumber extends _BoxedExpression {
     return false;
   }
   isEqual(rhs) {
-    return this.isSame(rhs);
+    if (this === rhs)
+      return true;
+    if (!(rhs instanceof _BoxedNumber))
+      return false;
+    const s = signDiff(this, rhs);
+    return s === 0;
   }
   match(rhs, options) {
     if (this.isEqualWithTolerance(rhs, options?.numericTolerance ?? 0))
@@ -18736,7 +18917,7 @@ function asString(expr) {
 }
 
 // src/compute-engine/library/arithmetic.ts
-var import_complex16 = __toESM(require_complex(), 1);
+var import_complex16 = __toESM(require_complex());
 
 // src/compute-engine/numerics/numeric-complex.ts
 function gamma3(c) {
@@ -18747,7 +18928,7 @@ function gammaln3(c) {
 }
 
 // src/compute-engine/library/arithmetic-power.ts
-var import_complex15 = __toESM(require_complex(), 1);
+var import_complex15 = __toESM(require_complex());
 function canonicalPower(ce, base, exponent, metadata) {
   if (exponent.symbol === "ComplexInfinity")
     return ce.NaN;
@@ -20162,21 +20343,7 @@ var ARITHMETIC_LIBRARY = [
             return ops2[0];
           return ce.fn("Max", ops2);
         },
-        evaluate: (ce, ops2) => {
-          if (ops2.length === 0)
-            return ce.NegativeInfinity;
-          let result = void 0;
-          const rest = [];
-          for (const op3 of ops2) {
-            if (!op3.isNumber || op3.numericValue === void 0)
-              rest.push(op3);
-            else if (!result || op3.isGreater(result))
-              result = op3;
-          }
-          if (rest.length > 0)
-            return ce.box(result ? ["Max", result, ...rest] : ["Max", ...rest]);
-          return result ?? ce.NaN;
-        }
+        evaluate: (ce, ops2) => processMinMax(ce, ops2, "Max")
       }
     },
     Min: {
@@ -20186,26 +20353,42 @@ var ARITHMETIC_LIBRARY = [
         domain: ["FunctionOf", ["VarArg", "Values"], "Numbers"],
         simplify: (ce, ops2) => {
           if (ops2.length === 0)
-            return ce.NegativeInfinity;
+            return ce.PositiveInfinity;
           if (ops2.length === 1)
             return ops2[0];
           return ce.fn("Min", ops2);
         },
-        evaluate: (ce, ops2) => {
+        evaluate: (ce, ops2) => processMinMax(ce, ops2, "Min")
+      }
+    },
+    Supremum: {
+      description: "Like Max, but defined for open sets",
+      complexity: 1200,
+      signature: {
+        domain: ["FunctionOf", ["VarArg", "Values"], "Numbers"],
+        simplify: (ce, ops2) => {
           if (ops2.length === 0)
             return ce.NegativeInfinity;
-          let result = void 0;
-          const rest = [];
-          for (const op3 of ops2) {
-            if (!op3.isNumber || op3.numericValue === void 0)
-              rest.push(op3);
-            else if (!result || op3.isLess(result))
-              result = op3;
-          }
-          if (rest.length > 0)
-            return ce.box(result ? ["Min", result, ...rest] : ["Min", ...rest]);
-          return result ?? ce.NaN;
-        }
+          if (ops2.length === 1)
+            return ops2[0];
+          return ce.fn("Min", ops2);
+        },
+        evaluate: (ce, ops2) => processMinMax(ce, ops2, "Supremum")
+      }
+    },
+    Infimum: {
+      description: "Like Min, but defined for open sets",
+      complexity: 1200,
+      signature: {
+        domain: ["FunctionOf", ["VarArg", "Values"], "Numbers"],
+        simplify: (ce, ops2) => {
+          if (ops2.length === 0)
+            return ce.PositiveInfinity;
+          if (ops2.length === 1)
+            return ops2[0];
+          return ce.fn("Min", ops2);
+        },
+        evaluate: (ce, ops2) => processMinMax(ce, ops2, "Infimum")
       }
     },
     Product: {
@@ -20251,6 +20434,69 @@ var ARITHMETIC_LIBRARY = [
         evaluate: (ce, ops2) => evalSummation(ce, ops2[0], ops2[1], "evaluate"),
         N: (ce, ops2) => evalSummation(ce, ops2[0], ops2[1], "N")
       }
+    },
+    // Limits
+    Limit: {
+      description: "Limit of a function",
+      complexity: 5e3,
+      hold: "all",
+      signature: {
+        domain: [
+          "FunctionOf",
+          "Anything",
+          "Numbers",
+          ["OptArg", "Numbers"],
+          "Numbers"
+        ],
+        N: (ce, ops2) => {
+          const [f, x, dir] = ops2;
+          const target = asFloat(x.N());
+          if (target === null)
+            return void 0;
+          const fn = applicable(f);
+          return ce.number(
+            limit(
+              (x2) => {
+                let y = fn([ce.number(x2)])?.valueOf();
+                return typeof y === "number" ? y : Number.NaN;
+              },
+              target,
+              dir ? asFloat(dir) ?? 1 : 1
+            )
+          );
+        }
+      }
+    },
+    NLimit: {
+      description: "Numerical approximation of the limit of a function",
+      complexity: 5e3,
+      hold: "all",
+      signature: {
+        domain: [
+          "FunctionOf",
+          "Anything",
+          "Numbers",
+          ["OptArg", "Numbers"],
+          "Numbers"
+        ],
+        evaluate: (ce, ops2) => {
+          const [f, x, dir] = ops2;
+          const target = asFloat(x.N());
+          if (target === null)
+            return void 0;
+          const fn = applicable(f);
+          return ce.number(
+            limit(
+              (x2) => {
+                let y = fn([ce.number(x2)])?.valueOf();
+                return typeof y === "number" ? y : Number.NaN;
+              },
+              target,
+              dir ? asFloat(dir) ?? 1 : 1
+            )
+          );
+        }
+      }
     }
   },
   //
@@ -20357,6 +20603,24 @@ function processAbs(ce, arg, mode) {
     return ce.neg(arg);
   return void 0;
 }
+function processMinMax(ce, ops2, mode) {
+  const upper = mode === "Max" || mode === "Supremum";
+  if (ops2.length === 0)
+    return upper ? ce.NegativeInfinity : ce.PositiveInfinity;
+  let result = void 0;
+  const rest = [];
+  for (const op3 of ops2) {
+    if (!op3.isNumber || op3.numericValue === void 0)
+      rest.push(op3);
+    else if (!result)
+      result = op3;
+    else if (upper && op3.isGreater(result) || !upper && op3.isLess(result))
+      result = op3;
+  }
+  if (rest.length > 0)
+    return ce.box(result ? [mode, result, ...rest] : [mode, ...rest]);
+  return result ?? (upper ? ce.NegativeInfinity : ce.PositiveInfinity);
+}
 
 // src/compute-engine/symbolic/derivative.ts
 var DERIVATIVES_TABLE = {
@@ -20681,8 +20945,9 @@ var CALCULUS_LIBRARY = [
           const params = ops2.slice(1);
           f.bind();
           f = f.canonical;
+          const result = ce._fn("D", [f, ...params]);
           ce.popScope();
-          return ce._fn("D", [f, ...params]);
+          return result;
         },
         evaluate: (ce, ops2) => {
           let f = ops2[0].canonical;
@@ -21541,6 +21806,7 @@ function indexes(ranges) {
 var CONTROL_STRUCTURES_LIBRARY = [
   {
     Block: {
+      hold: "all",
       signature: {
         domain: "Functions",
         canonical: canonicalBlock,
@@ -21642,33 +21908,37 @@ function whichEvaluate(ce, args, mode) {
 function evaluateBlock(ce, ops2) {
   if (ops2.length === 0)
     return ce.Nothing;
+  ce.resetContext();
   let result = void 0;
   for (const op3 of ops2) {
-    result = op3.evaluate();
-    const h = result.head;
-    if (h === "Return" || h === "Break" || h === "Continue")
+    const h = op3.head;
+    if (h === "Return") {
+      result = op3.op1.evaluate();
       break;
+    }
+    if (h === "Break" || h === "Continue") {
+      result = ce.fn(h, [op3.op1.evaluate()]);
+      break;
+    }
+    result = op3.evaluate();
   }
   return result ?? ce.Nothing;
 }
 function canonicalBlock(ce, ops2) {
   if (ops2.length === 0)
     return null;
+  ce.pushScope();
   const declarations = [];
   const body = [];
   for (const op3 of ops2) {
-    if (op3.head === "Declare") {
+    if (op3.head === "Declare")
       declarations.push(op3);
-    } else if (op3.head === "Assign") {
-      const id = op3.op1.symbol;
-      const def = ce.lookupSymbol(id) ?? ce.lookupFunction(id);
-      if (!def) {
-        declarations.push(ce._fn("Declare", [op3.op1, ce.symbol("Undefined")]));
-      }
-    } else
+    else
       body.push(invalidateDeclare(op3));
   }
-  return ce._fn("Block", [...declarations, ...body]);
+  const result = ce._fn("Block", [...declarations, ...body]);
+  ce.popScope();
+  return result;
 }
 function invalidateDeclare(expr) {
   if (expr.head === "Declare")
@@ -22033,7 +22303,8 @@ var CORE_LIBRARY = [
         },
         // By definition, for arguments of the canonical expression of
         // `Hold` are not canonicalized.
-        canonical: (ce, args) => args.length !== 1 ? null : ce._fn("Hold", args)
+        canonical: (ce, args) => args.length !== 1 ? null : ce._fn("Hold", args),
+        evaluate: (ce, ops2) => ops2[0]
       }
     },
     HorizontalSpacing: {
@@ -22073,6 +22344,32 @@ var CORE_LIBRARY = [
         evaluate: (_ce, ops2) => apply3(ops2[0], ops2.slice(1))
       }
     },
+    Assign: {
+      hold: "all",
+      signature: {
+        domain: ["FunctionOf", "Symbols", "Anything", "Anything"],
+        canonical: (ce, args) => {
+          if (args.length !== 2)
+            return null;
+          const op12 = args[0];
+          const op22 = args[1];
+          if (!op12.symbol)
+            return null;
+          if (op22.symbol)
+            return ce._fn("Assign", args);
+          return ce._fn("Assign", [op12, ce._fn("Hold", [op22])]);
+        },
+        evaluate: (ce, ops2) => {
+          const op12 = ops2[0];
+          const op22 = ops2[1];
+          if (!op12.symbol)
+            return ce.Nothing;
+          const val = op22.evaluate();
+          ce.assign(op12.symbol, val);
+          return val;
+        }
+      }
+    },
     Assume: {
       hold: "all",
       signature: {
@@ -22082,6 +22379,32 @@ var CORE_LIBRARY = [
     },
     // @todo
     About: { signature: { domain: "Functions" } },
+    Declare: {
+      hold: "all",
+      signature: {
+        domain: ["FunctionOf", "Symbols", "Anything"],
+        canonical: (ce, args) => {
+          if (args.length !== 2)
+            return null;
+          const op12 = args[0];
+          const op22 = args[1];
+          if (!op12.symbol)
+            return null;
+          if (op22.symbol)
+            return ce._fn("Declare", args);
+          return ce._fn("Declare", [op12, ce._fn("Hold", [op22])]);
+        },
+        evaluate: (ce, ops2) => {
+          const op12 = ops2[0];
+          const op22 = ops2[1];
+          if (!op12.symbol)
+            return ce.Nothing;
+          const val = op22.evaluate();
+          ce.declare(op12.symbol, val);
+          return val;
+        }
+      }
+    },
     Domain: {
       /** Return the domain of an expression */
       signature: {
@@ -24188,7 +24511,7 @@ function evalTrig(ce, mode, head2, op3) {
 }
 
 // src/compute-engine/boxed-expression/boxed-symbol-definition.ts
-var import_complex17 = __toESM(require_complex(), 1);
+var import_complex17 = __toESM(require_complex());
 var _BoxedSymbolDefinition = class {
   // @todo
   constructor(ce, name, def) {
@@ -25138,7 +25461,7 @@ function isFunctionDefinition(def) {
 }
 
 // src/compute-engine/cost-function.ts
-var import_complex19 = __toESM(require_complex(), 1);
+var import_complex19 = __toESM(require_complex());
 function numericCostFunction(n) {
   if (Number.isInteger(n) && n !== 0) {
     return Math.floor(Math.log2(Math.abs(n)) / Math.log2(10)) + (n > 0 ? 1 : 2);
@@ -25530,6 +25853,16 @@ function match(subject, pattern, options) {
   }
   if (!options.recursive)
     return null;
+  if (subject.ops) {
+    const ops2 = subject.ops;
+    const result = {};
+    for (let i = 0; i < ops2.length; i++) {
+      const sub2 = match(ops2[i], pattern, options);
+      if (sub2 !== null)
+        return sub2;
+    }
+    return result;
+  }
   return null;
 }
 
@@ -27295,10 +27628,10 @@ var ComputeEngine = class _ComputeEngine {
 };
 
 // src/compute-engine.ts
-var version = "0.17.0";
+var version = "0.18.0";
 globalThis[Symbol.for("io.cortexjs.compute-engine")] = {
   ComputeEngine: ComputeEngine.prototype.constructor,
-  version: "0.17.0"
+  version: "0.18.0"
 };
 export {
   ADDITION_PRECEDENCE,