@cortex-js/compute-engine 0.9.0 → 0.11.0

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

@@ -1,4 +1,4 @@
-/* 0.9.0 */
+/* 0.11.0 */
  * The most important classes are {@link ComputeEngine} and
  * {@link BoxedExpression}.
  *
@@ -13,11 +13,11 @@ import type { SignalMessage, WarningSignal, WarningSignalHandler } from '../comm
 import type { Expression, MathJsonDictionary, MathJsonFunction, MathJsonNumber, MathJsonString, MathJsonSymbol } from '../math-json/math-json-format';
 import type { NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
 export * from './latex-syntax/public';
-export declare type Rational = [number, number] | [Decimal, Decimal];
+export type Rational = [number, number] | [Decimal, Decimal];
 /**
  * Metadata that can be associated with a `BoxedExpression`
  */
-export declare type Metadata = {
+export type Metadata = {
     latex?: string | undefined;
     wikidata?: string | undefined;
 };
@@ -35,9 +35,9 @@ export declare type Metadata = {
 
 </div>
  */
-export declare type NumericMode = 'auto' | 'machine' | 'bignum' | 'complex';
+export type NumericMode = 'auto' | 'machine' | 'bignum' | 'complex';
 /** Options for `BoxedExpression.simplify()` */
-export declare type SimplifyOptions = EvaluateOptions & {
+export type SimplifyOptions = EvaluateOptions & {
     recursive?: boolean;
     rules?: BoxedRuleSet;
 };
@@ -45,12 +45,12 @@ export declare type SimplifyOptions = EvaluateOptions & {
  *
  * @internal
  */
-export declare type EvaluateOptions = {};
+export type EvaluateOptions = {};
 /** Options for `BoxedExpression.N()`
  * @internal
  */
-export declare type NOptions = {};
-export declare type ReplaceOptions = {
+export type NOptions = {};
+export type ReplaceOptions = {
     /** If `true`, apply replacement rules to all sub-expressions.
      * If `false`, only consider the top-level expression.
      *
@@ -82,16 +82,16 @@ export declare type ReplaceOptions = {
  * A substitution can also be considered a more constrained version of a
  * rule whose `lhs` is always a symbol.
  */
-export declare type Substitution = {
+export type Substitution = {
     [symbol: string]: SemiBoxedExpression;
 };
-export declare type BoxedSubstitution = {
+export type BoxedSubstitution = {
     [symbol: string]: BoxedExpression;
 };
 /** A LaTeX string starts and end with `$`, for example
  * `"$\frac{\pi}{2}$"`.
  */
-export declare type LatexString = string;
+export type LatexString = string;
 /**
  *  A rule describes how to modify an expressions that matches a `lhs` pattern
  * into a new expressions matching `rhs`.
@@ -112,7 +112,7 @@ export declare type LatexString = string;
  *  - `__1` (`__a`, etc..) match a sequence of one or more expressions
  *  - `___1` (`___a`, etc...) match a sequence of zero or more expressions
  */
-export declare type Rule = [
+export type Rule = [
     lhs: LatexString | SemiBoxedExpression | Pattern,
     rhs: LatexString | SemiBoxedExpression,
     options?: {
@@ -120,18 +120,18 @@ export declare type Rule = [
         priority?: number;
     }
 ];
-export declare type BoxedRule = [
+export type BoxedRule = [
     lhs: Pattern,
     rhs: BoxedExpression,
     priority: number,
     condition: undefined | ((wildcards: BoxedSubstitution) => boolean)
 ];
-export declare type BoxedRuleSet = Set<BoxedRule>;
-export declare type DomainCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';
+export type BoxedRuleSet = Set<BoxedRule>;
+export type DomainCompatibility = 'covariant' | 'contravariant' | 'bivariant' | 'invariant';
 /** A domain constructor is the head of a domain expression. */
-export declare type DomainConstructor = 'Error' | 'Matrix' | 'SquareMatrix' | 'Vector' | 'Function' | 'List' | 'Dictionary' | 'Tuple' | 'Range' | 'Interval' | 'Intersection' | 'Union' | 'Maybe' | 'Sequence' | 'Head' | 'Symbol' | 'Value' | 'Covariant' | 'Contravariant' | 'Bivariant' | 'Invariant';
-export declare type DomainLiteral = string;
-export declare type DomainExpression<T = SemiBoxedExpression> = DomainLiteral | [DomainConstructor, ...(string | T | DomainExpression<T>)[]] | ['Error', T] | ['Error', T, T] | ['Union', ...DomainExpression<T>[]] | ['Intersection', ...DomainExpression<T>[]] | ['Matrix', DomainExpression<T>, T, T] | ['SquareMatrix', DomainExpression<T>, T] | ['Vector', DomainExpression<T>, T] | ['List', DomainExpression<T>] | ['Dictionary', DomainExpression<T>] | ['Tuple', ...DomainExpression<T>[]] | ['Maybe', DomainExpression<T>] | ['Sequence', DomainExpression<T>] | ['Range'] | ['Range', T] | ['Range', T, T] | ['Range', T, T, T] | ['Interval', T, T] | ['Interval', ['Open', T], T] | ['Interval', T, ['Open', T]] | ['Interval', ['Open', T], ['Open', T]] | ['Value', T] | ['Head', string] | ['Symbol', string] | ['Covariant', DomainExpression<T>] | ['Contravariant', DomainExpression<T>] | ['Bivariant', DomainExpression<T>] | ['Invariant', DomainExpression<T>] | ['Function', ...DomainExpression<T>[]];
+export type DomainConstructor = 'Error' | 'Matrix' | 'SquareMatrix' | 'Vector' | 'Function' | 'List' | 'Dictionary' | 'Tuple' | 'Range' | 'Interval' | 'Intersection' | 'Union' | 'Maybe' | 'Sequence' | 'Head' | 'Symbol' | 'Value' | 'Covariant' | 'Contravariant' | 'Bivariant' | 'Invariant';
+export type DomainLiteral = string;
+export type DomainExpression<T = SemiBoxedExpression> = DomainLiteral | [DomainConstructor, ...(string | T | DomainExpression<T>)[]] | ['Error', T] | ['Error', T, T] | ['Union', ...DomainExpression<T>[]] | ['Intersection', ...DomainExpression<T>[]] | ['Matrix', DomainExpression<T>, T, T] | ['SquareMatrix', DomainExpression<T>, T] | ['Vector', DomainExpression<T>, T] | ['List', DomainExpression<T>] | ['Dictionary', DomainExpression<T>] | ['Tuple', ...DomainExpression<T>[]] | ['Maybe', DomainExpression<T>] | ['Sequence', DomainExpression<T>] | ['Range'] | ['Range', T] | ['Range', T, T] | ['Range', T, T, T] | ['Interval', T, T] | ['Interval', ['Open', T], T] | ['Interval', T, ['Open', T]] | ['Interval', ['Open', T], ['Open', T]] | ['Value', T] | ['Head', string] | ['Symbol', string] | ['Covariant', DomainExpression<T>] | ['Contravariant', DomainExpression<T>] | ['Bivariant', DomainExpression<T>] | ['Invariant', DomainExpression<T>] | ['Function', ...DomainExpression<T>[]];
 export interface BoxedDomain extends BoxedExpression {
     is(s: BoxedDomain): boolean;
     /** True if a valid domain, and compatible with `dom` */
@@ -176,7 +176,7 @@ export interface BoxedDomain extends BoxedExpression {
 /**
  * Options to control the serialization to MathJSON when using `BoxedExpression.json`.
  */
-export declare type JsonSerializationOptions = {
+export type JsonSerializationOptions = {
     /** A list of space separated function names that should be excluded from
      * the JSON output.
      *
@@ -431,16 +431,6 @@ export interface BoxedExpression {
      *
      */
     readonly isValid: boolean;
-    /**
-     * If `true`, this expression represents a value that was not calculated
-     * and that does not reference another expression.
-     *
-     * This means the expression is either a number, a string or a dictionary.
-     * Functions and symbols are not literals.
-     *
-     * **Note** applicable to canonical and non-canonical expressions.
-     */
-    readonly isLiteral: boolean;
     /**
      * An exact value is not further transformed when evaluated. To get an
      * approximate evaluation of an exact value, use `.N()`.
@@ -997,8 +987,8 @@ export interface BoxedExpression {
  * This is convenient when creating new expressions from portions
  * of an existing `BoxedExpression` while avoiding unboxing and reboxing.
  */
-export declare type SemiBoxedExpression = number | string | Decimal | Complex | MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction | MathJsonDictionary | SemiBoxedExpression[] | BoxedExpression;
-export declare type PatternMatchOptions = {
+export type SemiBoxedExpression = number | string | Decimal | Complex | MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction | MathJsonDictionary | SemiBoxedExpression[] | BoxedExpression;
+export type PatternMatchOptions = {
     substitution?: BoxedSubstitution;
     recursive?: boolean;
     numericTolerance?: number;
@@ -1019,27 +1009,31 @@ export interface ExpressionMapInterface<U> {
     [Symbol.iterator](): IterableIterator<[BoxedExpression, U]>;
 }
 /**
- * A symbol table contains definitions for symbols, functions and rules.
+ * An ID table contains definitions for symbols and functions.
+ *
+ * The index of the table is an identifier, the  name of the symbol or
+ * function for this definition
+ *
+ * The name of a symbol or function is an arbitrary string of Unicode
+ * characters, however the following conventions are recommended:
+ *
+ * - Use only letters, digits and `-`: `/[a-zA-Z0-9-]+/`
+ * - The first character should be a letter: `/^[a-zA-Z]/`
+ * - Functions and symbols exported from a library should start with an uppercase letter `/^[A-Z]/`
  *
  */
-export declare type SymbolTable = {
-    symbols?: SymbolDefinition[];
-    functions?: FunctionDefinition[];
-    simplifyRules?: BoxedRuleSet;
+export type IDTable = {
+    [id: string]: SymbolDefinition | FunctionDefinition;
 };
 /**
- * The entries of a `RuntimeSymbolTable` have been validated and
+ * The entries of a `RuntimeIdentifierTable` have been validated and
  * optimized for faster evaluation.
  *
  * When a new scope is created with `pushScope()` or when creating a new
- * engine instance, new instances of `RuntimeDictionary` are created as needed.
+ * engine instance, new instances of `RuntimeIdentifierTable` are created
+ * as needed.
  */
-export declare type RuntimeSymbolTable = {
-    symbols: Map<string, BoxedSymbolDefinition>;
-    symbolWikidata: Map<string, BoxedSymbolDefinition>;
-    functions: Map<string, BoxedFunctionDefinition>;
-    functionWikidata: Map<string, BoxedFunctionDefinition>;
-};
+export type RuntimeIdentifierTable = Map<string, BoxedSymbolDefinition | BoxedFunctionDefinition>;
 /**
  * A scope is a set of names in a dictionary that are bound (defined) in
  * a MathJSON expression.
@@ -1055,7 +1049,7 @@ export declare type RuntimeSymbolTable = {
  * where they are in an expression, they are not determined at runtime.
  *
  */
-export declare type Scope = {
+export type Scope = {
     /** This handler is invoked when exiting this scope if there are any
      * warnings pending. */
     warn?: WarningSignalHandler;
@@ -1084,9 +1078,9 @@ export declare type Scope = {
      */
     iterationLimit?: number;
 };
-export declare type RuntimeScope = Scope & {
+export type RuntimeScope = Scope & {
     parentScope?: RuntimeScope;
-    symbolTable?: RuntimeSymbolTable;
+    idTable?: RuntimeIdentifierTable;
     assumptions: undefined | ExpressionMapInterface<boolean>;
     /** The location of the call site that created this scope */
     origin?: {
@@ -1099,18 +1093,7 @@ export declare type RuntimeScope = Scope & {
     /** Set when one or more warnings have been signaled in this scope */
     warnings?: WarningSignal[];
 };
-export declare type BaseDefinition = {
-    /** The name of the symbol or function for this definition
-     *
-     * The name of a symbol or function is an arbitrary string of Unicode
-     * characters, however the following conventions are recommended:
-     *
-     * - Use only letters, digits and `-`: `/[a-zA-Z0-9-]+/`
-     * - The first character should be a letter: `/^[a-zA-Z]/`
-     * - Functions and symbols exported from a library should start with an uppercase letter `/^[A-Z]/`
-     *
-     */
-    name: string;
+export type BaseDefinition = {
     /** A short (about 1 line) description. May contain Markdown. */
     description?: string | string[];
     /** A URL pointing to more information about this symbol or head. */
@@ -1143,7 +1126,7 @@ export interface BoxedBaseDefinition {
  * A function definition can have some flags to indicate specific
  * properties of the function.
  */
-export declare type FunctionDefinitionFlags = {
+export type FunctionDefinitionFlags = {
     /**  If `true`, the function is applied element by element to lists, matrices
      * (`["List"]` or `["Tuple"]` expressions) and equations (relational
      * operators).
@@ -1230,7 +1213,7 @@ export declare type FunctionDefinitionFlags = {
 /**
  *
  */
-export declare type FunctionSignature = {
+export type FunctionSignature = {
     /** The domain of this signature, a domain compatible with the `Function`
      * domain) */
     domain?: BoxedDomain | DomainExpression;
@@ -1260,7 +1243,10 @@ export declare type FunctionSignature = {
      * arguments should be sorted in canonical order.
      *
      * The handler can make transformations based on the value of the arguments
-     * that are exact (i.e. `arg.isExact`).
+     * that are exact and literal
+     * (i.e. `arg.numericValue !== null && arg.isExact`).
+     *
+     * Values of symbols should not be substituted.
      *
      * The handler should not consider the value or any assumptions about any
      * of the arguments that are symbols or functions (i.e. `arg.isZero`,
@@ -1374,7 +1360,7 @@ export declare type FunctionSignature = {
     /** Return a compiled (optimized) expression. */
     compile?: (expr: BoxedExpression) => CompiledExpression;
 };
-export declare type BoxedFunctionSignature = {
+export type BoxedFunctionSignature = {
     domain: BoxedDomain;
     codomain?: BoxedDomain | ((ce: IComputeEngine, args: BoxedExpression[]) => BoxedDomain | null);
     canonical?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | null;
@@ -1389,7 +1375,7 @@ export declare type BoxedFunctionSignature = {
  * Definition record for a function.
  *
  */
-export declare type FunctionDefinition = BaseDefinition & Partial<FunctionDefinitionFlags> & {
+export type FunctionDefinition = BaseDefinition & Partial<FunctionDefinitionFlags> & {
     /**
      * A number used to order arguments.
      *
@@ -1424,7 +1410,7 @@ export declare type FunctionDefinition = BaseDefinition & Partial<FunctionDefini
     hold?: 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
     signature?: FunctionSignature;
 };
-export declare type BoxedFunctionDefinition = BoxedBaseDefinition & FunctionDefinitionFlags & {
+export type BoxedFunctionDefinition = BoxedBaseDefinition & FunctionDefinitionFlags & {
     complexity: number;
     hold: 'none' | 'all' | 'first' | 'rest' | 'last' | 'most';
     signature: BoxedFunctionSignature;
@@ -1438,7 +1424,7 @@ export declare type BoxedFunctionDefinition = BoxedBaseDefinition & FunctionDefi
  * For example, it might be useful to override `algebraic = false`
  * for a transcendental number.
  */
-export declare type SymbolFlags = {
+export type SymbolFlags = {
     number: boolean | undefined;
     integer: boolean | undefined;
     rational: boolean | undefined;
@@ -1464,42 +1450,61 @@ export declare type SymbolFlags = {
     prime: boolean | undefined;
     composite: boolean | undefined;
 };
-export declare type SymbolDefinitionFlags = {
+export type SymbolAttributes = {
     /**
-     * If true the value of the symbol is constant.
+     * If `true` the value of the symbol is constant. The value or domain of
+     * symbols with this attribute set to `true` cannot be changed.
+     *
+     * If `false`, the symbol is a variable.
      *
-     * If false, the symbol is a variable.
+     * **Default**: `false`
      */
     constant: boolean;
     /**
-     * If `false`, the value of the symbol is substituted during canonicalization
-     * or simplification.
-     *
-     * If true, the value is only replaced during a `ce.N()` or `ce.evaluate()`.
-     *
-     * **Default:** `true`
-     */
-    hold: boolean;
+     * If the symbol has a value, it is held as indicated in the table below.
+     * A green checkmark indicate that the symbol is substituted.
+  
+  <div class=symbols-table>
+  
+  | Operation | `"never"` | `"simplify"` | `"evaluate"` | `"N"` |
+  | :--- | :----- |
+  | `canonical()`|  {% icon "circle-check" "green-700" %} | | | |
+  | `simplify()` |   {% icon "circle-check" "green-700" %} | {% icon "circle-check" "green-700" %} | | |
+  | `evaluate()` |   {% icon "circle-check" "green-700" %} | {% icon "circle-check" "green-700" %} | {% icon "circle-check" "green-700" %} | |
+  | `"N()"` |  {% icon "circle-check" "green-700" %} | {% icon "circle-check" "green-700" %}  |  {% icon "circle-check" "green-700" %} | {% icon "circle-check" "green-700" %}  |
+  
+  </div>
+  
+    * Some examples:
+    * - `i` has `holdUntil: 'never'`
+    * - `GoldenRatio` has `holdUntil: 'simplify'` (symbolic constant)
+    * - `x` has `holdUntil: 'evaluate'` (variables)
+    * - `Pi` has `holdUntil: 'N'` (special numeric constant)
+    *
+    * **Default:** `simplify`
+    */
+    holdUntil: 'never' | 'simplify' | 'evaluate' | 'N';
 };
 /**
  * A bound symbol (i.e. one with an associated definition) has either a domain
  * (e.g. ∀ x ∈ ℝ), a value (x = 5) or both (π: value = 3.14... domain = TranscendentalNumber)
  */
-export declare type SymbolDefinition = BaseDefinition & Partial<SymbolFlags> & Partial<SymbolDefinitionFlags> & {
+export type SymbolDefinition = BaseDefinition & Partial<SymbolAttributes> & {
+    domain?: string | BoxedDomain;
     /** `value` can be a function since for some constants, such as
      * `Pi`, the actual value depends on the `precision` setting of the
      * `ComputeEngine` */
     value?: LatexString | SemiBoxedExpression | ((ce: IComputeEngine) => SemiBoxedExpression | null);
-    domain?: string | BoxedDomain;
+    flags?: Partial<SymbolFlags>;
 };
-export interface BoxedSymbolDefinition extends BoxedBaseDefinition, Partial<SymbolFlags>, SymbolDefinitionFlags {
+export interface BoxedSymbolDefinition extends BoxedBaseDefinition, SymbolAttributes, Partial<SymbolFlags> {
     get value(): BoxedExpression | undefined;
-    set value(val: BoxedExpression | undefined);
+    set value(val: SemiBoxedExpression | number | undefined);
     domain: BoxedDomain | undefined;
     at?: (index: string | number) => undefined | BoxedExpression;
 }
-export declare type AssumeResult = 'internal-error' | 'not-a-predicate' | 'contradiction' | 'tautology' | 'ok';
-export declare type CompiledExpression = {
+export type AssumeResult = 'internal-error' | 'not-a-predicate' | 'contradiction' | 'tautology' | 'ok';
+export type CompiledExpression = {
     evaluate?: (scope: {
         [symbol: string]: BoxedExpression;
     }) => number | BoxedExpression;
@@ -1570,18 +1575,26 @@ export interface IComputeEngine {
     set precision(p: number | 'machine');
     get precision(): number;
     costFunction: (expr: BoxedExpression) => number;
+    /** In strict mode (the default) the Compute Engine performs
+     * validation of domains and signature and may report errors.
+     *
+     * When strict mode is off, results may be incorrect or generate JavaScript
+     * errors if the input is not valid.
+     *
+     */
+    strict: boolean;
     /**
      * Associate a new definition to a symbol in the current context.
      *
      * If a definition existed previously, it is replaced.
      */
-    defineSymbol(def: SymbolDefinition): BoxedSymbolDefinition;
+    defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
     /**
      * Associate a new definition to a function in the current context.
      *
      * If a definition existed previously, it is replaced.
      */
-    defineFunction(def: FunctionDefinition): BoxedFunctionDefinition;
+    defineFunction(name: string, def: FunctionDefinition): BoxedFunctionDefinition;
     lookupSymbol(name: string, wikidata?: string, scope?: RuntimeScope): undefined | BoxedSymbolDefinition;
     /** Return `undefined` if no definition exist for this `head` */
     lookupFunction(head: string | BoxedExpression, scope?: RuntimeScope | null): undefined | BoxedFunctionDefinition;
@@ -1717,15 +1730,11 @@ export interface IComputeEngine {
     /** {@inheritDoc  JsonSerializationOptions} */
     get jsonSerializationOptions(): Readonly<JsonSerializationOptions>;
     set jsonSerializationOptions(val: Partial<JsonSerializationOptions>);
-    pushScope(options?: {
-        symbolTable?: Readonly<SymbolTable> | Readonly<SymbolTable>[];
-        assumptions?: (LatexString | Expression | BoxedExpression)[];
-        scope?: Partial<Scope>;
-    }): void;
+    pushScope(symbolTable?: Readonly<IDTable> | Readonly<IDTable>[], scope?: Partial<Scope>): void;
     popScope(): void;
-    /** Assign a value to an identifier in the current scope */
+    /** Assign a value to an identifier in the current scope. Use `null` to reset the identifier to no value */
     set(identifiers: {
-        [identifier: string]: SemiBoxedExpression;
+        [identifier: string]: SemiBoxedExpression | null;
     }): void;
     /** Declare identifiers (specify their domain without necessarily assigning them a value in the current scope*/
     let(identifiers: {

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

@@ -1,4 +1,4 @@
-/* 0.9.0 */
+/* 0.11.0 */
 /**
  * Go through all the rules in the rule set, and for all the rules that match
  * return the rhs of the rule applied to `expr`.

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

@@ -1,4 +1,4 @@
-/* 0.9.0 */
+/* 0.11.0 */
 /**
  * A set of simplification rules.
  *

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

@@ -1,4 +1,4 @@
-/* 0.9.0 */
+/* 0.11.0 */
 export declare const UNIVARIATE_ROOTS: Rule[];
 /**
  * Expression is a function of a single variable (`x`) or an Equality

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

@@ -1,4 +1,4 @@
-/* 0.9.0 */
+/* 0.11.0 */
 /**
  * Return the expansion of ['Multiply', lhs, rhs]
  * - lhs = 'a + b', rhs = '2'

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

@@ -1,4 +1,4 @@
-/* 0.9.0 */
+/* 0.11.0 */
 /**
  * Flatten the arguments.
  * If `expr` was canonical, the result it canonical.

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

@@ -1,4 +1,4 @@
-/* 0.9.0 */
+/* 0.11.0 */
 /**
  * Distribute `Negate` (multiply by -1) if expr is a number literal, an
  * addition or another `Negate`.

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

@@ -1,4 +1,4 @@
-/* 0.9.0 */
+/* 0.11.0 */
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *
@@ -12,8 +12,8 @@
  * If a coefficient does not apply (there are no corresponding term), it is `null`.
  *
  */
-export declare type UnivariateCoefficients = (null | BoxedExpression)[];
-export declare type MultivariateCoefficients = (null | (null | BoxedExpression)[])[];
+export type UnivariateCoefficients = (null | BoxedExpression)[];
+export type MultivariateCoefficients = (null | (null | BoxedExpression)[])[];
 /**
  * Return a list of coefficient of powers of `vars` in `poly`,
  * starting with power 0.

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

@@ -1,4 +1,4 @@
-/* 0.9.0 */
+/* 0.11.0 */
 /**
  * Group terms in a product by common term.
  *

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

@@ -1,4 +1,4 @@
-/* 0.9.0 */
+/* 0.11.0 */
 export declare class Sum {
     private engine;
     private _rational;

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

@@ -1,4 +1,4 @@
-/* 0.9.0 */
+/* 0.11.0 */
 import Decimal from 'decimal.js';
 import { BoxedExpression, Rational } from '../public';
 /**

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

@@ -1,4 +1,4 @@
-/* 0.9.0 */
+/* 0.11.0 */
 export { ComputeEngine } from './compute-engine/compute-engine';
-export declare const version = "0.9.0";
+export declare const version = "0.11.0";
 export { getVars } from './compute-engine/boxed-expression/utils';

package/dist/types/math-json/math-json-format.d.ts

@@ -1,4 +1,4 @@
-/* 0.9.0 */
+/* 0.11.0 */
     /** A human readable string to annotate this expression, since JSON does not
      * allow comments in its encoding */
     comment?: string;
@@ -78,19 +78,19 @@
  * - `1.(3)`
  * - `123456789123456789.123(4567)e999`
  */
-export declare type MathJsonNumber = {
+export type MathJsonNumber = {
     num: 'NaN' | '-Infinity' | '+Infinity' | string;
 } & Attributes;
-export declare type MathJsonSymbol = {
+export type MathJsonSymbol = {
     sym: string;
 } & Attributes;
-export declare type MathJsonString = {
+export type MathJsonString = {
     str: string;
 } & Attributes;
-export declare type MathJsonFunction = {
+export type MathJsonFunction = {
     fn: [Expression, ...Expression[]];
 } & Attributes;
-export declare type MathJsonDictionary = {
+export type MathJsonDictionary = {
     dict: {
         [key: string]: Expression;
     };
@@ -102,4 +102,4 @@ export declare type MathJsonDictionary = {
  * The dictionary and function nodes can contain expressions themselves.
  *
  */
-export declare type Expression = number | string | MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction | MathJsonDictionary | [Expression, ...Expression[]];
+export type Expression = number | string | MathJsonNumber | MathJsonString | MathJsonSymbol | MathJsonFunction | MathJsonDictionary | [Expression, ...Expression[]];

package/dist/types/math-json/utils.d.ts

@@ -1,4 +1,4 @@
-/* 0.9.0 */
+/* 0.11.0 */
 export declare function isNumberObject(expr: Expression | null): expr is MathJsonNumber;
 export declare function isSymbolObject(expr: Expression | null): expr is MathJsonSymbol;
 export declare function isStringObject(expr: Expression | null): expr is MathJsonString;

package/dist/types/math-json.d.ts

@@ -1,4 +1,4 @@
-/* 0.9.0 */
+/* 0.11.0 */
 export { isSymbolObject, isStringObject, isFunctionObject, isDictionaryObject, stringValue as getStringValue, head, headName, symbol, applyRecursively, mapArgs, op, nops, dictionary as getDictionary, } from './math-json/utils';
 export type { LatexToken, ParseHandler, SerializeHandler, LatexDictionaryEntry, LatexDictionary, ParseLatexOptions, SerializeLatexOptions, NumberFormattingOptions, } from './compute-engine/latex-syntax/public';
-export declare const version = "0.9.0";
+export declare const version = "0.11.0";

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.9.0",
+  "version": "0.11.0",
   "scripts": {
     "build": "bash ./scripts/build.sh",
     "clean": "bash ./scripts/clean.sh",