@cortex-js/compute-engine 0.12.3 → 0.12.5

package/dist/math-json.min.js

@@ -1,2 +1,283 @@
-/** MathJSON 0.12.3 */
-var global,factory;global=this,factory=function(n){function t(n){return null!==n&&"object"==typeof n&&"sym"in n}function r(n){return null!==n&&"object"==typeof n&&"fn"in n}function l(n){return null==n?null:"object"==typeof n&&"str"in n?n.str:"string"!=typeof n||n.length<2||"'"!==n[0]||"'"!==n[n.length-1]?null:n.substring(1,n.length-1)}function e(n){return null==n?null:Array.isArray(n)?n[0]:r(n)?n.fn[0]:null}function u(n){return null==n?null:Array.isArray(n)?n.slice(1):r(n)?n.fn.slice(1):null}function o(n,t){var l,e;return null==n?null:Array.isArray(n)?null!==(l=n[t])&&void 0!==l?l:null:r(n)&&null!==(e=n.fn[t])&&void 0!==e?e:null}function i(n){return o(n,2)}function f(n){return null==n?0:Array.isArray(n)?Math.max(0,n.length-1):r(n)?Math.max(0,n.fn.length-1):0}function c(n){var t;const r=e(n);if("KeyValuePair"===r||"Tuple"===r||"Pair"===r){const r=l(function(n){return o(n,1)}(n));return r?[r,null!==(t=i(n))&&void 0!==t?t:"Nothing"]:null}return null}function s(n){if(null===n)return null;if("object"==typeof n&&"dict"in n)return n.dict;const t=c(n);if(t)return{[t[0]]:t[1]};if("Dictionary"===e(n)){const t={};for(let r=1;r<f(n);r++){const l=c(o(n,r));l&&(t[l[0]]=l[1])}return t}return null}n.applyRecursively=function(n,t){var r;const l=e(n);if(null!==l)return[t(l),...(null!==(r=u(n))&&void 0!==r?r:[]).map(t)];const o=s(n);if(null!==o){const n=Object.keys(o),r={};for(const l of n)r[l]=t(o[l]);return{dict:r}}return t(n)},n.getDictionary=s,n.getStringValue=l,n.head=e,n.headName=function(n){const t=e(n);return"string"==typeof t?t:""},n.isDictionaryObject=function(n){return null!==n&&"object"==typeof n&&"dict"in n},n.isFunctionObject=r,n.isStringObject=function(n){return null!==n&&"object"==typeof n&&"str"in n},n.isSymbolObject=t,n.mapArgs=function(n,t){let l=null;if(Array.isArray(n)&&(l=n),r(n)&&(l=n.fn),null===l)return[];let e=1;const u=[];for(;e<l.length;)u.push(t(l[e])),e+=1;return u},n.nops=f,n.op=o,n.symbol=function(n){if(null==n)return null;if("string"==typeof n){if(/^[+\-\.0-9]/.test(n))return null;if(n.length>=2&&"'"===n[0]&&"'"===n[n.length-1])return null}const r=t(n)?n.sym:n;return"string"!=typeof r?null:r},n.version="0.12.3",Object.defineProperty(n,"__esModule",{value:!0})},"object"==typeof exports&&"undefined"!=typeof module?factory(exports):"function"==typeof define&&define.amd?define(["exports"],factory):factory((global="undefined"!=typeof globalThis?globalThis:global||self).MathJson={});
+/** CortexJS MathJSON 0.12.5 */
+    (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.MathJson = {}));})(this, (function (exports) { 'use strict';
+var MathJson = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/math-json.ts
+  var math_json_exports = {};
+  __export(math_json_exports, {
+    applyRecursively: () => applyRecursively,
+    getDictionary: () => dictionary,
+    getStringValue: () => stringValue,
+    head: () => head,
+    headName: () => headName,
+    isDictionaryObject: () => isDictionaryObject,
+    isFunctionObject: () => isFunctionObject,
+    isStringObject: () => isStringObject,
+    isSymbolObject: () => isSymbolObject,
+    mapArgs: () => mapArgs,
+    nops: () => nops,
+    op: () => op,
+    symbol: () => symbol,
+    version: () => version
+  });
+
+  // src/math-json/utils.ts
+  function isSymbolObject(expr) {
+    return expr !== null && typeof expr === "object" && "sym" in expr;
+  }
+  function isStringObject(expr) {
+    return expr !== null && typeof expr === "object" && "str" in expr;
+  }
+  function isFunctionObject(expr) {
+    return expr !== null && typeof expr === "object" && "fn" in expr;
+  }
+  function isDictionaryObject(expr) {
+    return expr !== null && typeof expr === "object" && "dict" in expr;
+  }
+  var recommendedScriptsRegex;
+  function isRecommendedScripts(text) {
+    if (!recommendedScriptsRegex) {
+      const recommendedScripts = [
+        "Zyyy",
+        "Zinh",
+        "Arab",
+        "Armn",
+        "Beng",
+        "Bopo",
+        "Cyrl",
+        "Deva",
+        "Ethi",
+        "Geor",
+        "Grek",
+        "Gujr",
+        "Guru",
+        "Hang",
+        "Hani",
+        "Hebr",
+        "Hira",
+        "Kana",
+        "Knda",
+        "Khmr",
+        "Laoo",
+        "Latn",
+        "Mlym",
+        "Mymr",
+        "Orya",
+        "Sinh",
+        "Taml",
+        "Telu",
+        "Thaa",
+        "Thai",
+        "Tibt"
+      ];
+      const regexPattern = `^[${recommendedScripts.map((x) => `\\p{Script=${x}}`).join("")}]*$`;
+      recommendedScriptsRegex = new RegExp(regexPattern, "u");
+    }
+    return recommendedScriptsRegex.test(text);
+  }
+  function isValidIdentifier(s) {
+    if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(s))
+      return true;
+    if (ONLY_EMOJIS.test(s))
+      return true;
+    if (!isRecommendedScripts(s))
+      return false;
+    return /^[\p{XIDS}_]\p{XIDC}*$/u.test(s);
+  }
+  var VS16 = "\\u{FE0F}";
+  var KEYCAP = "\\u{20E3}";
+  var ZWJ = "\\u{200D}";
+  var FLAG_SEQUENCE = "\\p{RI}\\p{RI}";
+  var TAG_MOD = `(?:[\\u{E0020}-\\u{E007E}]+\\u{E007F})`;
+  var EMOJI_MOD = `(?:\\p{EMod}|${VS16}${KEYCAP}?|${TAG_MOD})`;
+  var EMOJI_NOT_IDENTIFIER = `(?:(?=\\P{XIDC})\\p{Emoji})`;
+  var ZWJ_ELEMENT = `(?:${EMOJI_NOT_IDENTIFIER}${EMOJI_MOD}*|\\p{Emoji}${EMOJI_MOD}+|${FLAG_SEQUENCE})`;
+  var POSSIBLE_EMOJI = `(?:${ZWJ_ELEMENT})(${ZWJ}${ZWJ_ELEMENT})*`;
+  var SOME_EMOJI = new RegExp(`(?:${POSSIBLE_EMOJI})+`, "u");
+  var ONLY_EMOJIS = new RegExp(`^(?:${POSSIBLE_EMOJI})+$`, "u");
+  function validateIdentifier(s) {
+    if (typeof s !== "string")
+      return "not-a-string";
+    if (s === "")
+      return "empty-string";
+    if (s.normalize() !== s)
+      return "expected-nfc";
+    if (/[\u200E\u200F\u2066-\u2069\u202A-\u202E]/.test(s))
+      return "unexpected-bidi-marker";
+    if (ONLY_EMOJIS.test(s))
+      return "valid";
+    if (/\p{XIDC}/u.test(s) && SOME_EMOJI.test(s))
+      return "unexpected-mixed-emoji";
+    if (!isRecommendedScripts(s))
+      return "unexpected-script";
+    if (!isValidIdentifier(s)) {
+      if (!isValidIdentifier(s[0]))
+        return "invalid-first-char";
+      return "invalid-char";
+    }
+    return "valid";
+  }
+  function stringValue(expr) {
+    if (expr === null || expr === void 0)
+      return null;
+    if (typeof expr === "object" && "str" in expr)
+      return expr.str;
+    if (typeof expr !== "string")
+      return null;
+    if (expr.length < 2)
+      return null;
+    if (expr[0] !== "'" || expr[expr.length - 1] !== "'")
+      return null;
+    return expr.substring(1, expr.length - 1);
+  }
+  function head(expr) {
+    if (expr === null || expr === void 0)
+      return null;
+    if (Array.isArray(expr)) {
+      if (typeof expr[0] === "string" && !isValidIdentifier(expr[0])) {
+        console.error(
+          `Invalid identifier "${expr[0]}": ${validateIdentifier(expr[0])}`
+        );
+        return null;
+      }
+      return expr[0];
+    }
+    if (isFunctionObject(expr))
+      return expr.fn[0];
+    return null;
+  }
+  function headName(expr) {
+    const h = head(expr);
+    return typeof h === "string" ? h : "";
+  }
+  function ops(expr) {
+    if (expr === null || expr === void 0)
+      return null;
+    if (Array.isArray(expr))
+      return expr.slice(1);
+    if (isFunctionObject(expr))
+      return expr.fn.slice(1);
+    return null;
+  }
+  function op(expr, n) {
+    if (expr === null || expr === void 0)
+      return null;
+    if (Array.isArray(expr))
+      return expr[n] ?? null;
+    if (isFunctionObject(expr))
+      return expr.fn[n] ?? null;
+    return null;
+  }
+  function op1(expr) {
+    return op(expr, 1);
+  }
+  function op2(expr) {
+    return op(expr, 2);
+  }
+  function nops(expr) {
+    if (expr === null || expr === void 0)
+      return 0;
+    if (Array.isArray(expr))
+      return Math.max(0, expr.length - 1);
+    if (isFunctionObject(expr))
+      return Math.max(0, expr.fn.length - 1);
+    return 0;
+  }
+  function symbol(expr) {
+    if (expr === null || expr === void 0)
+      return null;
+    if (typeof expr === "string") {
+      if (/^[+\-\.0-9]/.test(expr))
+        return null;
+      if (expr.length >= 2 && expr[0] === "'" && expr[expr.length - 1] === "'")
+        return null;
+    }
+    const s = isSymbolObject(expr) ? expr.sym : expr;
+    if (typeof s !== "string")
+      return null;
+    return s;
+  }
+  function keyValuePair(expr) {
+    const h = head(expr);
+    if (h === "KeyValuePair" || h === "Tuple" || h === "Pair") {
+      const key = stringValue(op1(expr));
+      if (!key)
+        return null;
+      return [key, op2(expr) ?? "Nothing"];
+    }
+    return null;
+  }
+  function dictionary(expr) {
+    if (expr === null)
+      return null;
+    if (typeof expr === "object" && "dict" in expr)
+      return expr.dict;
+    const kv = keyValuePair(expr);
+    if (kv)
+      return { [kv[0]]: kv[1] };
+    const h = head(expr);
+    if (h === "Dictionary") {
+      const result = {};
+      for (let i = 1; i < nops(expr); i++) {
+        const kv2 = keyValuePair(op(expr, i));
+        if (kv2)
+          result[kv2[0]] = kv2[1];
+      }
+      return result;
+    }
+    return null;
+  }
+  function applyRecursively(expr, fn) {
+    const h = head(expr);
+    if (h !== null) {
+      return [fn(h), ...(ops(expr) ?? []).map(fn)];
+    }
+    const dict = dictionary(expr);
+    if (dict !== null) {
+      const keys = Object.keys(dict);
+      const result = {};
+      for (const key of keys)
+        result[key] = fn(dict[key]);
+      return { dict: result };
+    }
+    return fn(expr);
+  }
+  function mapArgs(expr, fn) {
+    let args = null;
+    if (Array.isArray(expr))
+      args = expr;
+    if (isFunctionObject(expr))
+      args = expr.fn;
+    if (args === null)
+      return [];
+    let i = 1;
+    const result = [];
+    while (i < args.length) {
+      result.push(fn(args[i]));
+      i += 1;
+    }
+    return result;
+  }
+
+  // src/math-json.ts
+  var version = "0.12.5";
+  return __toCommonJS(math_json_exports);
+})();
+Object.assign(exports, MathJson); Object.defineProperty(exports, '__esModule', { value: true });}));

package/dist/types/common/grapheme-splitter.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 /**
  * Return a string or an array of graphemes.
  *

package/dist/types/common/signals.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export type SignalCode = RuntimeSignalCode | ('invalid-name' | 'expected-predicate' | 'expected-symbol' | 'operator-requires-one-operand' | 'postfix-operator-requires-one-operand' | 'prefix-operator-requires-one-operand' | 'unbalanced-symbols' | 'expected-argument' | 'unexpected-command' | 'cyclic-definition' | 'invalid-supersets' | 'expected-supersets' | 'unknown-domain' | 'duplicate-wikidata' | 'invalid-dictionary-entry' | 'syntax-error');
 export type SignalMessage = SignalCode | [SignalCode, ...any[]];
 export type SignalOrigin = {

package/dist/types/common/utils.d.ts

@@ -1 +1 @@
-/* 0.12.3 */
+/* 0.12.5 */

package/dist/types/compute-engine/assume.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 /**
  * Add an assumption, in the form of a predicate, for example:
  *

package/dist/types/compute-engine/boxed-expression/abstract-boxed-expression.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import { Complex } from 'complex.js';
 import { Expression } from '../../math-json/math-json-format';
 import { BoxedExpression, BoxedFunctionDefinition, BoxedRuleSet, BoxedSymbolDefinition, BoxedDomain, EvaluateOptions, IComputeEngine, LatexString, Metadata, NOptions, PatternMatchOptions, SemiBoxedExpression, SimplifyOptions, Substitution, RuntimeScope, DomainCompatibility, DomainLiteral, BoxedBaseDefinition, Rational, BoxedSubstitution } from '../public';
@@ -30,6 +30,8 @@ export declare abstract class AbstractBoxedExpression implements BoxedExpression
     [Symbol.toPrimitive](hint: 'number' | 'string' | 'default'): number | string | null;
     /** Called by `JSON.stringify()` when serializing to json */
     toJSON(): Expression;
+    /** @internal */
+    get rawJson(): Expression;
     get scope(): RuntimeScope | null;
     /** Object.is() */
     is(rhs: any): boolean;

package/dist/types/compute-engine/boxed-expression/box.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import { Decimal } from 'decimal.js';
 import { IComputeEngine, SemiBoxedExpression, BoxedExpression, Metadata, Rational } from '../public';
 import { MathJsonNumber } from '../../math-json/math-json-format';

package/dist/types/compute-engine/boxed-expression/boxed-dictionary.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import { BoxedExpression, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, ReplaceOptions, Substitution, Metadata, PatternMatchOptions, BoxedDomain, BoxedSubstitution } from '../public';
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
 /**

package/dist/types/compute-engine/boxed-expression/boxed-domain.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import { BoxedDomain, BoxedExpression, BoxedSubstitution, DomainCompatibility, DomainConstructor, DomainExpression, DomainLiteral, IComputeEngine, Metadata, PatternMatchOptions } from '../public';
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
 /**
@@ -43,8 +43,9 @@ export declare class _BoxedDomain extends AbstractBoxedExpression implements Box
  * Note that `boxDomain()` should only be called from `ComputeEngine`.
  * This gives a chance for `ComputeEngine` to substitute cached objects.
  */
-export declare function boxDomain(ce: IComputeEngine, dom: BoxedDomain | DomainExpression, metadata?: Metadata): BoxedDomain;
+export declare function boxDomain(ce: IComputeEngine, dom: BoxedExpression | DomainExpression, metadata?: Metadata): BoxedDomain;
 /** Validate that `expr` is a Domain */
 export declare function isDomain(expr: Expression | BoxedExpression | BoxedDomain | DomainExpression): expr is BoxedDomain | DomainExpression;
+export declare function isValidDomain(expr: any): expr is BoxedDomain | DomainExpression;
 /** Return the ancestor domain that is shared by both `a` and `b` */
 export declare function sharedAncestorDomain(a: BoxedDomain, b: BoxedDomain): BoxedDomain;

package/dist/types/compute-engine/boxed-expression/boxed-function-definition.d.ts

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare function makeFunctionDefinition(engine: IComputeEngine, name: string, def: FunctionDefinition | BoxedFunctionDefinition): BoxedFunctionDefinition;

package/dist/types/compute-engine/boxed-expression/boxed-function.d.ts

@@ -1,6 +1,6 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, BoxedFunctionDefinition, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedSubstitution } from '../public';
+import { BoxedExpression, BoxedFunctionDefinition, IComputeEngine, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedSubstitution, EvaluateOptions } from '../public';
 /**
  * BoxedFunction
  */
@@ -29,6 +29,7 @@ export declare class BoxedFunction extends AbstractBoxedExpression {
     set isCanonical(val: boolean);
     get isPure(): boolean;
     get json(): Expression;
+    get rawJson(): Expression;
     get scope(): RuntimeScope | null;
     get head(): string | BoxedExpression;
     get ops(): BoxedExpression[];
@@ -86,7 +87,7 @@ export declare class BoxedFunction extends AbstractBoxedExpression {
 }
 export declare function makeCanonicalFunction(ce: IComputeEngine, head: string | BoxedExpression, ops: SemiBoxedExpression[], metadata?: Metadata): BoxedExpression;
 /** Apply arguments to an expression. If the expression is a lambda expression
- * it's wildcard arguments are substituted before being evaluated. Otherwise
+ * its wildcard arguments are substituted before being evaluated. Otherwise
  * the expression is just evaluated.
  */
 export declare function apply(fn: BoxedExpression, args: BoxedExpression[]): BoxedExpression;

package/dist/types/compute-engine/boxed-expression/boxed-number.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import { Complex } from 'complex.js';
 import { Expression } from '../../math-json/math-json-format';
 import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, NOptions, PatternMatchOptions, Rational, SimplifyOptions, BoxedSubstitution } from '../public';
@@ -35,7 +35,7 @@ export declare class BoxedNumber extends AbstractBoxedExpression {
     set isCanonical(val: boolean);
     get complexity(): number;
     get value(): BoxedExpression;
-    get numericValue(): number | Decimal | Complex | Rational | null;
+    get numericValue(): number | Decimal | Complex | Rational;
     get domain(): BoxedDomain;
     get json(): Expression;
     get sgn(): -1 | 0 | 1 | undefined | null;

package/dist/types/compute-engine/boxed-expression/boxed-patterns.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
 import { BoxedExpression, BoxedSubstitution, BoxedDomain, IComputeEngine, LatexString, Metadata, Pattern, PatternMatchOptions, SemiBoxedExpression, Substitution } from '../public';
 export declare class BoxedPattern extends AbstractBoxedExpression implements Pattern {

package/dist/types/compute-engine/boxed-expression/boxed-string.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
 import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, PatternMatchOptions, BoxedSubstitution } from '../public';
 /**

package/dist/types/compute-engine/boxed-expression/boxed-symbol-definition.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 /**
  * THEORY OF OPERATIONS
  *

package/dist/types/compute-engine/boxed-expression/boxed-symbol.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import { AbstractBoxedExpression } from './abstract-boxed-expression';
 import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedFunctionDefinition, BoxedBaseDefinition, DomainExpression, BoxedSubstitution } from '../public';
 /**

package/dist/types/compute-engine/boxed-expression/expression-map.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare class ExpressionMap<U> implements ExpressionMapInterface<U> {
     readonly _items: Map<BoxedExpression, U>;
     constructor(source?: ExpressionMapInterface<U> | readonly (readonly [BoxedExpression, U])[]);

package/dist/types/compute-engine/boxed-expression/order.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export type Order = 'lex' | 'dexlex' | 'grevlex' | 'elim';
 export declare const DEFAULT_COMPLEXITY = 100000;
 /**

package/dist/types/compute-engine/boxed-expression/serialize.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import Decimal from 'decimal.js';
 import { Expression } from '../../math-json/math-json-format';
 import { BoxedExpression, IComputeEngine, Metadata, Rational } from '../public';

package/dist/types/compute-engine/boxed-expression/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import { Expression } from '../../math-json/math-json-format';
 import { BoxedExpression, IComputeEngine } from '../public';
 export declare function isLatexString(s: unknown): s is string;

package/dist/types/compute-engine/boxed-expression/validate.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare function validateArgumentCount(ce: IComputeEngine, ops: BoxedExpression[], count: number): BoxedExpression[];
 /**
  * Validation of arguments is normally done by checking the signature of the

package/dist/types/compute-engine/compute-engine.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import { Complex } from 'complex.js';
 import { Expression, MathJsonNumber } from '../math-json/math-json-format';
 import type { LibraryCategory, LatexDictionary, LatexDictionaryEntry, LatexString, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
@@ -279,10 +279,11 @@ export declare class ComputeEngine implements IComputeEngine {
         canonical?: boolean;
     }): BoxedExpression;
     canonical(xs: SemiBoxedExpression[]): BoxedExpression[];
-    fn(head: string, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
+    fn(head: string, ops: BoxedExpression[], options?: {
+        canonical: boolean;
+    }): BoxedExpression;
     /** @internal */
     _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
-    error(message: ['invalid-domain', ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedDomain;
     error(message: string | [string, ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedExpression;
     hold(expr: SemiBoxedExpression): BoxedExpression;
     add(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;

package/dist/types/compute-engine/cost-function.d.ts

@@ -1,3 +1,3 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare function costFunction(expr: BoxedExpression): number;
 export declare const DEFAULT_COST_FUNCTION: typeof costFunction;

package/dist/types/compute-engine/domain-utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import { Decimal } from 'decimal.js';
 import { BoxedExpression, Rational } from './public';
 /** Quickly determine the numeric domain of a number or constant

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-algebra.d.ts

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-arithmetic.d.ts

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-calculus.d.ts

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-core.d.ts

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const DEFINITIONS_CORE: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-inequalities.d.ts

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-logic.d.ts

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const DEFINITIONS_LOGIC: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-other.d.ts

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const DEFINITIONS_OTHERS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-sets.d.ts

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-symbols.d.ts

@@ -1,2 +1,3 @@
-/* 0.12.3 */
+/* 0.12.5 */
+export declare const SYMBOLS: [string, string, number][];
 export declare const DEFINITIONS_SYMBOLS: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-trigonometry.d.ts

@@ -1,2 +1,2 @@
-/* 0.12.3 */
+/* 0.12.5 */
 export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions.d.ts

@@ -1,36 +1,45 @@
-/* 0.12.3 */
+/* 0.12.5 */
 import { WarningSignal } from '../../../common/signals';
 export type CommonEntry = {
     name?: string;
     serialize: SerializeHandler | LatexString;
 };
-export type SymbolEntry = CommonEntry & {
-    kind: 'symbol';
+export type IndexedIdentifierEntry = CommonEntry & {
+    kind: 'identifier';
     precedence: number;
-    parse: SymbolParseHandler;
+    parse: IdentifierParseHandler;
 };
-export type FunctionEntry = CommonEntry & {
+/**
+ * A function has the following form:
+ * - a prefix such as `\mathrm` or `\operatorname`
+ * - a trigger string, such as `gcd`
+ * - some postfix operators such as `\prime`
+ * - an optional list of arguments in an enclosure (parentheses)
+ *
+ * Functions of this type are indexed in the dictionary by their trigger string.
+ */
+export type IndexedFunctionEntry = CommonEntry & {
     kind: 'function';
     parse: FunctionParseHandler;
 };
-export type MatchfixEntry = CommonEntry & {
+export type IndexedMatchfixEntry = CommonEntry & {
     kind: 'matchfix';
     openDelimiter: Delimiter | LatexToken[];
     closeDelimiter: Delimiter | LatexToken[];
     parse: MatchfixParseHandler;
 };
-export type InfixEntry = CommonEntry & {
+export type IndexedInfixEntry = CommonEntry & {
     kind: 'infix';
     associativity: 'right' | 'left' | 'non' | 'both';
     precedence: number;
     parse: InfixParseHandler;
 };
-export type PrefixEntry = CommonEntry & {
+export type IndexedPrefixEntry = CommonEntry & {
     kind: 'prefix';
     precedence: number;
     parse: PrefixParseHandler;
 };
-export type PostfixEntry = CommonEntry & {
+export type IndexedPostfixEntry = CommonEntry & {
     kind: 'postfix';
     precedence: number;
     parse: PostfixParseHandler;
@@ -39,16 +48,16 @@ export type EnvironmentEntry = CommonEntry & {
     kind: 'environment';
     parse: EnvironmentParseHandler;
 };
-export type IndexedLatexDictionaryEntry = FunctionEntry | SymbolEntry | MatchfixEntry | InfixEntry | PrefixEntry | PostfixEntry | EnvironmentEntry;
+export type IndexedLatexDictionaryEntry = IndexedFunctionEntry | IndexedIdentifierEntry | IndexedMatchfixEntry | IndexedInfixEntry | IndexedPrefixEntry | IndexedPostfixEntry | EnvironmentEntry;
 export type IndexedLatexDictionary = {
     lookahead: number;
     name: Map<string, IndexedLatexDictionaryEntry>;
-    function: Map<string, FunctionEntry[]>;
-    symbol: (Map<LatexString, SymbolEntry[]> | null)[];
-    prefix: (Map<LatexString, PrefixEntry[]> | null)[];
-    infix: (Map<LatexString, InfixEntry[]> | null)[];
-    postfix: (Map<LatexString, PostfixEntry[]> | null)[];
-    matchfix: MatchfixEntry[];
+    function: Map<string, IndexedFunctionEntry[]>;
+    identifier: (Map<LatexString, IndexedIdentifierEntry[]> | null)[];
+    prefix: (Map<LatexString, IndexedPrefixEntry[]> | null)[];
+    infix: (Map<LatexString, IndexedInfixEntry[]> | null)[];
+    postfix: (Map<LatexString, IndexedPostfixEntry[]> | null)[];
+    matchfix: IndexedMatchfixEntry[];
     environment: Map<string, EnvironmentEntry>;
 };
 export declare function indexLatexDictionary(dic: readonly LatexDictionaryEntry[], onError: (sig: WarningSignal) => void): IndexedLatexDictionary;