@cortex-js/compute-engine 0.27.0 → 0.28.0

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.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.
@@ -27,13 +27,9 @@ export declare function narrow(...types: Readonly<Type>[]): Type;
  * widen('number', 'expression') => 'expression'
  * widen('number', 'string') => 'any'
  */
-export declare function widen(...types: Readonly<Type>[]): Type;
+export declare function widen(...types: Readonly<Type>[]): Readonly<Type>;
 export declare function isSignatureType(type: Readonly<Type> | TypeString): type is FunctionSignature;
 export declare function functionSignature(type: Readonly<Type>): Type | undefined;
-export declare function functionResult(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 isValidType(t: any): t is Readonly<Type>;
-/**
- * Add a `toString()` method to the type object
- */
-export declare function makeType(type: Type): Readonly<Type>;

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

@@ -1,2 +1,2 @@
-/* 0.27.0 */
+/* 0.28.0 */
 export declare function hidePrivateProperties(obj: any): void;

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

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

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

@@ -1,9 +1,10 @@
-/* 0.27.0 */
+/* 0.28.0 */
 import { Expression, MathJsonIdentifier } from '../../math-json/types';
 import type { BoxedBaseDefinition, BoxedExpression, BoxedFunctionDefinition, BoxedRuleSet, BoxedSubstitution, BoxedSymbolDefinition, CanonicalOptions, EvaluateOptions, IComputeEngine, JsonSerializationOptions, Metadata, PatternMatchOptions, Rule, RuntimeScope, Sign, SimplifyOptions, Substitution } from './public';
 import type { LatexString } from '../public';
 import type { NumericValue } from '../numeric-value/public';
 import type { SmallInteger } from '../numerics/numeric';
+import { CompiledType } from '../compile';
 import type { SerializeLatexOptions } from '../latex-syntax/public';
 import { AsciiMathOptions } from './ascii-math';
 /**
@@ -116,7 +117,7 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
         canonical: CanonicalOptions;
         recursive?: boolean;
     }): BoxedExpression;
-    solve(_vars: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<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;
@@ -130,13 +131,13 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     get baseDefinition(): BoxedBaseDefinition | undefined;
     get symbolDefinition(): BoxedSymbolDefinition | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
-    infer(t: Type): boolean;
+    infer(_t: Type): boolean;
     bind(): void;
     reset(): void;
     get value(): number | boolean | string | object | undefined;
     set value(_value: BoxedExpression | number | boolean | string | number[] | undefined);
-    get type(): Type;
-    set type(_type: Type);
+    get type(): BoxedType;
+    set type(_type: Type | TypeString | BoxedType);
     get isNumber(): boolean | undefined;
     get isInteger(): boolean | undefined;
     get isRational(): boolean | undefined;
@@ -144,15 +145,15 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     simplify(_options?: Partial<SimplifyOptions>): BoxedExpression;
     expand(): BoxedExpression;
     evaluate(_options?: Partial<EvaluateOptions>): BoxedExpression;
+    evaluateAsync(_options?: Partial<EvaluateOptions>): Promise<BoxedExpression>;
     N(): BoxedExpression;
     compile(options?: {
         to?: 'javascript';
-        optimize?: ('simplify' | 'evaluate')[];
         functions?: Record<MathJsonIdentifier, string | ((...any: any[]) => any)>;
         vars?: Record<MathJsonIdentifier, string>;
         imports?: Function[];
         preamble?: string;
-    }): (args: Record<string, any>) => any | undefined;
+    }): (args: Record<string, any>) => CompiledType;
     get isCollection(): boolean;
     contains(_rhs: BoxedExpression): boolean;
     subsetOf(_target: BoxedExpression, _strict: boolean): boolean;
@@ -163,5 +164,6 @@ export declare abstract class _BoxedExpression implements BoxedExpression {
     indexOf(_expr: BoxedExpression): number;
 }
 export declare function getSubexpressions(expr: BoxedExpression, name: MathJsonIdentifier): ReadonlyArray<BoxedExpression>;
-import { Type } from '../../common/type/types';
+import type { Type, TypeString } from '../../common/type/types';
 import { AbstractTensor } from '../tensor/tensors';
+import { BoxedType } from '../../common/type/boxed-type';

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 import { Decimal } from 'decimal.js';
 import type { BoxedExpression } from '../public';
 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,5 +1,6 @@
-/* 0.27.0 */
+/* 0.28.0 */
 import { Type } from '../../common/type/types';
+import { BoxedType } from '../../common/type/boxed-type';
 /**
  *
  * The canonical form of `Add`:
@@ -10,6 +11,6 @@ import { Type } from '../../common/type/types';
  *
  */
 export declare function canonicalAdd(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression;
-export declare function addType(args: ReadonlyArray<BoxedExpression>): Type;
+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;

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 /**
  * Canonical form of 'Divide' (and 'Rational')
  * - remove denominator of 1

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 /**
  * The canonical form of `Multiply`:
  * - removes `1` anb `-1`

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 import type { Rational } from '../numerics/rationals';
 export declare function asRadical(expr: BoxedExpression): Rational | null;
 export declare function canonicalPower(a: BoxedExpression, b: BoxedExpression): BoxedExpression;

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.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,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 import { Decimal } from 'decimal.js';
 import { IComputeEngine, SemiBoxedExpression, BoxedExpression, Metadata, CanonicalOptions } from './public';
 import { MathJsonIdentifier } from '../../math-json/types';

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

@@ -1,7 +1,8 @@
-/* 0.27.0 */
+/* 0.28.0 */
 import type { BoxedExpression, CollectionHandlers, CompiledExpression, EvaluateOptions, Sign } from './public';
 import { Type, TypeString } from '../../common/type/types';
 import { OneOf } from '../../common/one-of';
+import { BoxedType } from '../../common/type/boxed-type';
 export declare class _BoxedFunctionDefinition implements BoxedFunctionDefinition {
     engine: IComputeEngine;
     scope: RuntimeScope;
@@ -17,11 +18,11 @@ export declare class _BoxedFunctionDefinition implements BoxedFunctionDefinition
     pure: boolean;
     complexity: number;
     lazy: boolean;
-    signature: Type;
+    signature: BoxedType;
     inferredSignature: boolean;
     type?: (ops: ReadonlyArray<BoxedExpression>, options: {
         engine: IComputeEngine;
-    }) => Type | TypeString | undefined;
+    }) => BoxedType | Type | TypeString | undefined;
     sgn?: (ops: ReadonlyArray<BoxedExpression>, options: {
         engine: IComputeEngine;
     }) => Sign | undefined;
@@ -36,12 +37,18 @@ export declare class _BoxedFunctionDefinition implements BoxedFunctionDefinition
     evaluate?: (ops: ReadonlyArray<BoxedExpression>, options: Partial<EvaluateOptions> & {
         engine: IComputeEngine;
     }) => BoxedExpression | undefined;
+    evaluateAsync?: (ops: ReadonlyArray<BoxedExpression>, options?: Partial<EvaluateOptions> & {
+        engine?: IComputeEngine;
+    }) => Promise<BoxedExpression | undefined>;
     evalDimension?: (ops: ReadonlyArray<BoxedExpression>, options: {
         engine: IComputeEngine;
     }) => BoxedExpression;
     compile?: (expr: BoxedExpression) => CompiledExpression;
     collection?: Partial<CollectionHandlers>;
     constructor(ce: IComputeEngine, name: string, def: FunctionDefinition);
+    infer(sig: Type): void;
+    update(def: FunctionDefinition): void;
     reset(): void;
 }
 export declare function makeFunctionDefinition(engine: IComputeEngine, name: string, def: OneOf<[FunctionDefinition | BoxedFunctionDefinition]>): BoxedFunctionDefinition;
+export declare function isBoxedFunctionDefinition(x: any): x is BoxedFunctionDefinition;

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

@@ -1,15 +1,16 @@
-/* 0.27.0 */
+/* 0.28.0 */
 import type { BoxedFunctionDefinition, IComputeEngine, BoxedRuleSet, SimplifyOptions, Substitution, ReplaceOptions, Metadata, PatternMatchOptions, RuntimeScope, BoxedSubstitution, EvaluateOptions, BoxedBaseDefinition, Rule, CanonicalOptions } from '../public';
 import type { BoxedExpression, Sign } from './public';
 import { NumericValue } from '../numeric-value/public';
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { Type } from '../../common/type/types';
+import { BoxedType } from '../../common/type/boxed-type';
 /**
- * A boxed function represent an expression that can be
- * represented by a function call.
+ * A boxed function represent an expression that can be represented by a
+ * function call.
  *
- * It is composed of an operator (the name of the function) and
- * a list of arguments.
+ * It is composed of an operator (the name of the function) and a list of
+ * arguments.
  *
  * It has a definition associated with it, based on the operator.
  * The definition contains the signature of the function, and the
@@ -98,11 +99,12 @@ export declare class BoxedFunction extends _BoxedExpression {
     get isReal(): boolean | undefined;
     get isFunctionExpression(): boolean;
     /** The type of the value of the function */
-    get type(): Type;
+    get type(): BoxedType;
     simplify(options?: Partial<SimplifyOptions>): BoxedExpression;
     evaluate(options?: Partial<EvaluateOptions>): BoxedExpression;
+    evaluateAsync(options?: Partial<EvaluateOptions>): Promise<BoxedExpression>;
     N(): BoxedExpression;
-    solve(vars: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
+    solve(vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
     get isCollection(): boolean;
     contains(rhs: BoxedExpression): boolean;
     get size(): number;
@@ -111,4 +113,6 @@ export declare class BoxedFunction extends _BoxedExpression {
     get(index: BoxedExpression | string): BoxedExpression | undefined;
     indexOf(expr: BoxedExpression): number;
     subsetOf(rhs: BoxedExpression, strict: boolean): boolean;
+    _computeValue(options?: Partial<EvaluateOptions>): () => BoxedExpression;
+    _computeValueAsync(options?: Partial<EvaluateOptions>): () => Promise<BoxedExpression>;
 }

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 import { Decimal } from 'decimal.js';
 import type { BoxedExpression, IComputeEngine, Metadata, PatternMatchOptions, BoxedSubstitution, EvaluateOptions, BoxedRuleSet, ReplaceOptions, Rule, Substitution, CanonicalOptions, SimplifyOptions, Sign } from '../public';
 import type { Expression, MathJsonNumber } from '../../math-json';
@@ -6,7 +6,7 @@ import { SmallInteger } from '../numerics/numeric';
 import { Rational } from '../numerics/rationals';
 import { ExactNumericValueData, NumericValue, NumericValueData } from '../numeric-value/public';
 import { _BoxedExpression } from './abstract-boxed-expression';
-import { Type } from '../../common/type/types';
+import { BoxedType } from '../../common/type/boxed-type';
 /**
  * BoxedNumber
  *
@@ -54,7 +54,7 @@ export declare class BoxedNumber extends _BoxedExpression {
     root(exp: number | BoxedExpression): BoxedExpression;
     sqrt(): BoxedExpression;
     ln(semiBase?: number | BoxedExpression): BoxedExpression;
-    get type(): Type;
+    get type(): BoxedType;
     get sgn(): Sign | undefined;
     get numerator(): BoxedExpression;
     get denominator(): BoxedExpression;

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 import type { BoxedExpression } from './public';
 export declare function isWildcard(expr: BoxedExpression): expr is BoxedSymbol;
 export declare function wildcardName(expr: BoxedExpression): string | null;

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

@@ -1,6 +1,6 @@
-/* 0.27.0 */
+/* 0.28.0 */
 import { _BoxedExpression } from './abstract-boxed-expression';
-import { Type } from '../../common/type/types';
+import { BoxedType } from '../../common/type/boxed-type';
 /**
  * BoxedString
  *
@@ -15,7 +15,7 @@ export declare class BoxedString extends _BoxedExpression {
     get isPure(): boolean;
     get isCanonical(): boolean;
     set isCanonical(_va: boolean);
-    get type(): Type;
+    get type(): BoxedType;
     get complexity(): number;
     get string(): string;
     match(pattern: BoxedExpression, _options?: PatternMatchOptions): BoxedSubstitution | null;

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

@@ -1,5 +1,6 @@
-/* 0.27.0 */
-import { Type } from '../../common/type/types';
+/* 0.28.0 */
+import { Type, TypeString } from '../../common/type/types';
+import { BoxedType } from '../../common/type/boxed-type';
 /**
  * ### THEORY OF OPERATIONS
  *
@@ -51,8 +52,8 @@ export declare class _BoxedSymbolDefinition implements BoxedSymbolDefinition {
     reset(): void;
     get value(): BoxedExpression | undefined;
     set value(val: SemiBoxedExpression | number | undefined);
-    get type(): Type;
-    set type(type: Type);
+    get type(): BoxedType;
+    set type(type: Type | TypeString | BoxedType);
     get sgn(): Sign | undefined;
     set sgn(val: Sign | undefined);
     get even(): boolean | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 import type { Expression } from '../../math-json/types';
 import type { Type, TypeString } from '../../common/type/types';
 import type { BoxedExpression, BoxedRuleSet, BoxedSymbolDefinition, IComputeEngine, EvaluateOptions, ReplaceOptions, SimplifyOptions, Substitution, Metadata, PatternMatchOptions, RuntimeScope, BoxedFunctionDefinition, BoxedBaseDefinition, BoxedSubstitution, Rule, CanonicalOptions, BoxedRule, Sign } from './public';
@@ -6,6 +6,7 @@ import { NumericValue } from '../numeric-value/public';
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { BigNum } from '../numerics/bignum';
 import type { OneOf } from '../../common/one-of';
+import { BoxedType } from '../../common/type/boxed-type';
 /**
  * BoxedSymbol
  *
@@ -64,7 +65,7 @@ export declare class BoxedSymbol extends _BoxedExpression {
     root(n: number | BoxedExpression): BoxedExpression;
     sqrt(): BoxedExpression;
     ln(semiBase?: number | BoxedExpression): BoxedExpression;
-    solve(vars: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
+    solve(vars?: Iterable<string> | string | BoxedExpression | Iterable<BoxedExpression>): null | ReadonlyArray<BoxedExpression>;
     get complexity(): number;
     get operator(): string;
     get symbol(): string;
@@ -72,7 +73,7 @@ export declare class BoxedSymbol extends _BoxedExpression {
     get symbolDefinition(): BoxedSymbolDefinition | undefined;
     get functionDefinition(): BoxedFunctionDefinition | undefined;
     /**
-     * Subsequence inferences will narrow the domain of the symbol.
+     * Subsequent inferences will narrow the domain of the symbol.
      * f: integer -> real, g: real -> real
      * g(x) => x: real
      * f(x) => x: integer narrowed from integer to real
@@ -90,8 +91,8 @@ export declare class BoxedSymbol extends _BoxedExpression {
         },
         BoxedExpression
     ]> | number | object | undefined);
-    get type(): Type;
-    set type(t: Type | TypeString);
+    get type(): BoxedType;
+    set type(t: Type | TypeString | BoxedType);
     get sgn(): Sign | undefined;
     has(x: string | string[]): boolean;
     match(pattern: BoxedExpression, options?: PatternMatchOptions): BoxedSubstitution | null;

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

@@ -1,10 +1,10 @@
-/* 0.27.0 */
+/* 0.28.0 */
 import type { BoxedExpression, IComputeEngine, EvaluateOptions, SimplifyOptions, Metadata, BoxedSubstitution, PatternMatchOptions, BoxedBaseDefinition, BoxedFunctionDefinition } from '../public';
 import { TensorDataType } from './tensor-fields';
 import { NumericValue } from '../numeric-value/public';
 import { _BoxedExpression } from './abstract-boxed-expression';
 import { AbstractTensor, TensorData } from '../tensor/tensors';
-import { Type } from '../../common/type/types';
+import { BoxedType } from '../../common/type/boxed-type';
 /**
  * A boxed tensor represents an expression that can be represented by a tensor.
  * This could be a vector, matrix or multi-dimensional array.
@@ -66,7 +66,7 @@ export declare class BoxedTensor extends _BoxedExpression {
     sqrt(): BoxedExpression;
     get shape(): number[];
     get rank(): number;
-    get type(): Type;
+    get type(): BoxedType;
     get json(): Expression;
     /** Mathematical equality */
     isEqual(rhs: number | BoxedExpression): boolean | undefined;

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

@@ -1,6 +1,7 @@
-/* 0.27.0 */
+/* 0.28.0 */
     value: T | null;
     generation: number | undefined;
 };
 /** The cache v will get updated if necessary */
 export declare function cachedValue<T>(v: CachedValue<T>, generation: number | undefined, fn: () => T): T;
+export declare function cachedValueAsync<T>(v: CachedValue<T>, generation: number | undefined, fn: () => Promise<T>): Promise<T>;

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

@@ -1,2 +1,2 @@
-/* 0.27.0 */
+/* 0.28.0 */
 export declare function canonicalForm(expr: BoxedExpression, forms: CanonicalOptions): BoxedExpression;

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 /**
  * Structural equality of boxed expressions.
  */

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 export declare function expandProducts(ce: IComputeEngine, ops: ReadonlyArray<BoxedExpression>): BoxedExpression | null;
 export declare function choose(n: number, k: number): number;
 /** Attempt to transform the expression (h, ops) into a sum */

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 import { NumericValue } from '../numeric-value/public';
 /** Combine rational expressions into a single fraction */
 export declare function together(op: BoxedExpression): BoxedExpression;

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 /**
  *
  * Make all the arguments canonical.

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

@@ -1,9 +1,10 @@
-/* 0.27.0 */
+/* 0.28.0 */
 /** Apply the function `f` to each operand of the expression `expr`,
- * account for the 'hold' property of the function definition:
+ * account for the 'lazy' property of the function definition:
  *
  * Account for `Hold`, `ReleaseHold`, `Sequence`, `Symbol` and `Nothing`.
  *
  * If `f` returns `null`, the element is not added to the result
  */
 export declare function holdMap(expr: BoxedExpression, f: (x: BoxedExpression) => BoxedExpression | null): ReadonlyArray<BoxedExpression>;
+export declare function holdMapAsync(expr: BoxedExpression, f: (x: BoxedExpression) => Promise<BoxedExpression | null>): Promise<ReadonlyArray<BoxedExpression>>;

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 /**
  * The function attempts to match a subject expression to a
  * [pattern](/compute-engine/guides/patterns-and-rules/).

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 export declare function canonicalNegate(expr: BoxedExpression): BoxedExpression;
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 import type { Rational } from '../numerics/rationals';
 import type { BoxedExpression } from './public';
 export declare function asRational(expr: BoxedExpression): Rational | undefined;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *

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

@@ -1,4 +1,4 @@
-/* 0.27.0 */
+/* 0.28.0 */
 import { Rational } from '../numerics/rationals';
 import { NumericValue } from '../numeric-value/public';
 /**