@cortex-js/compute-engine 0.24.1 → 0.25.1

package/dist/math-json.min.js

@@ -1,4 +1,4 @@
-/** MathJSON 0.24.1 */
+/** MathJSON 0.25.1 */
     (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 f=Object.defineProperty;var T=Object.getOwnPropertyDescriptor;var v=Object.getOwnPropertyNames;var k=Object.prototype.hasOwnProperty;var D=(n,t)=>{for(var e in t)f(n,e,{get:t[e],enumerable:!0})},R=(n,t,e,i)=>{if(t&&typeof t=="object"||typeof t=="function")for(let r of v(t))!k.call(n,r)&&r!==e&&f(n,r,{get:()=>t[r],enumerable:!(i=T(t,r))||i.enumerable});return n};var _=n=>R(f({},"__esModule",{value:!0}),n);var z={};D(z,{applyRecursively:()=>J,getDictionary:()=>y,getStringValue:()=>m,head:()=>o,headName:()=>I,isDictionaryObject:()=>M,isFunctionObject:()=>u,isStringObject:()=>S,isSymbolObject:()=>d,mapArgs:()=>$,nops:()=>E,op:()=>s,symbol:()=>A,version:()=>X});function d(n){return n!==null&&typeof n=="object"&&"sym"in n}function S(n){return n!==null&&typeof n=="object"&&"str"in n}function u(n){return n!==null&&typeof n=="object"&&"fn"in n}function M(n){return n!==null&&typeof n=="object"&&"dict"in n}var c;function N(n){if(!c){let e=`^[${["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"].map(i=>`\\p{Script=${i}}`).join("")}]*$`;c=new RegExp(e,"u")}return c.test(n)}function a(n){return/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(n)||O.test(n)?!0:N(n)?/^[\p{XIDS}_]\p{XIDC}*$/u.test(n):!1}var F="\\u{FE0F}",V="\\u{20E3}",L="\\u{200D}",P="\\p{RI}\\p{RI}",w="(?:[\\u{E0020}-\\u{E007E}]+\\u{E007F})",b=`(?:\\p{EMod}|${F}${V}?|${w})`,C="(?:(?=\\P{XIDC})\\p{Emoji})",h=`(?:${C}${b}*|\\p{Emoji}${b}+|${P})`,j=`(?:${h})(${L}${h})*`,G=new RegExp(`(?:${j})+`,"u"),O=new RegExp(`^(?:${j})+$`,"u");function q(n){return typeof n!="string"?"not-a-string":n===""?"empty-string":n.normalize()!==n?"expected-nfc":/[\u200E\u200F\u2066-\u2069\u202A-\u202E]/.test(n)?"unexpected-bidi-marker":O.test(n)?"valid":/\p{XIDC}/u.test(n)&&G.test(n)?"unexpected-mixed-emoji":N(n)?a(n)?"valid":a(n[0])?"invalid-char":"invalid-first-char":"unexpected-script"}function m(n){return n==null?null:typeof n=="object"&&"str"in n?n.str:typeof n!="string"||n.length<2||n[0]!=="'"||n[n.length-1]!=="'"?null:n.substring(1,n.length-1)}function o(n){return Array.isArray(n)?typeof n[0]=="string"&&!a(n[0])?(console.error(`Invalid identifier "${n[0]}": ${q(n[0])}`),null):n[0]:n==null?null:u(n)?n.fn[0]:null}function I(n){let t=o(n);return typeof t=="string"?t:""}function H(n){return Array.isArray(n)?n.slice(1):n==null?null:u(n)?n.fn.slice(1):null}function s(n,t){return Array.isArray(n)?n[t]??null:n==null?null:u(n)?n.fn[t]??null:null}function K(n){return s(n,1)}function Z(n){return s(n,2)}function E(n){return n==null?0:Array.isArray(n)?Math.max(0,n.length-1):u(n)?Math.max(0,n.fn.length-1):0}function A(n){if(typeof n=="string")return/^[+-]?[0-9\.]/.test(n)||n.length>=2&&n[0]==="'"&&n[n.length-1]==="'"?null:n;if(n==null)return null;let t=d(n)?n.sym:n;return typeof t!="string"?null:t}function p(n){let t=o(n);if(t==="KeyValuePair"||t==="Tuple"||t==="Pair"){let e=m(K(n));return e?[e,Z(n)??"Nothing"]:null}return null}function y(n){if(n===null)return null;if(typeof n=="object"&&"dict"in n)return n.dict;let t=p(n);if(t)return{[t[0]]:t[1]};if(o(n)==="Dictionary"){let i={};for(let r=1;r<E(n);r++){let l=p(s(n,r));l&&(i[l[0]]=l[1])}return i}return null}function J(n,t){let e=o(n);if(e!==null)return[t(e),...(H(n)??[]).map(t)];let i=y(n);if(i!==null){let r=Object.keys(i),l={};for(let g of r)l[g]=t(i[g]);return{dict:l}}return t(n)}function $(n,t){let e=null;if(Array.isArray(n)&&(e=n),u(n)&&(e=n.fn),e===null)return[];let i=1,r=[];for(;i<e.length;)r.push(t(e[i])),i+=1;return r}var X="0.24.1";return _(z);})();
+var MathJson=(()=>{var f=Object.defineProperty;var T=Object.getOwnPropertyDescriptor;var v=Object.getOwnPropertyNames;var k=Object.prototype.hasOwnProperty;var D=(n,t)=>{for(var e in t)f(n,e,{get:t[e],enumerable:!0})},F=(n,t,e,i)=>{if(t&&typeof t=="object"||typeof t=="function")for(let r of v(t))!k.call(n,r)&&r!==e&&f(n,r,{get:()=>t[r],enumerable:!(i=T(t,r))||i.enumerable});return n};var R=n=>F(f({},"__esModule",{value:!0}),n);var z={};D(z,{applyRecursively:()=>A,getDictionary:()=>y,getStringValue:()=>m,head:()=>l,headName:()=>j,isDictionaryObject:()=>S,isFunctionObject:()=>u,isStringObject:()=>M,isSymbolObject:()=>d,mapArgs:()=>$,nops:()=>E,op:()=>s,symbol:()=>O,version:()=>X});function d(n){return n!==null&&typeof n=="object"&&"sym"in n}function M(n){return n!==null&&typeof n=="object"&&"str"in n}function u(n){return n!==null&&typeof n=="object"&&"fn"in n}function S(n){return n!==null&&typeof n=="object"&&"dict"in n}var c;function I(n){if(!c){let e=`^[${["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"].map(i=>`\\p{Script=${i}}`).join("")}]*$`;c=new RegExp(e,"u")}return c.test(n)}function a(n){return/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(n)||N.test(n)?!0:I(n)?/^[\p{XIDS}_]\p{XIDC}*$/u.test(n):!1}var _="\\u{FE0F}",V="\\u{20E3}",L="\\u{200D}",P="\\p{RI}\\p{RI}",w="(?:[\\u{E0020}-\\u{E007E}]+\\u{E007F})",b=`(?:\\p{EMod}|${_}${V}?|${w})`,C="(?:(?=\\P{XIDC})\\p{Emoji})",h=`(?:${C}${b}*|\\p{Emoji}${b}+|${P})`,J=`(?:${h})(${L}${h})*`,G=new RegExp(`(?:${J})+`,"u"),N=new RegExp(`^(?:${J})+$`,"u");function q(n){return typeof n!="string"?"not-a-string":n===""?"empty-string":n.normalize()!==n?"expected-nfc":/[\u200E\u200F\u2066-\u2069\u202A-\u202E]/.test(n)?"unexpected-bidi-marker":N.test(n)?"valid":/\p{XIDC}/u.test(n)&&G.test(n)?"unexpected-mixed-emoji":I(n)?a(n)?"valid":a(n[0])?"invalid-char":"invalid-first-char":"unexpected-script"}function m(n){return n==null?null:typeof n=="object"&&"str"in n?n.str:typeof n!="string"||n.length<2||n[0]!=="'"||n[n.length-1]!=="'"?null:n.substring(1,n.length-1)}function l(n){return Array.isArray(n)?typeof n[0]=="string"&&!a(n[0])?(console.error(`Invalid identifier "${n[0]}": ${q(n[0])}`),null):n[0]:n==null?null:u(n)?n.fn[0]:null}function j(n){let t=l(n);return typeof t=="string"?t:""}function H(n){return Array.isArray(n)?n.slice(1):n==null?null:u(n)?n.fn.slice(1):null}function s(n,t){return Array.isArray(n)?n[t]??null:n==null?null:u(n)?n.fn[t]??null:null}function K(n){return s(n,1)}function Z(n){return s(n,2)}function E(n){return n==null?0:Array.isArray(n)?Math.max(0,n.length-1):u(n)?Math.max(0,n.fn.length-1):0}function O(n){if(typeof n=="string")return/^[+-]?[0-9\.]/.test(n)||n.length>=2&&n[0]==="'"&&n[n.length-1]==="'"?null:n;if(n==null)return null;let t=d(n)?n.sym:n;return typeof t!="string"?null:t}function p(n){let t=l(n);if(t==="KeyValuePair"||t==="Tuple"||t==="Pair"){let e=m(K(n));return e?[e,Z(n)??"Nothing"]:null}return null}function y(n){if(n===null)return null;if(typeof n=="object"&&"dict"in n)return n.dict;let t=p(n);if(t)return{[t[0]]:t[1]};if(l(n)==="Dictionary"){let i={};for(let r=1;r<E(n);r++){let o=p(s(n,r));o&&(i[o[0]]=o[1])}return i}return null}function A(n,t){let e=l(n);if(e!==null)return[t(e),...(H(n)??[]).map(t)];let i=y(n);if(i!==null){let r=Object.keys(i),o={};for(let g of r)o[g]=t(i[g]);return{dict:o}}return t(n)}function $(n,t){let e=null;if(Array.isArray(n)&&(e=n),u(n)&&(e=n.fn),e===null)return[];let i=1,r=[];for(;i<e.length;)r.push(t(e[i])),i+=1;return r}var X="0.25.1";return R(z);})();
 Object.assign(exports, MathJson); Object.defineProperty(exports, '__esModule', { value: true });}));

package/dist/types/common/ansi-codes.d.ts

@@ -1,4 +1,4 @@
-/* 0.24.1 */
+/* 0.25.1 */
 export declare const BLACK = "\u001B[30;1m${s}";
 export declare const GREY = "\u001B[30;1m${s}";
 export declare const GREEN = "\u001B[32;1m";

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

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

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

@@ -1,4 +1,4 @@
-/* 0.24.1 */
+/* 0.25.1 */
 /** @category Error Handling */
 export type RuntimeSignalCode = 'timeout' | 'out-of-memory' | 'recursion-depth-exceeded' | 'iteration-limit-exceeded';
 /** @category Error Handling */

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

@@ -1 +1 @@
-/* 0.24.1 */
+/* 0.25.1 */

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

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

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

@@ -1,7 +1,10 @@
-/* 0.24.1 */
+/* 0.25.1 */
 import { Decimal } from 'decimal.js';
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, BoxedFunctionDefinition, BoxedRuleSet, BoxedSymbolDefinition, BoxedDomain, EvaluateOptions, IComputeEngine, LatexString, Metadata, NOptions, PatternMatchOptions, SimplifyOptions, Substitution, RuntimeScope, DomainCompatibility, DomainLiteral, BoxedBaseDefinition, Rational, BoxedSubstitution, Rule, SemiBoxedExpression } from '../public';
+import { LatexString } from '../public';
+import { Rational } from '../numerics/rationals';
+import { BoxedBaseDefinition, BoxedDomain, BoxedExpression, BoxedFunctionDefinition, BoxedRuleSet, BoxedSubstitution, BoxedSymbolDefinition, CanonicalOptions, DomainCompatibility, DomainLiteral, EvaluateOptions, IComputeEngine, JsonSerializationOptions, Metadata, NOptions, PatternMatchOptions, Rule, RuntimeScope, SemiBoxedExpression, SimplifyOptions, Substitution } from './public';
+import { SerializeLatexOptions } from '../latex-syntax/public';
 /**
  * _BoxedExpression
  */
@@ -18,22 +21,28 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     /** Verbatim LaTeX, obtained from a source, i.e. from parsing,
      *  not generated synthetically
      */
-    protected _latex?: string;
+    verbatimLatex?: string;
     constructor(ce: IComputeEngine, metadata?: Metadata);
     /**
      *
      * `Object.valueOf()`: return a JavaScript primitive value for the expression
      *
+     * Primitive values are: boolean, number, bigint, string, null, undefined
+     *
      */
-    valueOf(): number | any[] | string | boolean;
+    valueOf(): number | Object | string | boolean;
     /** Object.toString() */
     toString(): string;
     print(): void;
     [Symbol.toPrimitive](hint: 'number' | 'string' | 'default'): number | string | null;
-    /** Called by `JSON.stringify()` when serializing to json */
+    /** Called by `JSON.stringify()` when serializing to json.
+     *
+     * Note: this is a standard method of JavaScript objects.
+     *
+     */
     toJSON(): Expression;
-    /** @internal */
-    get rawJson(): Expression;
+    toMathJson(options?: Readonly<Partial<JsonSerializationOptions>>): Expression;
+    toLatex(options?: Partial<SerializeLatexOptions>): LatexString;
     get scope(): RuntimeScope | null;
     /** Object.is() */
     is(rhs: any): boolean;
@@ -41,15 +50,14 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     get latex(): LatexString;
     set latex(val: LatexString);
     get symbol(): string | null;
-    get isNothing(): boolean;
     get string(): string | null;
-    getSubexpressions(head: string): BoxedExpression[];
-    get subexpressions(): BoxedExpression[];
-    get symbols(): string[];
-    get unknowns(): string[];
-    get freeVariables(): string[];
-    get errors(): BoxedExpression[];
-    get ops(): null | BoxedExpression[];
+    getSubexpressions(head: string): ReadonlyArray<BoxedExpression>;
+    get subexpressions(): ReadonlyArray<BoxedExpression>;
+    get symbols(): ReadonlyArray<string>;
+    get unknowns(): ReadonlyArray<string>;
+    get freeVariables(): ReadonlyArray<string>;
+    get errors(): ReadonlyArray<BoxedExpression>;
+    get ops(): null | ReadonlyArray<BoxedExpression>;
     get nops(): number;
     get op1(): BoxedExpression;
     get op2(): BoxedExpression;
@@ -75,9 +83,13 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     get shape(): number[];
     get rank(): number;
     subs(_sub: Substitution, options?: {
-        canonical: boolean;
+        canonical?: CanonicalOptions;
+    }): BoxedExpression;
+    map(fn: (x: BoxedExpression) => BoxedExpression, options?: {
+        canonical: CanonicalOptions;
+        recursive?: boolean;
     }): BoxedExpression;
-    solve(_vars: Iterable<string>): null | BoxedExpression[];
+    solve(_vars: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
     replace(_rules: BoxedRuleSet | Rule | Rule[]): null | BoxedExpression;
     has(_v: string | string[]): boolean;
     isLess(_rhs: BoxedExpression): boolean | undefined;
@@ -103,7 +115,7 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     get keysCount(): number;
     getKey(_key: string): BoxedExpression | undefined;
     hasKey(_key: string): boolean;
-    get value(): number | boolean | string | number[] | undefined;
+    get value(): number | boolean | string | Object | undefined;
     set value(_value: BoxedExpression | number | boolean | string | number[] | undefined);
     get domain(): BoxedDomain | undefined;
     set domain(_domain: BoxedDomain);
@@ -123,4 +135,4 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
         optimize: ('simplify' | 'evaluate')[];
     }): ((args: Record<string, any>) => any | undefined) | undefined;
 }
-export declare function getSubexpressions(expr: BoxedExpression, head: string): BoxedExpression[];
+export declare function getSubexpressions(expr: BoxedExpression, head: string): ReadonlyArray<BoxedExpression>;

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

@@ -1,7 +1,8 @@
-/* 0.24.1 */
+/* 0.25.1 */
 import { Decimal } from 'decimal.js';
-import { IComputeEngine, SemiBoxedExpression, BoxedExpression, Metadata, Rational, CanonicalForm } from '../public';
+import { IComputeEngine, SemiBoxedExpression, BoxedExpression, Metadata, CanonicalOptions } from './public';
 import { MathJsonNumber } from '../../math-json/math-json-format';
+import { Rational } from '../numerics/rationals';
 /**
  * ### THEORY OF OPERATIONS
  *
@@ -68,11 +69,11 @@ export declare function boxNumber(ce: IComputeEngine, num: MathJsonNumber | numb
  *
  * If available, preserve LaTeX and wikidata metadata in the boxed expression.
  *
- * Note that `boxFunction()` should only be called from `ce.box()`
+ * Note that `boxFunction()` should only be called from `ce.function()`
  */
-export declare function boxFunction(ce: IComputeEngine, head: string, ops: SemiBoxedExpression[], options: {
+export declare function boxFunction(ce: IComputeEngine, head: string, ops: readonly SemiBoxedExpression[], options?: {
     metadata?: Metadata;
-    canonical?: boolean;
+    canonical?: CanonicalOptions;
 }): BoxedExpression;
 /**
  * Notes about the boxed form:
@@ -93,13 +94,12 @@ export declare function boxFunction(ce: IComputeEngine, head: string, ops: SemiB
  *
  * [4] A `Negate` function applied to a number literal is converted to a number.
  *
- *
- * Note that `Negate` is only distributed over addition. In practice, having
+ *     Note that `Negate` is only distributed over addition. In practice, having
  * `Negate` factored on multiply/divide is more useful to detect patterns.
  *
- * Note that the `box()` function should only be called from `ce.box()`
+ * Note that this function should only be called from `ce.box()`
  *
  */
 export declare function box(ce: IComputeEngine, expr: null | undefined | Decimal | Complex | Rational | SemiBoxedExpression, options?: {
-    canonical?: boolean | CanonicalForm | CanonicalForm[];
+    canonical?: CanonicalOptions;
 }): BoxedExpression;

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

@@ -1,7 +1,7 @@
-/* 0.24.1 */
+/* 0.25.1 */
 import Decimal from 'decimal.js';
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, ReplaceOptions, Substitution, Metadata, PatternMatchOptions, BoxedDomain, BoxedSubstitution, Rule } from '../public';
+import { BoxedExpression, IComputeEngine, EvaluateOptions, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, ReplaceOptions, Substitution, Metadata, PatternMatchOptions, BoxedDomain, BoxedSubstitution, Rule, CanonicalOptions } from './public';
 import { _BoxedExpression } from './abstract-boxed-expression';
 /**
  * BoxedDictionary
@@ -14,7 +14,7 @@ export declare class BoxedDictionary extends _BoxedExpression {
     constructor(ce: IComputeEngine, dict: {
         [key: string]: SemiBoxedExpression;
     } | Map<string, BoxedExpression>, options?: {
-        canonical?: boolean;
+        canonical?: CanonicalOptions;
         metadata?: Metadata;
     });
     bind(): void;
@@ -43,6 +43,6 @@ export declare class BoxedDictionary extends _BoxedExpression {
     N(_options?: NOptions): BoxedExpression;
     replace(rules: BoxedRuleSet | Rule | Rule[], options?: ReplaceOptions): null | BoxedExpression;
     subs(sub: Substitution, options?: {
-        canonical: boolean;
+        canonical?: CanonicalOptions;
     }): BoxedExpression;
 }

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

@@ -1,8 +1,9 @@
-/* 0.24.1 */
+/* 0.25.1 */
 import Decimal from 'decimal.js';
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedDomain, BoxedExpression, BoxedSubstitution, DomainCompatibility, DomainConstructor, DomainExpression, DomainLiteral, IComputeEngine, Metadata, PatternMatchOptions, SemiBoxedExpression } from '../public';
+import { BoxedDomain, BoxedSubstitution, DomainCompatibility, DomainConstructor, DomainExpression, DomainLiteral, IComputeEngine, Metadata, PatternMatchOptions } from '../public';
 import { _BoxedExpression } from './abstract-boxed-expression';
+import { BoxedExpression, SemiBoxedExpression } from './public';
 /**
  * A `_BoxedDomain` is a wrapper around a boxed, canonical, domain
  * expression.

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

@@ -1,4 +1,5 @@
-/* 0.24.1 */
+/* 0.25.1 */
+import { BoxedExpression } from './public';
 export declare class _BoxedFunctionDefinition implements BoxedFunctionDefinition {
     engine: IComputeEngine;
     scope: RuntimeScope;

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

@@ -1,8 +1,9 @@
-/* 0.24.1 */
+/* 0.25.1 */
 import { Decimal } from 'decimal.js';
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, BoxedFunctionDefinition, IComputeEngine, NOptions, BoxedRuleSet, SemiBoxedExpression, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedSubstitution, EvaluateOptions, BoxedBaseDefinition, Hold, Rule } from '../public';
+import { BoxedFunctionDefinition, IComputeEngine, NOptions, BoxedRuleSet, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedSubstitution, EvaluateOptions, BoxedBaseDefinition, Hold, Rule, CanonicalOptions } from '../public';
+import { BoxedExpression, SemiBoxedExpression } from './public';
 /**
  * A boxed function represent an expression that can be
  * represented by a function call.
@@ -26,7 +27,7 @@ export declare class BoxedFunction extends _BoxedExpression {
     private _isPure;
     private _result;
     private _hash;
-    constructor(ce: IComputeEngine, head: string | BoxedExpression, ops: BoxedExpression[], options?: {
+    constructor(ce: IComputeEngine, head: string | BoxedExpression, ops: ReadonlyArray<BoxedExpression>, options?: {
         metadata?: Metadata;
         canonical?: boolean;
     });
@@ -39,19 +40,17 @@ export declare class BoxedFunction extends _BoxedExpression {
     set isCanonical(val: boolean);
     get isPure(): boolean;
     get json(): Expression;
-    get rawJson(): Expression;
     get scope(): RuntimeScope | null;
     get head(): string | BoxedExpression;
-    get ops(): BoxedExpression[];
+    get ops(): ReadonlyArray<BoxedExpression>;
     get nops(): number;
     get op1(): BoxedExpression;
     get op2(): BoxedExpression;
     get op3(): BoxedExpression;
     get isValid(): boolean;
     get canonical(): BoxedExpression;
-    map<T = BoxedExpression>(fn: (x: BoxedExpression) => T): IterableIterator<T>;
     subs(sub: Substitution, options?: {
-        canonical?: boolean;
+        canonical?: CanonicalOptions;
     }): BoxedExpression;
     replace(rules: BoxedRuleSet | Rule | Rule[], options?: ReplaceOptions): BoxedExpression | null;
     has(x: string | string[]): boolean;
@@ -75,9 +74,9 @@ export declare class BoxedFunction extends _BoxedExpression {
     simplify(options?: SimplifyOptions): BoxedExpression;
     evaluate(options?: EvaluateOptions): BoxedExpression;
     N(options?: NOptions): BoxedExpression;
-    solve(vars: string[]): null | BoxedExpression[];
+    solve(vars: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
 }
-export declare function makeCanonicalFunction(ce: IComputeEngine, head: string | BoxedExpression, ops: SemiBoxedExpression[], metadata?: Metadata): BoxedExpression;
+export declare function makeCanonicalFunction(ce: IComputeEngine, head: string | BoxedExpression, ops: ReadonlyArray<SemiBoxedExpression>, metadata?: Metadata): BoxedExpression;
 /** Apply the function `f` to elements of `xs`, except to the elements
  * described by `skip`:
  * - `all`: don't apply f to any elements
@@ -91,4 +90,4 @@ export declare function makeCanonicalFunction(ce: IComputeEngine, head: string |
  *
  * If `f` returns `null`, the element is not added to the result
  */
-export declare function holdMap(xs: BoxedExpression[], skip: Hold, associativeHead: string, f: (x: BoxedExpression) => BoxedExpression | null): BoxedExpression[];
+export declare function holdMap(xs: ReadonlyArray<BoxedExpression>, skip: Hold, associativeHead: string, f: (x: BoxedExpression) => BoxedExpression | null): ReadonlyArray<BoxedExpression>;

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

@@ -1,8 +1,9 @@
-/* 0.24.1 */
+/* 0.25.1 */
 import { Decimal } from 'decimal.js';
-import { Expression } from '../../math-json/math-json-format';
-import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, NOptions, PatternMatchOptions, Rational, SimplifyOptions, BoxedSubstitution, EvaluateOptions, SemiBoxedExpression } from '../public';
+import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, NOptions, PatternMatchOptions, SimplifyOptions, BoxedSubstitution, EvaluateOptions, SemiBoxedExpression } from '../public';
+import { Rational } from '../numerics/rationals';
 import { _BoxedExpression } from './abstract-boxed-expression';
+import { Expression } from '../../math-json';
 /**
  * BoxedNumber
  *
@@ -30,6 +31,7 @@ export declare class BoxedNumber extends _BoxedExpression {
         canonical?: boolean;
     });
     get hash(): number;
+    get json(): Expression;
     get head(): string;
     get isPure(): boolean;
     get isExact(): boolean;
@@ -38,7 +40,6 @@ export declare class BoxedNumber extends _BoxedExpression {
     get complexity(): number;
     get numericValue(): number | Decimal | Complex | Rational;
     get domain(): BoxedDomain;
-    get json(): Expression;
     get sgn(): -1 | 0 | 1 | undefined | null;
     isSame(rhs: BoxedExpression): boolean;
     isEqual(rhs: BoxedExpression): boolean;

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

@@ -1,17 +1,4 @@
-/* 0.24.1 */
-import { BoxedSymbol } from './boxed-symbol';
-import Complex from 'complex.js';
-import Decimal from 'decimal.js';
+/* 0.25.1 */
+import { BoxedExpression } from './public';
 export declare function isWildcard(expr: BoxedExpression): expr is BoxedSymbol;
 export declare function wildcardName(expr: BoxedExpression): string | null;
-/**
- * The function attempts to match a subject expression to a
- * [pattern](/compute-engine/guides/patterns-and-rules/).
- *
- * If the match is successful, it returns a `Substitution` indicating how to
- * transform the pattern to become the subject.
- *
- * If the expression does not match the pattern, it returns `null`.
- *
- */
-export declare function match(subject: BoxedExpression, pattern: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression | BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;

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

@@ -1,6 +1,5 @@
-/* 0.24.1 */
-import { _BoxedExpression } from './abstract-boxed-expression';
-import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, PatternMatchOptions, BoxedSubstitution, SemiBoxedExpression } from '../public';
+/* 0.25.1 */
+import { BoxedExpression, BoxedDomain, IComputeEngine, Metadata, PatternMatchOptions, BoxedSubstitution, SemiBoxedExpression } from './public';
 import Complex from 'complex.js';
 import Decimal from 'decimal.js';
 /**
@@ -11,8 +10,8 @@ import Decimal from 'decimal.js';
 export declare class BoxedString extends _BoxedExpression {
     private readonly _string;
     constructor(ce: IComputeEngine, expr: string, metadata?: Metadata);
+    get json(): string;
     get hash(): number;
-    get json(): Expression;
     get head(): string;
     get isPure(): boolean;
     get isCanonical(): boolean;

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

@@ -1,4 +1,4 @@
-/* 0.24.1 */
+/* 0.25.1 */
 /**
  * ### THEORY OF OPERATIONS
  *

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

@@ -1,8 +1,8 @@
-/* 0.24.1 */
+/* 0.25.1 */
 import { Decimal } from 'decimal.js';
 import { Expression } from '../../math-json/math-json-format';
 import { _BoxedExpression } from './abstract-boxed-expression';
-import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedFunctionDefinition, BoxedBaseDefinition, DomainExpression, BoxedSubstitution, Rule, SemiBoxedExpression } from '../public';
+import { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, NOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOptions, BoxedDomain, RuntimeScope, BoxedFunctionDefinition, BoxedBaseDefinition, DomainExpression, BoxedSubstitution, Rule, SemiBoxedExpression, CanonicalOptions } from './public';
 /**
  * BoxedSymbol
  *
@@ -26,12 +26,12 @@ export declare class BoxedSymbol extends _BoxedExpression {
     private _def;
     constructor(ce: IComputeEngine, name: string, options?: {
         metadata?: Metadata;
-        canonical?: boolean;
+        canonical?: CanonicalOptions;
         def?: BoxedSymbolDefinition | BoxedFunctionDefinition;
     });
+    get json(): Expression;
     get hash(): number;
     get isPure(): boolean;
-    get json(): Expression;
     get scope(): RuntimeScope | null;
     get isConstant(): boolean;
     /**
@@ -42,11 +42,10 @@ export declare class BoxedSymbol extends _BoxedExpression {
     get isCanonical(): boolean;
     set isCanonical(val: boolean);
     get canonical(): BoxedExpression;
-    solve(vars: string[]): null | BoxedExpression[];
+    solve(vars: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
     get complexity(): number;
     get head(): string;
     get symbol(): string;
-    get isNothing(): boolean;
     get baseDefinition(): BoxedBaseDefinition | undefined;
     get symbolDefinition(): BoxedSymbolDefinition | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
@@ -57,7 +56,7 @@ export declare class BoxedSymbol extends _BoxedExpression {
      * f(x) => x:integer narrowed from integer to real
      */
     infer(domain: BoxedDomain): boolean;
-    get value(): number | boolean | string | number[] | undefined;
+    get value(): number | boolean | string | Object | undefined;
     set value(value: boolean | string | Decimal | Complex | {
         re: number;
         im: number;
@@ -104,7 +103,7 @@ export declare class BoxedSymbol extends _BoxedExpression {
     N(options?: NOptions): BoxedExpression;
     replace(rules: BoxedRuleSet | Rule | Rule[], options?: ReplaceOptions): BoxedExpression | null;
     subs(sub: Substitution, options?: {
-        canonical: boolean;
+        canonical?: CanonicalOptions;
     }): BoxedExpression;
 }
 export declare function makeCanonicalSymbol(ce: IComputeEngine, name: string): BoxedExpression;

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

@@ -1,4 +1,4 @@
-/* 0.24.1 */
+/* 0.25.1 */
 import Decimal from 'decimal.js';
 import { Expression } from '../../math-json/math-json-format';
 import { BoxedExpression, IComputeEngine, EvaluateOptions, NOptions, SimplifyOptions, Metadata, BoxedDomain, BoxedSubstitution, PatternMatchOptions, BoxedBaseDefinition, BoxedFunctionDefinition, SemiBoxedExpression } from '../public';
@@ -26,10 +26,10 @@ export declare class BoxedTensor extends _BoxedExpression {
     private _expression;
     constructor(ce: IComputeEngine, input: {
         head?: string;
-        ops: BoxedExpression[];
+        ops: ReadonlyArray<BoxedExpression>;
     } | AbstractTensor<'expression'>, options?: {
-        canonical?: boolean;
         metadata?: Metadata;
+        canonical?: boolean;
     });
     get expression(): BoxedExpression;
     /** Create the tensor on demand */
@@ -47,7 +47,7 @@ export declare class BoxedTensor extends _BoxedExpression {
     get complexity(): number;
     get head(): string;
     get nops(): number;
-    get ops(): BoxedExpression[];
+    get ops(): ReadonlyArray<BoxedExpression>;
     get op1(): BoxedExpression;
     get op2(): BoxedExpression;
     get op3(): BoxedExpression;
@@ -55,7 +55,6 @@ export declare class BoxedTensor extends _BoxedExpression {
     get rank(): number;
     get domain(): BoxedDomain | undefined;
     get json(): Expression;
-    get rawJson(): Expression;
     /** Structural equality */
     isSame(rhs: BoxedExpression): boolean;
     /** Mathematical equality */
@@ -66,8 +65,8 @@ export declare class BoxedTensor extends _BoxedExpression {
     N(options?: NOptions): BoxedExpression;
 }
 export declare function isBoxedTensor(val: unknown): val is BoxedTensor;
-export declare function expressionTensorInfo(head: string, rows: BoxedExpression[]): {
+export declare function expressionTensorInfo(head: string, rows: ReadonlyArray<BoxedExpression>): {
     shape: number[];
     dtype: keyof DataTypeMap;
 };
-export declare function expressionAsTensor<T extends TensorDataType>(head: string, rows: BoxedExpression[]): TensorData<T> | undefined;
+export declare function expressionAsTensor<T extends TensorDataType>(head: string, rows: ReadonlyArray<BoxedExpression>): TensorData<T> | undefined;

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

@@ -1,2 +1,2 @@
-/* 0.24.1 */
-export declare function canonicalForm(expr: BoxedExpression, forms: boolean | CanonicalForm | CanonicalForm[]): BoxedExpression;
+/* 0.25.1 */
+export declare function canonicalForm(expr: BoxedExpression, forms: CanonicalOptions): BoxedExpression;

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

@@ -0,0 +1,56 @@
+/* 0.25.1 */
+ *
+ * ## THEORY OF OPERATIONS
+ *
+ * In order to preserve exact results, some numeric operations are performed
+ * on "coefficients" which represent a product of a rational number,
+ * an algebraic numbers and the square root of an integer.
+ *
+ * A field is defined on these coefficients.
+ *
+ *
+ */
+import { Rational } from '../numerics/rationals';
+import { BoxedExpression } from './public';
+export interface CoefficientData {
+    float: number;
+    rational: Rational;
+    sqrt: number;
+}
+export declare class Coefficient implements CoefficientData {
+    static zero: Coefficient;
+    static one: Coefficient;
+    /**
+     * Attempt to factor a numeric coefficient `c` and a `rest` out of a
+     * canonical expression `expr` such that `ce.mul(c, rest)` is equal to `expr`.
+     *
+     * Attempts to make `rest` a positive value (i.e. pulls out negative sign).
+     *
+     * For example:
+     *
+     * ['Multiply', 2, 'x', 3, 'a']
+     *    -> [6, ['Multiply', 'x', 'a']]
+     *
+     * ['Divide', ['Multiply', 2, 'x'], ['Multiply', 3, 'y', 'a']]
+     *    -> [['Rational', 2, 3], ['Divide', 'x', ['Multiply, 'y', 'a']]]
+     */
+    static fromExpression(expr: BoxedExpression): [coef: Coefficient, rest: BoxedExpression];
+    float: number;
+    rational: Rational;
+    sqrt: number;
+    constructor(value?: number | Partial<CoefficientData>);
+    asFloat(): number;
+    asRational(): Rational;
+    normalize(): void;
+    get isZero(): boolean;
+    get isOne(): boolean;
+    get sign(): number;
+    neg(): Coefficient;
+    inv(): Coefficient;
+    mul(other: Partial<CoefficientData> | number | Rational): Coefficient;
+    pow(exponent: number): Coefficient;
+    div(other: Partial<CoefficientData> | number | Rational): Coefficient;
+    add(other: Partial<CoefficientData> | number | Rational): Coefficient;
+    sub(other: Partial<CoefficientData> | number | Rational): Coefficient;
+    eq(other: Coefficient): boolean;
+}

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

@@ -1,4 +1,4 @@
-/* 0.24.1 */
+/* 0.25.1 */
 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/factor.d.ts

@@ -0,0 +1,11 @@
+/* 0.25.1 */
+import Decimal from 'decimal.js';
+import { Rational } from '../numerics/rationals';
+import { BoxedExpression } from './public';
+export declare function applyCoefficient(value: number | Decimal | Complex | Rational | null, coef: Rational): number | Decimal | Complex | Rational | null;
+/** Combine rational expressions into a single fraction */
+export declare function together(op: BoxedExpression): BoxedExpression;
+/**
+ * Return a list of expressions that multiply together to form `expr`.
+ */
+export declare function factor(expr: BoxedExpression): BoxedExpression;

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

@@ -0,0 +1,14 @@
+/* 0.25.1 */
+import Decimal from 'decimal.js';
+import { BoxedSubstitution, PatternMatchOptions, BoxedExpression, SemiBoxedExpression } from './public';
+/**
+ * The function attempts to match a subject expression to a
+ * [pattern](/compute-engine/guides/patterns-and-rules/).
+ *
+ * If the match is successful, it returns a `Substitution` indicating how to
+ * transform the pattern to become the subject.
+ *
+ * If the expression does not match the pattern, it returns `null`.
+ *
+ */
+export declare function match(subject: BoxedExpression, pattern: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression | BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;

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

@@ -0,0 +1,41 @@
+/* 0.25.1 */
+import { Rational } from '../numerics/rationals';
+import { BoxedExpression } from './public';
+/**
+ * Attempt to factor a numeric coefficient `c` and a `rest` out of a
+ * canonical expression `expr` such that `ce.mul(c, rest)` is equal to `expr`.
+ *
+ * Attempts to make `rest` a positive value (i.e. pulls out negative sign).
+ *
+ * For example:
+ *
+ * ['Multiply', 2, 'x', 3, 'a']
+ *    -> [6, ['Multiply', 'x', 'a']]
+ *
+ * ['Divide', ['Multiply', 2, 'x'], ['Multiply', 3, 'y', 'a']]
+ *    -> [['Rational', 2, 3], ['Divide', 'x', ['Multiply, 'y', 'a']]]
+ */
+export declare function asCoefficient(expr: BoxedExpression): [coef: Rational, rest: BoxedExpression];
+export declare function asRational(expr: BoxedExpression): Rational | undefined;
+export declare function asApproximateRational(expr: BoxedExpression): Rational | undefined;
+export declare function div(lhs: Rational, rhs: Rational): Rational;
+/**
+ * Add a literal numeric value to a rational.
+ * If the rational is a bigint, this is a hint to do the calculation in bigint
+ * (no need to check `bignumPreferred()`).
+ * @param lhs
+ * @param rhs
+ * @returns
+ */
+export declare function add(lhs: Rational, rhs: BoxedExpression | Rational): Rational;
+export declare function mul(lhs: Rational, rhs: BoxedExpression | Rational): Rational;
+export declare function asFloat(expr: BoxedExpression | undefined): number | null;
+export declare function asBignum(expr: BoxedExpression | undefined): Decimal | null;
+export declare function asMachineInteger(expr: BoxedExpression | undefined): number | null;
+/**
+ *
+ * @param lhs
+ * @param rhs
+ * @returns the sign (-1, 0, 1) of the difference between `lhs` and `rhs`
+ */
+export declare function signDiff(lhs: BoxedExpression, rhs: BoxedExpression, tolerance?: number): -1 | 0 | 1 | undefined;