@cortex-js/compute-engine 0.29.0 → 0.30.0

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

@@ -1,4 +1,4 @@
-/* 0.29.0 */
+/* 0.30.0 */
  * A primitive type is a simple type that represents a concrete value.
  *
  * - `any`: the top type
@@ -12,7 +12,7 @@
  *    - a symbolic expression, such as `["Add", "x", 1]`
  *    - `<value>`
  *    - `symbol`: a symbol, such as `x`.
- *    - `function`: a function expression
+ *    - `function`: a function literal
  *      such as `["Function", ["Add", "x", 1], "x"]`.
  *
  * - `value`
@@ -21,19 +21,24 @@
  *      - `boolean`: a boolean value: `True` or `False`.
  *      - `string`: a string of characters.
  *    - `collection`
- *       - `list`: a collection of expressions, possibly recursive,
- *          with optional dimensions, e.g. `[number]`, `[boolean^32]`,
- *          `[number^(2x3)]`. Used to represent a vector, a matrix or a
- *          tensor when the type of its elements is a number
  *       - `set`: a collection of unique expressions, e.g. `set<string>`.
- *       - `tuple`: a fixed-size collection of named or unnamed elements, e.g.
- *          `tuple<number, boolean>`, `tuple<x: number, y: boolean>`.
- *       - `map`: a set key-value pairs, e.g. `map<x: number, y: boolean>`.
+ *       - `record`: a collection of specific key-value pairs,
+ *          e.g. `record<x: number, y: boolean>`.
+ *       - `dictionary`: a collection of arbitrary key-value pairs
+ *          e.g. `dictionary<string, number>`.
+ *       - `indexed_collection`: collections whose elements can be accessed
+ *             by a numeric index
+ *          - `list`: a collection of expressions, possibly recursive,
+ *              with optional dimensions, e.g. `[number]`, `[boolean^32]`,
+ *              `[number^(2x3)]`. Used to represent a vector, a matrix or a
+ *              tensor when the type of its elements is a number
+ *           - `tuple`: a fixed-size collection of named or unnamed elements,
+ *              e.g. `tuple<number, boolean>`, `tuple<x: number, y: boolean>`.
  *
  *
  *
  */
-export type PrimitiveType = NumericType | 'collection' | 'list' | 'set' | 'map' | 'tuple' | 'value' | 'scalar' | 'function' | 'symbol' | 'boolean' | 'string' | 'expression' | 'unknown' | 'error' | 'nothing' | 'never' | 'any';
+export type PrimitiveType = NumericPrimitiveType | 'collection' | 'indexed_collection' | 'list' | 'set' | 'dictionary' | 'record' | 'dictionary' | 'tuple' | 'value' | 'scalar' | 'function' | 'symbol' | 'boolean' | 'string' | 'expression' | 'unknown' | 'error' | 'nothing' | 'never' | 'any';
 /**
  * - `number`: any numeric value = `complex` + `real` plus `NaN`
  * - `complex`: a number with non-zero real and imaginary parts = `finite_complex` plus `ComplexInfinity`
@@ -49,7 +54,7 @@ export type PrimitiveType = NumericType | 'collection' | 'list' | 'set' | 'map'
  * - `rational`: a pure rational number (not an integer) = `finite_rational` + `non_finite_number`
  *
  */
-export type NumericType = 'number' | 'finite_number' | 'complex' | 'finite_complex' | 'imaginary' | 'real' | 'finite_real' | 'rational' | 'finite_rational' | 'integer' | 'finite_integer' | 'non_finite_number';
+export type NumericPrimitiveType = 'number' | 'finite_number' | 'complex' | 'finite_complex' | 'imaginary' | 'real' | 'finite_real' | 'rational' | 'finite_rational' | 'integer' | 'finite_integer' | 'non_finite_number';
 export type NamedElement = {
     name?: string;
     type: Type;
@@ -58,7 +63,8 @@ export type FunctionSignature = {
     kind: 'signature';
     args?: NamedElement[];
     optArgs?: NamedElement[];
-    restArg?: NamedElement;
+    variadicArg?: NamedElement;
+    variadicMin?: 0 | 1;
     result: Type;
 };
 export type AlgebraicType = {
@@ -73,24 +79,42 @@ export type ValueType = {
     kind: 'value';
     value: any;
 };
-/** Map is a non-indexable collection of key/value pairs.
- * An element of a map whose type is a subtype of `nothing` is optional.
- * For example, in `{x: number, y: boolean | nothing}` the element `y` is optional.
+/** A record is a collection of key-value pairs.
+ *
+ * The keys are strings. The set of keys is fixed.
+ *
+ * For a record type to be a subtype of another record type, it must have a
+ * subset of the keys, and all their types must match (width subtyping).
+ *
  */
-export type MapType = {
-    kind: 'map';
+export type RecordType = {
+    kind: 'record';
     elements: Record<string, Type>;
 };
-/** Collection, List, Set, Tuple and Map are collections.
+/** A dictionary is a collection of key-value pairs.
  *
+ * The keys are strings. The set of keys is also not defined as part of the
+ * type and can be modified at runtime.
+ *
+ * A dictionary is suitable for use as cache or data storage.
+ */
+export type DictionaryType = {
+    kind: 'dictionary';
+    values: Type;
+};
+/**
  * `CollectionType` is a generic collection of elements of a certain type.
+ *
+ * - Indexed collections: List, Tuple
+ * - Non-indexed: Set, Record, Dictionary
+ *
  */
 export type CollectionType = {
-    kind: 'collection';
+    kind: 'collection' | 'indexed_collection';
     elements: Type;
 };
 /**
- * The elements of a list are ordered.
+ * The elements of a list can be accessed by their one-based index.
  *
  * All elements of a list have the same type, but it can be a broad type,
  * up to `any`.
@@ -106,13 +130,30 @@ export type ListType = {
     elements: Type;
     dimensions?: number[];
 };
+export type SymbolType = {
+    kind: 'symbol';
+    name: string;
+};
+export type ExpressionType = {
+    kind: 'expression';
+    operator: string;
+};
+export type NumericType = {
+    kind: 'numeric';
+    type: NumericPrimitiveType;
+    lower?: number;
+    upper?: number;
+};
 /** Each element of a set is unique (is not present in the set more than once).
- * The elements of a set are not ordered.
+ * The elements of a set are not indexed.
  */
 export type SetType = {
     kind: 'set';
     elements: Type;
 };
+/** The elements of a tuple are indexed and may be named or unnamed.
+ * If one element is named, all elements must be named.
+ */
 export type TupleType = {
     kind: 'tuple';
     elements: NamedElement[];
@@ -120,9 +161,11 @@ export type TupleType = {
 /** Nominal typing */
 export type TypeReference = {
     kind: 'reference';
-    ref: string;
+    name: string;
+    alias: boolean;
+    def: Type | undefined;
 };
-export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType | ListType | SetType | MapType | TupleType | FunctionSignature | ValueType | TypeReference;
+export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType | ListType | SetType | RecordType | DictionaryType | TupleType | SymbolType | ExpressionType | NumericType | NumericPrimitiveType | FunctionSignature | ValueType | TypeReference;
 /**
  * The type of a boxed expression indicates the kind of expression it is and
  * the value it represents.
@@ -222,7 +265,7 @@ export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType
  * - `"number -> number"` -- a signature with a single argument
  * - `"(x: number, number) -> number"` -- a signature with a named argument
  * - `"(number, y:number?) -> number"` -- a signature with an optional named argument (can have several optional arguments, at the end)
- * - `"(number, ...number) -> number"` -- a signature with a rest argument (can have only one, and no optional arguments if there is a rest argument).
+ * - `"(number, number+) -> number"` -- a signature with a rest argument (can have only one, and no optional arguments if there is a rest argument).
  * - `"() -> number"` -- a signature with an empty argument list
  * - `"number | boolean"` -- a union type
  * - `"(x: number) & (y: number)"` -- an intersection type
@@ -231,4 +274,27 @@ export type Type = PrimitiveType | AlgebraicType | NegationType | CollectionType
  */
 export type TypeString = string;
 export type TypeCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';
-export type TypeResolver = (name: string) => Type | undefined;
+/** A type resolver should return a definition for a given type name.
+ */
+export type TypeResolver = {
+    /** Return a list of all type names that are defined in the resolver. This is
+     * used to display error messages when a type is not found. */
+    get names(): string[];
+    forward: (name: string) => TypeReference | undefined;
+    resolve: (name: string) => TypeReference | undefined;
+};
+/**
+ * ### Future considerations:
+ * - Add support for generics (e.g. `list<T>`), i.e. parametric polymorphism,
+ * - Add support for type constraints (e.g. `list<T: number>` or list<T> where T: number),
+ * - Add support for type variants (e.g. a la Rust enums)
+ *     Maybe something like
+ *      `variant<Square, Circle>` or
+ *      `variant<Square(side: integer), Circle(radius: integer)>`
+ *      `variant<Square: {side: integer}, Circle: {radius: integer}>`
+ * - Add support for dependent types, with type-level computations
+ * - Add support for integers, booleans, symbols and strings, i.e. "T = "red" | "green" | "blue""
+ * - Add support for conditional types (e.g. `T extends U ? X : Y`)
+ *
+ *
+ */

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

@@ -1,4 +1,4 @@
-/* 0.29.0 */
+/* 0.30.0 */
 /** 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.
@@ -32,4 +32,5 @@ export declare function isSignatureType(type: Readonly<Type> | TypeString): type
 export declare function functionSignature(type: Readonly<Type>): Type | undefined;
 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,2 +1,2 @@
-/* 0.29.0 */
+/* 0.30.0 */
 export declare function hidePrivateProperties(obj: any): void;

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

@@ -1,4 +1,4 @@
-/* 0.29.0 */
+/* 0.30.0 */
 /**
  * Add an assumption, in the form of a predicate, for example:
  *
@@ -7,7 +7,7 @@
  * - `x > 3`
  * - `x + y = 5`
  *
- * Assumptions that represent a symbol definition (equality to an expression,
+ * Assumptions that represent a value definition (equality to an expression,
  * membership to a type, >0, <=0, etc...) are stored directly in the current
  * scope's symbols dictionary, and an entry for the symbol is created if
  * necessary.

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

@@ -1,36 +1,27 @@
-/* 0.29.0 */
-import { Expression, MathJsonIdentifier } from '../../math-json/types';
+/* 0.30.0 */
+import type { Expression, MathJsonSymbol } from '../../math-json/types';
 import type { Type, TypeString } from '../../common/type/types';
 import { BoxedType } from '../../common/type/boxed-type';
-import type { BoxedSubstitution, Metadata, RuntimeScope, Substitution, CanonicalOptions, BoxedRuleSet, Rule, BoxedBaseDefinition, BoxedSymbolDefinition, BoxedFunctionDefinition, EvaluateOptions, CompiledType, Sign, BoxedExpression, JsonSerializationOptions, PatternMatchOptions, SimplifyOptions, TensorData, ComputeEngine } from '../global-types';
+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 { NumericValue } from '../numeric-value/types';
 import type { SmallInteger } from '../numerics/types';
 import type { LatexString, SerializeLatexOptions } from '../latex-syntax/types';
-import { AsciiMathOptions } from './ascii-math';
 /**
  * _BoxedExpression
+ *
+ * @internal
  */
 export declare abstract class _BoxedExpression implements BoxedExpression {
     abstract readonly hash: number;
     abstract readonly json: Expression;
-    abstract readonly operator: string;
-    /** @deprecated */
-    get head(): string;
-    abstract get isCanonical(): boolean;
-    abstract set isCanonical(_val: boolean);
+    abstract isCanonical: boolean;
     abstract match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;
     readonly engine: ComputeEngine;
     /** Verbatim LaTeX, obtained from a source, i.e. from parsing,
      *  not generated synthetically
      */
-    verbatimLatex?: string;
+    readonly verbatimLatex?: string;
     constructor(ce: ComputeEngine, metadata?: Metadata);
-    isSame(rhs: BoxedExpression): boolean;
-    isEqual(rhs: number | BoxedExpression): boolean | undefined;
-    isLess(_rhs: number | BoxedExpression): boolean | undefined;
-    isLessEqual(_rhs: number | BoxedExpression): boolean | undefined;
-    isGreater(_rhs: number | BoxedExpression): boolean | undefined;
-    isGreaterEqual(_rhs: number | BoxedExpression): boolean | undefined;
     /**
      *
      * `Object.valueOf()`: return a JavaScript primitive value for the expression
@@ -38,12 +29,12 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
      * Primitive values are: boolean, number, bigint, string, null, undefined
      *
      */
-    valueOf(): number | object | string | boolean;
-    toAsciiMath(options?: Partial<AsciiMathOptions>): string;
+    valueOf(): number | number[] | number[][] | number[][][] | string | boolean;
+    [Symbol.toPrimitive](hint: 'number' | 'string' | 'default'): number | string | null;
     /** Object.toString() */
     toString(): string;
-    print(): void;
-    [Symbol.toPrimitive](hint: 'number' | 'string' | 'default'): number | string | null;
+    toLatex(options?: Partial<SerializeLatexOptions>): LatexString;
+    get latex(): LatexString;
     /** Called by `JSON.stringify()` when serializing to json.
      *
      * Note: this is a standard method of JavaScript objects.
@@ -51,51 +42,27 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
      */
     toJSON(): Expression;
     toMathJson(options?: Readonly<Partial<JsonSerializationOptions>>): Expression;
-    toLatex(options?: Partial<SerializeLatexOptions>): LatexString;
-    toNumericValue(): [NumericValue, BoxedExpression];
-    get scope(): RuntimeScope | null;
-    is(rhs: any): boolean;
+    print(): void;
+    get isStructural(): boolean;
     get canonical(): BoxedExpression;
     get structural(): BoxedExpression;
-    get isStructural(): boolean;
-    get latex(): LatexString;
-    set latex(val: LatexString);
-    get symbol(): string | null;
-    get tensor(): null | TensorData<'expression'>;
-    get string(): string | null;
-    getSubexpressions(operator: MathJsonIdentifier): 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(): SmallInteger;
-    get op1(): BoxedExpression;
-    get op2(): BoxedExpression;
-    get op3(): BoxedExpression;
     get isValid(): boolean;
     get isPure(): boolean;
-    /** Literals (number, string, boolean) are constants. Some symbols
-     * may also be constants (e.g. Pi, E, True, False). Expressions of constant
-     * symbols are also constants (if the function is pure).
-     */
     get isConstant(): boolean;
-    get isNaN(): boolean | undefined;
-    get isInfinity(): boolean | undefined;
-    get isFinite(): boolean | undefined;
+    get isNumberLiteral(): boolean;
+    get numericValue(): number | NumericValue | null;
+    toNumericValue(): [NumericValue, BoxedExpression];
     get isEven(): boolean | undefined;
     get isOdd(): boolean | undefined;
-    get numericValue(): number | NumericValue | null;
-    get isNumberLiteral(): boolean;
-    get isFunctionExpression(): boolean;
     get re(): number;
     get im(): number;
     get bignumRe(): Decimal | undefined;
     get bignumIm(): Decimal | undefined;
-    get numerator(): BoxedExpression;
-    get denominator(): BoxedExpression;
-    get numeratorDenominator(): [BoxedExpression, BoxedExpression];
+    get sgn(): Sign | undefined;
+    get isPositive(): boolean | undefined;
+    get isNonNegative(): boolean | undefined;
+    get isNegative(): boolean | undefined;
+    get isNonPositive(): boolean | undefined;
     neg(): BoxedExpression;
     inv(): BoxedExpression;
     abs(): BoxedExpression;
@@ -107,7 +74,36 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     root(exp: number | BoxedExpression): BoxedExpression;
     sqrt(): BoxedExpression;
     ln(base?: number | BoxedExpression): BoxedExpression;
-    get sgn(): Sign | undefined;
+    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>;
+    get symbols(): ReadonlyArray<string>;
+    get unknowns(): ReadonlyArray<string>;
+    get errors(): ReadonlyArray<BoxedExpression>;
+    get isFunctionExpression(): boolean;
+    get ops(): null | ReadonlyArray<BoxedExpression>;
+    get isScoped(): boolean;
+    get localScope(): Scope | undefined;
+    abstract readonly operator: string;
+    get nops(): SmallInteger;
+    get op1(): BoxedExpression;
+    get op2(): BoxedExpression;
+    get op3(): BoxedExpression;
+    get isNaN(): boolean | undefined;
+    get isInfinity(): boolean | undefined;
+    get isFinite(): boolean | undefined;
     get shape(): number[];
     get rank(): number;
     subs(_sub: Substitution, options?: {
@@ -120,22 +116,18 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     solve(_vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
     replace(_rules: BoxedRuleSet | Rule | Rule[]): null | BoxedExpression;
     has(_v: string | string[]): boolean;
-    get isPositive(): boolean | undefined;
-    get isNonNegative(): boolean | undefined;
-    get isNegative(): boolean | undefined;
-    get isNonPositive(): boolean | undefined;
     get description(): string[] | undefined;
     get url(): string | undefined;
     get wikidata(): string | undefined;
     get complexity(): number | undefined;
     get baseDefinition(): BoxedBaseDefinition | undefined;
-    get symbolDefinition(): BoxedSymbolDefinition | undefined;
-    get functionDefinition(): BoxedFunctionDefinition | undefined;
-    infer(_t: Type): boolean;
+    get valueDefinition(): BoxedValueDefinition | undefined;
+    get operatorDefinition(): BoxedOperatorDefinition | undefined;
+    infer(t: Type, inferenceMode?: 'narrow' | 'widen'): boolean;
     bind(): void;
     reset(): void;
-    get value(): number | boolean | string | object | undefined;
-    set value(_value: BoxedExpression | number | boolean | string | number[] | undefined);
+    get value(): BoxedExpression | undefined;
+    set value(_value: any);
     get type(): BoxedType;
     set type(_type: Type | TypeString | BoxedType);
     get isNumber(): boolean | undefined;
@@ -149,18 +141,25 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     N(): BoxedExpression;
     compile(options?: {
         to?: 'javascript';
-        functions?: Record<MathJsonIdentifier, string | ((...any: any[]) => any)>;
-        vars?: Record<MathJsonIdentifier, string>;
+        functions?: Record<MathJsonSymbol, string | ((...any: any[]) => any)>;
+        vars?: Record<MathJsonSymbol, string>;
         imports?: ((...any: any[]) => any)[];
         preamble?: string;
-    }): (args: Record<string, any>) => CompiledType;
+        fallback?: boolean;
+    }): ((...args: any[]) => any) & {
+        isCompiled?: boolean;
+    };
     get isCollection(): boolean;
-    contains(_rhs: BoxedExpression): boolean;
-    subsetOf(_target: BoxedExpression, _strict: boolean): boolean;
-    get size(): number;
-    each(_start?: number, _count?: number): Iterator<BoxedExpression, undefined>;
+    get isIndexedCollection(): boolean;
+    get isLazyCollection(): boolean;
+    xcontains(_rhs: BoxedExpression): boolean | undefined;
+    subsetOf(_target: BoxedExpression, _strict: boolean): boolean | undefined;
+    get xsize(): number | undefined;
+    get isEmptyCollection(): boolean | undefined;
+    get isFiniteCollection(): boolean | undefined;
+    each(): Generator<BoxedExpression>;
     at(_index: number): BoxedExpression | undefined;
     get(_key: string | BoxedExpression): BoxedExpression | undefined;
-    indexOf(_expr: BoxedExpression): number;
+    indexWhere(_predicate: (element: BoxedExpression) => boolean): number | undefined;
 }
-export declare function getSubexpressions(expr: BoxedExpression, name: MathJsonIdentifier): ReadonlyArray<BoxedExpression>;
+export declare function getSubexpressions(expr: BoxedExpression, name: MathJsonSymbol): ReadonlyArray<BoxedExpression>;

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

@@ -1,4 +1,4 @@
-/* 0.29.0 */
+/* 0.30.0 */
 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;

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

@@ -1,4 +1,4 @@
-/* 0.29.0 */
+/* 0.30.0 */
 import { BoxedType } from '../../common/type/boxed-type';
 import type { BoxedExpression, ComputeEngine } from '../global-types';
 /**

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

@@ -1,4 +1,4 @@
-/* 0.29.0 */
+/* 0.30.0 */
 /**
  * Canonical form of 'Divide' (and 'Rational')
  * - remove denominator of 1
@@ -12,7 +12,7 @@ export declare function canonicalDivide(op1: BoxedExpression, op2: BoxedExpressi
 export declare function div(num: BoxedExpression, denom: number | BoxedExpression): BoxedExpression;
 /**
  * The canonical form of `Multiply`:
- * - removes `1` anb `-1`
+ * - removes `1` and `-1`
  * - simplifies the signs:
  *    - i.e. `-y \times -x` -> `x \times y`
  *    - `2 \times -x` -> `-2 \times x`

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

@@ -1,6 +1,24 @@
-/* 0.29.0 */
+/* 0.30.0 */
 import type { Rational } from '../numerics/types';
 export declare function asRadical(expr: BoxedExpression): Rational | null;
+/**
+ *
+ * Produce the canonical form of the operands of a Power expression, returning either the operation
+ * result (e.g. 'a^1 -> a'), an alternate expr. representation ('a^{1/2} -> Sqrt(a)'), or an
+ * unchanged 'Power' expression. Operations include:
+ *
+ * - @todo
+ *
+ * Both the given base and exponent can either be canonical or non-canonical: with fully
+ * canonicalized args. lending to more simplifications.
+ *
+ * Returns a canonical expr. is both operands are canonical.
+ 
+ * @export
+ * @param a
+ * @param b
+ * @returns
+ */
 export declare function canonicalPower(a: BoxedExpression, b: BoxedExpression): BoxedExpression;
 export declare function canonicalRoot(a: BoxedExpression, b: BoxedExpression | number): BoxedExpression;
 /**

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

@@ -1,4 +1,4 @@
-/* 0.29.0 */
+/* 0.30.0 */
 export type AsciiMathSerializer = (expr: BoxedExpression, precedence?: number) => string;
 export type AsciiMathOptions = {
     symbols: Record<string, string>;

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

@@ -1,7 +1,5 @@
-/* 0.29.0 */
-import { Decimal } from 'decimal.js';
-import type { SemiBoxedExpression, BoxedExpression, CanonicalOptions, ComputeEngine, Metadata } from '../global-types';
-import { MathJsonIdentifier } from '../../math-json/types';
+/* 0.30.0 */
+import { MathJsonSymbol } from '../../math-json/types';
 import { NumericValue } from '../numeric-value/types';
 /**
  * Given a name and a set of arguments, return a boxed function expression.
@@ -10,10 +8,11 @@ import { NumericValue } from '../numeric-value/types';
  *
  * Note that `boxFunction()` should only be called from `ce.function()`
  */
-export declare function boxFunction(ce: ComputeEngine, name: MathJsonIdentifier, ops: readonly SemiBoxedExpression[], options?: {
+export declare function boxFunction(ce: ComputeEngine, name: MathJsonSymbol, ops: readonly SemiBoxedExpression[], options?: {
     metadata?: Metadata;
     canonical?: CanonicalOptions;
     structural?: boolean;
+    scope?: Scope;
 }): BoxedExpression;
 /**
  * Notes about the boxed form:
@@ -43,5 +42,6 @@ export declare function boxFunction(ce: ComputeEngine, name: MathJsonIdentifier,
 export declare function box(ce: ComputeEngine, expr: null | undefined | NumericValue | SemiBoxedExpression, options?: {
     canonical?: CanonicalOptions;
     structural?: boolean;
+    scope?: Scope;
 }): BoxedExpression;
-export declare function toBigint(x: Complex | Decimal | SemiBoxedExpression): bigint | null;
+export declare function semiCanonical(ce: ComputeEngine, xs: ReadonlyArray<SemiBoxedExpression>, scope?: Scope): ReadonlyArray<BoxedExpression>;

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

@@ -0,0 +1,42 @@
+/* 0.30.0 */
+import { _BoxedExpression } from './abstract-boxed-expression';
+import { BoxedType } from '../../common/type/boxed-type';
+import { Expression } from '../../math-json/types';
+/**
+ * BoxedDictionary
+ *
+ */
+export declare class BoxedDictionary extends _BoxedExpression implements DictionaryInterface {
+    [Symbol.toStringTag]: string;
+    private readonly _keyValues;
+    private _type;
+    constructor(ce: ComputeEngine, keyValues: Record<string, SemiBoxedExpression> | BoxedExpression, options?: {
+        metadata?: Metadata;
+        canonical?: boolean;
+    });
+    private _initFromRecord;
+    private _initFromExpression;
+    get json(): Expression;
+    get hash(): number;
+    get operator(): string;
+    get type(): BoxedType;
+    get isPure(): boolean;
+    get isCanonical(): boolean;
+    set isCanonical(_va: boolean);
+    get value(): BoxedExpression | undefined;
+    get complexity(): number;
+    get isCollection(): boolean;
+    get isIndexedCollection(): boolean;
+    get isLazyCollection(): boolean;
+    xcontains(_rhs: BoxedExpression): boolean | undefined;
+    get xsize(): number | undefined;
+    get isEmptyCollection(): boolean;
+    get isFiniteCollection(): boolean;
+    each(): Generator<BoxedExpression>;
+    get(key: string): BoxedExpression | undefined;
+    has(key: string): boolean;
+    get keys(): string[];
+    get entries(): [string, BoxedExpression][];
+    get values(): BoxedExpression[];
+    match(pattern: BoxedExpression, _options?: PatternMatchOptions): BoxedSubstitution | null;
+}