@cortex-js/compute-engine 0.35.6 → 0.50.1

package/dist/math-json.esm.js

@@ -1,4 +1,4 @@
-/** Compute Engine 0.35.6 */
+/** Compute Engine 0.50.1 */
 
 // src/math-json/utils.ts
 function isNumberObject(expr) {
@@ -115,7 +115,7 @@ function expressionToDictionaryValue(expr) {
 }
 
 // src/math-json.ts
-var version = "0.35.6";
+var version = "0.50.1";
 export {
   dictionaryFromExpression,
   isFunctionObject,

package/dist/math-json.min.esm.js

@@ -1,2 +1,2 @@
-/** Compute Engine 0.35.6 */
-function d(n){return n!==null&&typeof n=="object"&&"num"in n}function s(n){return n!==null&&typeof n=="object"&&"sym"in n}function a(n){return n!==null&&typeof n=="object"&&"str"in n}function m(n){return n!==null&&typeof n=="object"&&"dict"in n&&typeof n.dict=="object"&&!Array.isArray(n.dict)&&n.dict!==null}function u(n){return n!==null&&typeof n=="object"&&"fn"in n&&Array.isArray(n.fn)&&n.fn.length>0&&typeof n.fn[0]=="string"}function c(n){return n==null?null:typeof n=="object"&&"str"in n?n.str:typeof n!="string"?null:n.length>=2&&n.at(0)==="'"&&n.at(-1)==="'"?n.substring(1,n.length-1):M(n)||b(n)?null:n}function l(n){return Array.isArray(n)?n[0]:n==null?"":u(n)?n.fn[0]:""}function y(n){return Array.isArray(n)?n.slice(1):n!==void 0&&u(n)?n.fn.slice(1):[]}function E(n,t){return Array.isArray(n)?n[t]??null:n===null||!u(n)?null:n.fn[t]??null}function h(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 g(n){return typeof n=="string"&&b(n)?n.length>=2&&n.at(0)==="`"&&n.at(-1)==="`"?n.slice(1,-1):n:n==null?null:s(n)?n.sym:null}function f(n){let t=l(n);if(t==="KeyValuePair"||t==="Tuple"||t==="Pair"){let[i,r]=y(n),e=c(i);return e?[e,r??"Nothing"]:null}return null}function j(n){if(n===null)return null;if(m(n))return n;let t=f(n);if(t)return{[t[0]]:t[1]};if(l(n)==="Dictionary"){let i={},r=y(n);for(let e=1;e<h(n);e++){let o=f(r[e]);o&&(i[o[0]]=A(o[1])??"Nothing")}return{dict:i}}return null}function O(n,t){let i=null;if(Array.isArray(n)&&(i=n),u(n)&&(i=n.fn),i===null)return[];let r=1,e=[];for(;r<i.length;)e.push(t(i[r])),r+=1;return e}function M(n){return/^(nan|oo|\+oo|-oo|infinity|\+infinity|-infinity)$/i.test(n)||/^[+-]?(0|[1-9][0-9]*)(\.[0-9]+)?(\([0-9]+\))?([eE][+-]?[0-9]+)?$/.test(n)}function b(n){return/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(n)||n.length>=2&&n[0]==="`"&&n[n.length-1]==="`"}function A(n){return n==null?null:a(n)?n.str:d(n)?parseFloat(n.num):s(n)?n.sym:typeof n=="string"||typeof n=="number"?n:Array.isArray(n)?{fn:n}:n}var S="0.35.6";export{j as dictionaryFromExpression,u as isFunctionObject,a as isStringObject,s as isSymbolObject,O as mapArgs,E as operand,l as operator,c as stringValue,g as symbol,S as version};
+/** Compute Engine 0.50.1 */
+function b(n){return n!==null&&typeof n=="object"&&"num"in n}function s(n){return n!==null&&typeof n=="object"&&"sym"in n}function f(n){return n!==null&&typeof n=="object"&&"str"in n}function M(n){return n!==null&&typeof n=="object"&&"dict"in n&&typeof n.dict=="object"&&!Array.isArray(n.dict)&&n.dict!==null}function r(n){return n!==null&&typeof n=="object"&&"fn"in n&&Array.isArray(n.fn)&&n.fn.length>0&&typeof n.fn[0]=="string"}function c(n){return n==null?null:typeof n=="object"&&"str"in n?n.str:typeof n!="string"?null:n.length>=2&&n.at(0)==="'"&&n.at(-1)==="'"?n.substring(1,n.length-1):j(n)||y(n)?null:n}function l(n){return Array.isArray(n)?n[0]:n==null?"":r(n)?n.fn[0]:""}function h(n){return Array.isArray(n)?n.slice(1):n!==void 0&&r(n)?n.fn.slice(1):[]}function d(n,t){return Array.isArray(n)?n[t]??null:n===null||!r(n)?null:n.fn[t]??null}function J(n){return n==null?0:Array.isArray(n)?Math.max(0,n.length-1):r(n)?Math.max(0,n.fn.length-1):0}function m(n){return typeof n=="string"&&y(n)?n.length>=2&&n.at(0)==="`"&&n.at(-1)==="`"?n.slice(1,-1):n:n==null?null:s(n)?n.sym:null}function a(n){let t=l(n);if(t==="KeyValuePair"||t==="Tuple"||t==="Pair"){let[i,o]=h(n),e=c(i);return e?[e,o??"Nothing"]:null}return null}function E(n){if(n===null)return null;if(M(n))return n;let t=a(n);if(t)return{[t[0]]:t[1]};if(l(n)==="Dictionary"){let i={},o=h(n);for(let e=1;e<J(n);e++){let u=a(o[e]);u&&(i[u[0]]=O(u[1])??"Nothing")}return{dict:i}}return null}function g(n,t){let i=null;if(Array.isArray(n)&&(i=n),r(n)&&(i=n.fn),i===null)return[];let o=1,e=[];for(;o<i.length;)e.push(t(i[o])),o+=1;return e}function j(n){return/^(nan|oo|\+oo|-oo|infinity|\+infinity|-infinity)$/i.test(n)||/^[+-]?(0|[1-9][0-9]*)(\.[0-9]+)?(\([0-9]+\))?([eE][+-]?[0-9]+)?$/.test(n)}function y(n){return/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(n)||n.length>=2&&n[0]==="`"&&n[n.length-1]==="`"}function O(n){return n==null?null:f(n)?n.str:b(n)?parseFloat(n.num):s(n)?n.sym:typeof n=="string"||typeof n=="number"?n:Array.isArray(n)?{fn:n}:n}var S="0.50.1";export{E as dictionaryFromExpression,r as isFunctionObject,f as isStringObject,s as isSymbolObject,g as mapArgs,d as operand,l as operator,c as stringValue,m as symbol,S as version};

package/dist/math-json.min.umd.js

@@ -1,4 +1,4 @@
-/** MathJSON 0.35.6 */
+/** MathJSON 0.50.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 j=Object.getOwnPropertyDescriptor;var O=Object.getOwnPropertyNames;var M=Object.prototype.hasOwnProperty;var A=(n,t)=>{for(var i in t)f(n,i,{get:t[i],enumerable:!0})},J=(n,t,i,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of O(t))!M.call(n,e)&&e!==i&&f(n,e,{get:()=>t[e],enumerable:!(r=j(t,e))||r.enumerable});return n};var S=n=>J(f({},"__esModule",{value:!0}),n);var T={};A(T,{dictionaryFromExpression:()=>E,isFunctionObject:()=>u,isStringObject:()=>a,isSymbolObject:()=>o,mapArgs:()=>h,operand:()=>d,operator:()=>s,stringValue:()=>c,symbol:()=>m,version:()=>V});function N(n){return n!==null&&typeof n=="object"&&"num"in n}function o(n){return n!==null&&typeof n=="object"&&"sym"in n}function a(n){return n!==null&&typeof n=="object"&&"str"in n}function p(n){return n!==null&&typeof n=="object"&&"dict"in n&&typeof n.dict=="object"&&!Array.isArray(n.dict)&&n.dict!==null}function u(n){return n!==null&&typeof n=="object"&&"fn"in n&&Array.isArray(n.fn)&&n.fn.length>0&&typeof n.fn[0]=="string"}function c(n){return n==null?null:typeof n=="object"&&"str"in n?n.str:typeof n!="string"?null:n.length>=2&&n.at(0)==="'"&&n.at(-1)==="'"?n.substring(1,n.length-1):k(n)||g(n)?null:n}function s(n){return Array.isArray(n)?n[0]:n==null?"":u(n)?n.fn[0]:""}function b(n){return Array.isArray(n)?n.slice(1):n!==void 0&&u(n)?n.fn.slice(1):[]}function d(n,t){return Array.isArray(n)?n[t]??null:n===null||!u(n)?null:n.fn[t]??null}function D(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 m(n){return typeof n=="string"&&g(n)?n.length>=2&&n.at(0)==="`"&&n.at(-1)==="`"?n.slice(1,-1):n:n==null?null:o(n)?n.sym:null}function y(n){let t=s(n);if(t==="KeyValuePair"||t==="Tuple"||t==="Pair"){let[i,r]=b(n),e=c(i);return e?[e,r??"Nothing"]:null}return null}function E(n){if(n===null)return null;if(p(n))return n;let t=y(n);if(t)return{[t[0]]:t[1]};if(s(n)==="Dictionary"){let i={},r=b(n);for(let e=1;e<D(n);e++){let l=y(r[e]);l&&(i[l[0]]=F(l[1])??"Nothing")}return{dict:i}}return null}function h(n,t){let i=null;if(Array.isArray(n)&&(i=n),u(n)&&(i=n.fn),i===null)return[];let r=1,e=[];for(;r<i.length;)e.push(t(i[r])),r+=1;return e}function k(n){return/^(nan|oo|\+oo|-oo|infinity|\+infinity|-infinity)$/i.test(n)||/^[+-]?(0|[1-9][0-9]*)(\.[0-9]+)?(\([0-9]+\))?([eE][+-]?[0-9]+)?$/.test(n)}function g(n){return/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(n)||n.length>=2&&n[0]==="`"&&n[n.length-1]==="`"}function F(n){return n==null?null:a(n)?n.str:N(n)?parseFloat(n.num):o(n)?n.sym:typeof n=="string"||typeof n=="number"?n:Array.isArray(n)?{fn:n}:n}var V="0.35.6";return S(T);})();
+var MathJson=(()=>{var a=Object.defineProperty;var E=Object.getOwnPropertyDescriptor;var g=Object.getOwnPropertyNames;var j=Object.prototype.hasOwnProperty;var O=(n,t)=>{for(var i in t)a(n,i,{get:t[i],enumerable:!0})},A=(n,t,i,o)=>{if(t&&typeof t=="object"||typeof t=="function")for(let e of g(t))!j.call(n,e)&&e!==i&&a(n,e,{get:()=>t[e],enumerable:!(o=E(t,e))||o.enumerable});return n};var S=n=>A(a({},"__esModule",{value:!0}),n);var T={};O(T,{dictionaryFromExpression:()=>d,isFunctionObject:()=>r,isStringObject:()=>f,isSymbolObject:()=>u,mapArgs:()=>J,operand:()=>b,operator:()=>s,stringValue:()=>c,symbol:()=>M,version:()=>V});function N(n){return n!==null&&typeof n=="object"&&"num"in n}function u(n){return n!==null&&typeof n=="object"&&"sym"in n}function f(n){return n!==null&&typeof n=="object"&&"str"in n}function p(n){return n!==null&&typeof n=="object"&&"dict"in n&&typeof n.dict=="object"&&!Array.isArray(n.dict)&&n.dict!==null}function r(n){return n!==null&&typeof n=="object"&&"fn"in n&&Array.isArray(n.fn)&&n.fn.length>0&&typeof n.fn[0]=="string"}function c(n){return n==null?null:typeof n=="object"&&"str"in n?n.str:typeof n!="string"?null:n.length>=2&&n.at(0)==="'"&&n.at(-1)==="'"?n.substring(1,n.length-1):k(n)||m(n)?null:n}function s(n){return Array.isArray(n)?n[0]:n==null?"":r(n)?n.fn[0]:""}function y(n){return Array.isArray(n)?n.slice(1):n!==void 0&&r(n)?n.fn.slice(1):[]}function b(n,t){return Array.isArray(n)?n[t]??null:n===null||!r(n)?null:n.fn[t]??null}function D(n){return n==null?0:Array.isArray(n)?Math.max(0,n.length-1):r(n)?Math.max(0,n.fn.length-1):0}function M(n){return typeof n=="string"&&m(n)?n.length>=2&&n.at(0)==="`"&&n.at(-1)==="`"?n.slice(1,-1):n:n==null?null:u(n)?n.sym:null}function h(n){let t=s(n);if(t==="KeyValuePair"||t==="Tuple"||t==="Pair"){let[i,o]=y(n),e=c(i);return e?[e,o??"Nothing"]:null}return null}function d(n){if(n===null)return null;if(p(n))return n;let t=h(n);if(t)return{[t[0]]:t[1]};if(s(n)==="Dictionary"){let i={},o=y(n);for(let e=1;e<D(n);e++){let l=h(o[e]);l&&(i[l[0]]=F(l[1])??"Nothing")}return{dict:i}}return null}function J(n,t){let i=null;if(Array.isArray(n)&&(i=n),r(n)&&(i=n.fn),i===null)return[];let o=1,e=[];for(;o<i.length;)e.push(t(i[o])),o+=1;return e}function k(n){return/^(nan|oo|\+oo|-oo|infinity|\+infinity|-infinity)$/i.test(n)||/^[+-]?(0|[1-9][0-9]*)(\.[0-9]+)?(\([0-9]+\))?([eE][+-]?[0-9]+)?$/.test(n)}function m(n){return/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(n)||n.length>=2&&n[0]==="`"&&n[n.length-1]==="`"}function F(n){return n==null?null:f(n)?n.str:N(n)?parseFloat(n.num):u(n)?n.sym:typeof n=="string"||typeof n=="number"?n:Array.isArray(n)?{fn:n}:n}var V="0.50.1";return S(T);})();
 Object.assign(exports, MathJson); Object.defineProperty(exports, '__esModule', { value: true });}));

package/dist/math-json.umd.js

@@ -1,4 +1,4 @@
-/** MathJSON 0.35.6 */
+/** MathJSON 0.50.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 __defProp = Object.defineProperty;
@@ -149,7 +149,7 @@ var MathJson = (() => {
   }
 
   // src/math-json.ts
-  var version = "0.35.6";
+  var version = "0.50.1";
   return __toCommonJS(math_json_exports);
 })();
 Object.assign(exports, MathJson); Object.defineProperty(exports, '__esModule', { value: true });}));

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare const DEFAULT_COLOR = "\u001B[39m";
 export declare const DEFAULT_BG = "\u001B[49m";
 export declare const WHITE_BG = "\u001B[47m";

package/dist/types/common/configuration-change.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
     private _listeners;
     private _pending;
     private _version;

package/dist/types/common/fuzzy-string-match.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare function fuzzyStringMatch(invalidWord: string, validWords: string[]): string | null;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
     cause: unknown;
     value: T;
     constructor({ message, value, cause, }?: {

package/dist/types/common/one-of.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
     infer Head,
     ...infer Rem
 ] ? MergeTypes<Rem, Res & Head> : Res;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export type RuntimeSignalCode = 'timeout' | 'out-of-memory' | 'recursion-depth-exceeded' | 'iteration-limit-exceeded';
 /** @category Error Handling */
 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');

package/dist/types/common/type/ast-nodes.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
     kind: string;
     position: number;
     line: number;

package/dist/types/common/type/boxed-type.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /** @category Type */
 export declare class BoxedType {
     static unknown: BoxedType;

package/dist/types/common/type/lexer.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export interface Token {
     type: TokenType;
     value: string;

package/dist/types/common/type/parse.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /**
  * BNF grammar for the type parser:
  *

package/dist/types/common/type/parser.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 import { TypeNode } from './ast-nodes';
 import { TypeResolver } from './types';
 export declare class Parser {
@@ -19,6 +19,13 @@ export declare class Parser {
     private parseUnionType;
     private parseIntersectionType;
     private parsePrimaryType;
+    /**
+     * Scan forward from the current '(' to determine if this is a function
+     * signature (i.e. `(...)  ->`) without consuming any tokens. Tracks
+     * parenthesis depth so nested parens like `((string|number), expr?)` are
+     * handled correctly.
+     */
+    private isFunctionSignature;
     private parseFunctionSignature;
     private parseArgument;
     private parseNamedElement;

package/dist/types/common/type/primitive.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /** All the types representing numeric values */
 export declare const NUMERIC_TYPES: NumericPrimitiveType[];
 export declare const INDEXED_COLLECTION_TYPES: PrimitiveType[];
@@ -8,3 +8,4 @@ export declare const VALUE_TYPES: PrimitiveType[];
 export declare const EXPRESSION_TYPES: PrimitiveType[];
 export declare const PRIMITIVE_TYPES: PrimitiveType[];
 export declare function isValidPrimitiveType(s: any): s is PrimitiveType;
+export declare function isValidType(t: any): t is Readonly<Type>;

package/dist/types/common/type/reduce.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /**
  * Reduce the input type
  *

package/dist/types/common/type/serialize.d.ts

@@ -1,2 +1,2 @@
-/* 0.35.6 */
+/* 0.50.1 */
 export declare function typeToString(type: Type, precedence?: number): string;

package/dist/types/common/type/subtype.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /** Return true if lhs is a subtype of rhs */
 export declare function isPrimitiveSubtype(lhs: PrimitiveType, rhs: PrimitiveType): boolean;
 /** Return true if lhs is a subtype of rhs */

package/dist/types/common/type/type-builder.d.ts

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 import { Type, TypeResolver } from './types';
 export declare class TypeBuilder implements ASTVisitor<Type> {
     private typeResolver;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
  * A primitive type is a simple type that represents a concrete value.
  *
  * - `any`: the top type

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

@@ -1,4 +1,6 @@
-/* 0.35.6 */
+/* 0.50.1 */
+export { isValidType };
+import type { Type, FunctionSignature, TypeString } from './types';
 /** Convert two or more types into a more specific type that is a subtype of
  *  all the input types. The resulting type is usually more constrained and
  *  only encompasses values that belong to both input types.
@@ -33,4 +35,3 @@ export declare function functionSignature(type: Readonly<Type>): Type | undefine
 export declare function functionResult(type: Readonly<Type> | undefined): Type | undefined;
 export declare function collectionElementType(type: Readonly<Type>): Type | undefined;
 export declare function isValidTypeName(name: string): boolean;
-export declare function isValidType(t: any): t is Readonly<Type>;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
  *
  * <!--
  * !@consider?

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.1 */
 /**
  * Add an assumption, in the form of a predicate, for example:
  *
@@ -23,7 +23,7 @@
  * `forget` about any symbols in the new assumption.
  *
  */
-export declare function assume(proposition: BoxedExpression): AssumeResult;
+export declare function assume(proposition: Expression): AssumeResult;
 /**
  * Query assumptions to determine the sign of a symbol.
  *
@@ -40,23 +40,5 @@ export declare function assume(proposition: BoxedExpression): AssumeResult;
  * @returns The inferred sign, or undefined if no relevant assumptions found
  */
 export declare function getSignFromAssumptions(ce: ComputeEngine, symbol: string): Sign | undefined;
-/**
- * Get inequality bounds for a symbol from the assumption database.
- *
- * For example, if `x > 4` is assumed, this returns `{ lowerBound: 4, lowerStrict: true }`.
- * If `x <= 10` is assumed, this returns `{ upperBound: 10, upperStrict: false }`.
- *
- * Note: Assumptions are normalized to forms like:
- * - `x > 4` becomes `Less(Add(Negate(x), 4), 0)` i.e., `4 - x < 0`
- * - `x > 0` becomes `Less(Negate(x), 0)` i.e., `-x < 0`
- *
- * @param ce - The compute engine instance
- * @param symbol - The symbol name to query
- * @returns An object with lowerBound, upperBound, and strictness flags
- */
-export declare function getInequalityBoundsFromAssumptions(ce: ComputeEngine, symbol: string): {
-    lowerBound?: BoxedExpression;
-    lowerStrict?: boolean;
-    upperBound?: BoxedExpression;
-    upperStrict?: boolean;
-};
+import { getInequalityBoundsFromAssumptions } from './boxed-expression/inequality-bounds';
+export { getInequalityBoundsFromAssumptions };

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

@@ -1,21 +1,25 @@
-/* 0.35.6 */
-import type { Expression, MathJsonSymbol } from '../../math-json/types';
+/* 0.50.1 */
+import type { MathJsonExpression, MathJsonSymbol } from '../../math-json/types';
 import type { Type, TypeString } from '../../common/type/types';
 import { BoxedType } from '../../common/type/boxed-type';
-import type { BoxedSubstitution, Metadata, Substitution, CanonicalOptions, BoxedRuleSet, Rule, BoxedBaseDefinition, BoxedValueDefinition, BoxedOperatorDefinition, EvaluateOptions, Sign, BoxedExpression, JsonSerializationOptions, PatternMatchOptions, SimplifyOptions, ComputeEngine, Scope, Tensor } from '../global-types';
+import type { BoxedSubstitution, Metadata, Substitution, CanonicalOptions, BoxedRuleSet, Rule, BoxedBaseDefinition, BoxedValueDefinition, BoxedOperatorDefinition, EvaluateOptions, Sign, Expression, JsonSerializationOptions, PatternMatchOptions, SimplifyOptions, IComputeEngine as ComputeEngine, Scope, Tensor, TensorDataType } from '../global-types';
 import type { NumericValue } from '../numeric-value/types';
 import type { SmallInteger } from '../numerics/types';
 import type { LatexString, SerializeLatexOptions } from '../latex-syntax/types';
+import type { serializeJson as _SerializeJsonFn } from './serialize';
+/** @internal */
+export declare function _setSerializeJson(fn: typeof _SerializeJsonFn): void;
 /**
  * _BoxedExpression
  *
  * @internal
  */
-export declare abstract class _BoxedExpression implements BoxedExpression {
+export declare abstract class _BoxedExpression implements Expression {
+    readonly _kind: string;
     abstract readonly hash: number;
-    abstract readonly json: Expression;
+    abstract readonly json: MathJsonExpression;
     abstract isCanonical: boolean;
-    abstract match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
+    abstract match(pattern: Expression, options?: PatternMatchOptions): BoxedSubstitution | null;
     readonly engine: ComputeEngine;
     /** Verbatim LaTeX, obtained from a source, i.e. from parsing,
      *  not generated synthetically
@@ -40,18 +44,18 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
      * Note: this is a standard method of JavaScript objects.
      *
      */
-    toJSON(): Expression;
-    toMathJson(options?: Readonly<Partial<JsonSerializationOptions>>): Expression;
+    toJSON(): MathJsonExpression;
+    toMathJson(options?: Readonly<Partial<JsonSerializationOptions>>): MathJsonExpression;
     print(): void;
     get isStructural(): boolean;
-    get canonical(): BoxedExpression;
-    get structural(): BoxedExpression;
+    get canonical(): Expression;
+    get structural(): Expression;
     get isValid(): boolean;
     get isPure(): boolean;
     get isConstant(): boolean;
     get isNumberLiteral(): boolean;
-    get numericValue(): number | NumericValue | null;
-    toNumericValue(): [NumericValue, BoxedExpression];
+    get numericValue(): number | NumericValue | undefined;
+    toNumericValue(): [NumericValue, Expression];
     get isEven(): boolean | undefined;
     get isOdd(): boolean | undefined;
     get re(): number;
@@ -63,44 +67,44 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     get isNonNegative(): boolean | undefined;
     get isNegative(): boolean | undefined;
     get isNonPositive(): boolean | undefined;
-    neg(): BoxedExpression;
-    inv(): BoxedExpression;
-    abs(): BoxedExpression;
-    add(rhs: number | BoxedExpression): BoxedExpression;
-    sub(rhs: BoxedExpression): BoxedExpression;
-    mul(rhs: NumericValue | number | BoxedExpression): BoxedExpression;
-    div(rhs: number | BoxedExpression): BoxedExpression;
-    pow(exp: number | BoxedExpression): BoxedExpression;
-    root(exp: number | BoxedExpression): BoxedExpression;
-    sqrt(): BoxedExpression;
-    ln(base?: number | BoxedExpression): BoxedExpression;
-    get numerator(): BoxedExpression;
-    get denominator(): BoxedExpression;
-    get numeratorDenominator(): [BoxedExpression, BoxedExpression];
-    is(other: BoxedExpression | number | bigint | boolean | string): boolean;
-    isSame(other: BoxedExpression): boolean;
-    isEqual(other: number | BoxedExpression): boolean | undefined;
-    isLess(other: number | BoxedExpression): boolean | undefined;
-    isLessEqual(other: number | BoxedExpression): boolean | undefined;
-    isGreater(other: number | BoxedExpression): boolean | undefined;
-    isGreaterEqual(other: number | BoxedExpression): boolean | undefined;
-    get symbol(): string | null;
-    get tensor(): null | Tensor<any>;
-    get string(): string | null;
-    getSubexpressions(operator: MathJsonSymbol): ReadonlyArray<BoxedExpression>;
-    get subexpressions(): ReadonlyArray<BoxedExpression>;
+    neg(): Expression;
+    inv(): Expression;
+    abs(): Expression;
+    add(_rhs: number | Expression): Expression;
+    sub(rhs: Expression): Expression;
+    mul(_rhs: NumericValue | number | Expression): Expression;
+    div(_rhs: number | Expression): Expression;
+    pow(_exp: number | Expression): Expression;
+    root(_exp: number | Expression): Expression;
+    sqrt(): Expression;
+    ln(_base?: number | Expression): Expression;
+    get numerator(): Expression;
+    get denominator(): Expression;
+    get numeratorDenominator(): [Expression, Expression];
+    is(other: Expression | number | bigint | boolean | string): boolean;
+    isSame(other: Expression): boolean;
+    isEqual(other: number | Expression): boolean | undefined;
+    isLess(other: number | Expression): boolean | undefined;
+    isLessEqual(other: number | Expression): boolean | undefined;
+    isGreater(other: number | Expression): boolean | undefined;
+    isGreaterEqual(other: number | Expression): boolean | undefined;
+    get symbol(): string | undefined;
+    get tensor(): Tensor<TensorDataType> | undefined;
+    get string(): string | undefined;
+    getSubexpressions(operator: MathJsonSymbol): ReadonlyArray<Expression>;
+    get subexpressions(): ReadonlyArray<Expression>;
     get symbols(): ReadonlyArray<string>;
     get unknowns(): ReadonlyArray<string>;
-    get errors(): ReadonlyArray<BoxedExpression>;
+    get errors(): ReadonlyArray<Expression>;
     get isFunctionExpression(): boolean;
-    get ops(): null | ReadonlyArray<BoxedExpression>;
+    get ops(): ReadonlyArray<Expression> | undefined;
     get isScoped(): boolean;
     get localScope(): Scope | undefined;
     abstract readonly operator: string;
     get nops(): SmallInteger;
-    get op1(): BoxedExpression;
-    get op2(): BoxedExpression;
-    get op3(): BoxedExpression;
+    get op1(): Expression;
+    get op2(): Expression;
+    get op3(): Expression;
     get isNaN(): boolean | undefined;
     get isInfinity(): boolean | undefined;
     get isFinite(): boolean | undefined;
@@ -108,13 +112,13 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     get rank(): number;
     subs(_sub: Substitution, options?: {
         canonical?: CanonicalOptions;
-    }): BoxedExpression;
-    map(fn: (x: BoxedExpression) => BoxedExpression, options?: {
+    }): Expression;
+    map(fn: (x: Expression) => Expression, options?: {
         canonical: CanonicalOptions;
         recursive?: boolean;
-    }): BoxedExpression;
-    solve(_vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression> | Record<string, BoxedExpression> | Array<Record<string, BoxedExpression>>;
-    replace(_rules: BoxedRuleSet | Rule | Rule[]): null | BoxedExpression;
+    }): Expression;
+    solve(_vars?: Iterable<string> | string | Expression | Iterable<Expression>): null | ReadonlyArray<Expression> | Record<string, Expression> | Array<Record<string, Expression>>;
+    replace(_rules: BoxedRuleSet | Rule | Rule[]): null | Expression;
     has(_v: string | string[]): boolean;
     get description(): string[] | undefined;
     get url(): string | undefined;
@@ -123,46 +127,32 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     get baseDefinition(): BoxedBaseDefinition | undefined;
     get valueDefinition(): BoxedValueDefinition | undefined;
     get operatorDefinition(): BoxedOperatorDefinition | undefined;
-    infer(t: Type, inferenceMode?: 'narrow' | 'widen'): boolean;
+    infer(_t: Type, _inferenceMode?: 'narrow' | 'widen'): boolean;
     bind(): void;
     reset(): void;
-    get value(): BoxedExpression | undefined;
-    set value(_value: any);
+    get value(): Expression | undefined;
+    set value(_value: unknown);
     get type(): BoxedType;
     set type(_type: Type | TypeString | BoxedType);
     get isNumber(): boolean | undefined;
     get isInteger(): boolean | undefined;
     get isRational(): boolean | undefined;
     get isReal(): boolean | undefined;
-    simplify(_options?: Partial<SimplifyOptions>): BoxedExpression;
-    trigSimplify(): BoxedExpression;
-    expand(): BoxedExpression;
-    evaluate(_options?: Partial<EvaluateOptions>): BoxedExpression;
-    evaluateAsync(_options?: Partial<EvaluateOptions>): Promise<BoxedExpression>;
-    N(): BoxedExpression;
-    compile(options?: {
-        to?: string;
-        target?: any;
-        operators?: Partial<Record<MathJsonSymbol, [op: string, prec: number]>> | ((op: MathJsonSymbol) => [op: string, prec: number] | undefined);
-        functions?: Record<MathJsonSymbol, string | ((...any: any[]) => any)>;
-        vars?: Record<MathJsonSymbol, string>;
-        imports?: ((...any: any[]) => any)[];
-        preamble?: string;
-        fallback?: boolean;
-    }): ((...args: any[]) => any) & {
-        isCompiled?: boolean;
-    };
+    simplify(_options?: Partial<SimplifyOptions>): Expression;
+    evaluate(_options?: Partial<EvaluateOptions>): Expression;
+    evaluateAsync(_options?: Partial<EvaluateOptions>): Promise<Expression>;
+    N(): Expression;
     get isCollection(): boolean;
     get isIndexedCollection(): boolean;
     get isLazyCollection(): boolean;
-    contains(_rhs: BoxedExpression): boolean | undefined;
-    subsetOf(_target: BoxedExpression, _strict: boolean): boolean | undefined;
+    contains(_rhs: Expression): boolean | undefined;
+    subsetOf(_target: Expression, _strict: boolean): boolean | undefined;
     get count(): number | undefined;
     get isEmptyCollection(): boolean | undefined;
     get isFiniteCollection(): boolean | undefined;
-    each(): Generator<BoxedExpression>;
-    at(_index: number): BoxedExpression | undefined;
-    get(_key: string | BoxedExpression): BoxedExpression | undefined;
-    indexWhere(_predicate: (element: BoxedExpression) => boolean): number | undefined;
+    each(): Generator<Expression>;
+    at(_index: number): Expression | undefined;
+    get(_key: string | Expression): Expression | undefined;
+    indexWhere(_predicate: (element: Expression) => boolean): number | undefined;
 }
-export declare function getSubexpressions(expr: BoxedExpression, name: MathJsonSymbol): ReadonlyArray<BoxedExpression>;
+export declare function getSubexpressions(expr: Expression, name: MathJsonSymbol): ReadonlyArray<Expression>;

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

@@ -1,5 +1,5 @@
-/* 0.35.6 */
+/* 0.50.1 */
 import { Decimal } from 'decimal.js';
-import type { BoxedExpression } from '../global-types';
-export declare function apply(expr: BoxedExpression, fn: (x: number) => number | Complex, bigFn?: (x: Decimal) => Decimal | Complex | number, complexFn?: (x: Complex) => number | Complex): BoxedExpression | undefined;
-export declare function apply2(expr1: BoxedExpression, expr2: BoxedExpression, fn: (x1: number, x2: number) => number | Complex, bigFn?: (x1: Decimal, x2: Decimal) => Decimal | Complex | number, complexFn?: (x1: Complex, x2: number | Complex) => Complex | number): BoxedExpression | undefined;
+import type { Expression } from '../global-types';
+export declare function apply(expr: Expression, fn: (x: number) => number | Complex, bigFn?: (x: Decimal) => Decimal | Complex | number, complexFn?: (x: Complex) => number | Complex): Expression | undefined;
+export declare function apply2(expr1: Expression, expr2: Expression, fn: (x1: number, x2: number) => number | Complex, bigFn?: (x1: Decimal, x2: Decimal) => Decimal | Complex | number, complexFn?: (x1: Complex, x2: number | Complex) => Complex | number): Expression | undefined;

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

@@ -1,6 +1,6 @@
-/* 0.35.6 */
+/* 0.50.1 */
 import { BoxedType } from '../../common/type/boxed-type';
-import type { BoxedExpression, ComputeEngine } from '../global-types';
+import type { Expression, IComputeEngine as ComputeEngine } from '../global-types';
 /**
  *
  * The canonical form of `Add`:
@@ -10,7 +10,16 @@ import type { BoxedExpression, ComputeEngine } from '../global-types';
  * - sort the terms
  *
  */
-export declare function canonicalAdd(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression;
-export declare function addType(args: ReadonlyArray<BoxedExpression>): Type | BoxedType;
-export declare function add(...xs: ReadonlyArray<BoxedExpression>): BoxedExpression;
-export declare function addN(...xs: ReadonlyArray<BoxedExpression>): BoxedExpression;
+export declare function canonicalAdd(ce: ComputeEngine, ops: ReadonlyArray<Expression>): Expression;
+export declare function addType(args: ReadonlyArray<Expression>): Type | BoxedType;
+export declare function add(...xs: ReadonlyArray<Expression>): Expression;
+export declare function addN(...xs: ReadonlyArray<Expression>): Expression;
+export declare class Terms {
+    private engine;
+    private terms;
+    constructor(ce: ComputeEngine, terms: ReadonlyArray<Expression>);
+    private _add;
+    private find;
+    N(): Expression;
+    asExpression(): Expression;
+}

package/dist/types/compute-engine/boxed-expression/arithmetic-mul-div.d.ts

@@ -1,4 +1,69 @@
-/* 0.35.6 */
+/* 0.50.1 */
+import { NumericValue } from '../numeric-value/types';
+import type { Rational } from '../numerics/types';
+/**
+ * Group terms in a product by common term.
+ *
+ * All the terms should be canonical.
+ * - the arguments should have been flattened for `Multiply`
+ *
+ * - any argument of power been distributed, i.e.
+ *      (ab)^2 ->  a^2 b^2
+ * *
+ * 3 + √5 + √(x+1) + x^2 + (a+b)^2 + d
+ *  -> [ [[3, "d"], [1, 1]],
+ *       [[5, "x+1"], [1, 2]],
+ *       [[1, "a+b"], [2, 1]]
+ *      ]
+ *
+ */
+export declare class Product {
+    readonly options?: {
+        canonical?: boolean;
+    };
+    engine: ComputeEngine;
+    coefficient: NumericValue;
+    terms: {
+        term: Expression;
+        exponent: Rational;
+    }[];
+    private _isCanonical;
+    static from(expr: Expression): Product;
+    constructor(ce: ComputeEngine, xs?: ReadonlyArray<Expression>, options?: {
+        canonical?: boolean;
+    });
+    /**
+     * Add a term to the product.
+     *
+     * If `this._isCanonical` a running product of exact terms is kept.
+     * Otherwise, terms and their exponent are tallied.
+     */
+    mul(term: Expression, exp?: Rational): void;
+    /** Divide the product by a term of coefficient */
+    div(term: NumericValue | Expression): void;
+    /** The terms of the product, grouped by degrees.
+     *
+     * If `mode` is `rational`, rationals are split into separate numerator and
+     * denominator, so that a rational expression can be created later
+     * If `mode` is `expression`, a boxed expression is returned, without
+     * splitting rationals
+     * If `mode` is `numeric`, the literals are combined into one expression
+     *
+     */
+    groupedByDegrees(options?: {
+        mode?: 'rational' | 'expression' | 'numeric';
+    }): {
+        exponent: Rational;
+        terms: Expression[];
+    }[] | null;
+    asExpression(options?: {
+        numericApproximation: boolean;
+    }): Expression;
+    /** The product, expressed as a numerator and denominator */
+    asNumeratorDenominator(): [Expression, Expression];
+    asRationalExpression(): Expression;
+}
+export declare function commonTerms(lhs: Product, rhs: Product): [NumericValue, Expression];
 /**
  * Canonical form of 'Divide' (and 'Rational')
  * - remove denominator of 1
@@ -8,8 +73,8 @@
  *   or Rational expression
  * - evaluate number literals
  */
-export declare function canonicalDivide(op1: BoxedExpression, op2: BoxedExpression): BoxedExpression;
-export declare function div(num: BoxedExpression, denom: number | BoxedExpression): BoxedExpression;
+export declare function canonicalDivide(op1: Expression, op2: Expression): Expression;
+export declare function div(num: Expression, denom: number | Expression): Expression;
 /**
  * The canonical form of `Multiply`:
  * - removes `1` and `-1`
@@ -22,6 +87,7 @@ export declare function div(num: BoxedExpression, denom: number | BoxedExpressio
  *
  * The input ops may not be canonical, the result is canonical.
  */
-export declare function canonicalMultiply(ce: ComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression;
-export declare function mul(...xs: ReadonlyArray<BoxedExpression>): BoxedExpression;
-export declare function mulN(...xs: ReadonlyArray<BoxedExpression>): BoxedExpression;
+export declare function canonicalMultiply(ce: ComputeEngine, ops: ReadonlyArray<Expression>): Expression;
+export declare function expandProducts(ce: ComputeEngine, ops: ReadonlyArray<Expression>): Expression | null;
+export declare function mul(...xs: ReadonlyArray<Expression>): Expression;
+export declare function mulN(...xs: ReadonlyArray<Expression>): Expression;