@cortex-js/compute-engine 0.5.0 → 0.6.0

package/dist/types/compute-engine/latex-syntax/dictionary/definitions-trigonometry.d.ts

@@ -1,2 +1,2 @@
-/* 0.5.0 */
+/* 0.6.0 */
 export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;

package/dist/types/compute-engine/latex-syntax/dictionary/definitions.d.ts

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.0 */
 import { WarningSignal } from '../../../common/signals';
 export declare type CommonEntry = {
     name?: string;
@@ -7,7 +7,6 @@ export declare type CommonEntry = {
 export declare type SymbolEntry = CommonEntry & {
     kind: 'symbol';
     precedence: number;
-    arguments: 'group' | 'implicit' | '';
     optionalLatexArg: number;
     requiredLatexArg: number;
     parse: SymbolParseHandler;

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

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.0 */
 import { Serializer } from './serializer';
 import { Expression } from '../../math-json/math-json-format';
 import { WarningSignalHandler } from '../../common/signals';
@@ -16,7 +16,7 @@ export declare class LatexSyntax {
         onError?: WarningSignalHandler;
     });
     updateOptions(opt: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>): void;
-    static getDictionary(domain?: DictionaryCategory | 'all'): Readonly<LatexDictionary>;
+    static getDictionary(category?: DictionaryCategory | 'all'): Readonly<LatexDictionary>;
     parse(latex: LatexString): Expression;
     serialize(expr: Expression): LatexString;
     get serializer(): Serializer;

package/dist/types/compute-engine/latex-syntax/parse.d.ts

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.0 */
 import { ParseLatexOptions, LatexToken, NumberFormattingOptions, Delimiter, Terminator, Parser } from './public';
 import { IndexedLatexDictionary, InfixEntry, PostfixEntry, PrefixEntry, SymbolEntry } from './dictionary/definitions';
 import { WarningSignalHandler } from '../../common/signals';
@@ -79,11 +79,13 @@ export declare class _Parser implements Parser {
     matchPrefixOperator(until?: Terminator): Expression | null;
     matchInfixOperator(lhs: Expression, until?: Terminator): Expression | null;
     /**
-     * 'group' : will look for an argument inside a pair of `()`
-     * 'implicit': either an expression inside a pair of `()`, or just a primary
+     * - 'enclosure' : will look for an argument inside an enclosure (open/close fence)
+     * - 'implicit': either an expression inside a pair of `()`, or just a primary
      *  (i.e. we interpret `\cos x + 1` as `\cos(x) + 1`)
+     * - 'group': the arguments follow until an end of group, `<}>`. This is the
+     * case for example for `\displaystyle`
      */
-    matchArguments(kind: undefined | '' | 'group' | 'implicit'): Expression[] | null;
+    matchArguments(kind: undefined | '' | 'enclosure' | 'implicit' | 'group'): Expression[] | null;
     /** If matches the normalized open delimiter, returns the
      * expected closing delimiter.
      *
@@ -103,7 +105,8 @@ export declare class _Parser implements Parser {
     /**
      * A symbol can be:
      * - a constant: `\pi`
-     * - a variable: `x`
+     * - a single-letter variable: `x`
+     * - a multi-letter variable: `\mathit{speed}` or `\mathrm{speed}`
      * - a function with explicit arguments `f(x)`
      * - a function with implicit arguments: `\cos x`
      * - a command: `\frac{2}{3}`
@@ -133,9 +136,7 @@ export declare class _Parser implements Parser {
      */
     matchSupsub(lhs: Expression | null): Expression | null;
     matchPostfix(lhs: Expression | null): Expression | null;
-    matchString(until: {
-        tokens: LatexToken[];
-    } & Partial<Terminator>): string;
+    matchString(until: Partial<Terminator>): string;
     matchEnvironmentName(command: '\\begin' | '\\end', envName: string): boolean;
     /**
      * Match an expression in a tabular format,
@@ -192,7 +193,7 @@ export declare class _Parser implements Parser {
      */
     matchExpression(until?: Partial<Terminator>): Expression | null;
     /**
-     * Add latex or other requested metadata to the expression
+     * Add LaTeX or other requested metadata to the expression
      */
     decorate(expr: Expression | null, start: number): Expression | null;
 }

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

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.0 */
 import { Expression } from '../../math-json/math-json-format';
 import type { IComputeEngine } from '../public';
 /**
@@ -165,6 +165,7 @@ export declare type SymbolEntry = BaseEntry & {
     precedence?: number;
     /**
      * Indicate if this symbol can be followed by arguments.
+     *
      * The presence of arguments will indicate that the arguments should be
      * applied to the symbol. Otherwise, the invisible operator is applied
      * to the symbol and the arguments.
@@ -172,14 +173,14 @@ export declare type SymbolEntry = BaseEntry & {
      * If `arguments` is `"group"`:
      *
      * "f(x)" -> `["f", "x"]`
-     * "f x" -> `["multiply", "f", "x"]`
+     * "f x" -> `["Multiply", "f", "x"]`
      *
      * If `arguments` is `""`:
      *
-     * "f(x)" -> `["multiply", "f", ["group", "x"]]`
-     * "f x" -> `["multiply", "f", "x"]`
+     * "f(x)" -> `["Multiply", "f", "x"]`
+     * "f x" -> `["Multiply", "f", "x"]`
      *
-     * If `arguments` is `"group/primary"` and the symbol is followed either
+     * If `arguments` is `"implicit"` and the symbol is followed either
      * by a group or by a primary (prefix + symbol + subsupfix + postfix).
      * Used for trig functions. i.e. `\sin x` vs `\sin(x)`:
      *
@@ -187,9 +188,7 @@ export declare type SymbolEntry = BaseEntry & {
      * "f x" -> `["f", "x"]`
      *
      */
-    arguments?: 'group' | 'implicit' | '';
     /**
-     * Applicable when `kind` is `"symbol"`.
      *
      * If a LaTeX command (i.e. the trigger starts with `\`, e.g. `\sqrt`)
      * indicates the number of optional arguments expected (indicate with
@@ -200,7 +199,6 @@ export declare type SymbolEntry = BaseEntry & {
      */
     optionalLatexArg?: number;
     /**
-     * Applicable when `kind` is `"symbol"`.
      *
      * If a LaTeX command (i.e. the trigger starts with `\`, e.g. `\frac`)
      * indicates the number of required arguments expected (indicated with
@@ -217,7 +215,6 @@ export declare type SymbolEntry = BaseEntry & {
  */
 export declare type DefaultEntry = BaseEntry & {
     precedence?: number;
-    arguments?: 'group' | 'implicit' | '';
     optionalLatexArg?: number;
     requiredLatexArg?: number;
     parse?: Expression | SymbolParseHandler;
@@ -280,22 +277,22 @@ export declare type ParseLatexOptions = {
      */
     parseNumbers: boolean;
     /**
-     * The `parseUnknownToken`  function is invoked when a token (`a`,
-     * `\alpha`...) is encountered at a position where a symbol or a function
-     * could be parsed.
+     * This handler is invoked when the parser encounter a set of tokens
+     * at a position that could be a symbol or function.
+     *
+     * The `symbol` argument is one or more tokens.
      *
-     * If it returns `symbol` or `function`, the token is interpreted as a symbol
-     * or function, respectively.
+     * The handler can return:
      *
-     * If a `function` and the token is followed by an apply function operator
-     * (typically, parentheses), parse them as arguments to the function.
+     * - `symbol` to indicate the string represent a constant or variable.
      *
-     * If `skip`, the token is skipped as if it was not present. This is
-     * convenient for purely presentational commands, such as `\displaystyle`.
+     * - `function` to indicate the string is a function name. If an apply
+     * function operator (typically, parentheses) follow, parse them as arguments
+     * to the function.
      *
-     * If `error`, an error condition is raised.
+     * - `error`, an error condition is raised.
      */
-    parseUnknownToken: (token: LatexToken, parser: Parser) => 'symbol' | 'function' | 'skip' | 'error';
+    parseUnknownSymbol: (symbol: string, parser: Parser) => 'symbol' | 'function' | 'unknown';
     /**
      * If true, the expression will be decorated with the LaTeX
      * fragments corresponding to each elements of the expression.
@@ -515,16 +512,18 @@ export interface Parser {
     /** If the next tokens correspond to an optional LaTeX argument,
      * enclosed with `[` and `]` return the content of the argument
      * as an expression and advance the index past the closing `]`.
+     *
      * Otherwise, return `null`.
      */
     matchOptionalLatexArgument(): Expression | null;
     matchRequiredLatexArgument(): Expression | null;
     /**
-     * 'group' : will look for an argument inside a pair of `()`
-     * 'implicit': either an expression inside a pair of `()`, or just a primary
-     *  (i.e. we interpret `\cos x + 1` as `\cos(x) + 1`)
+     * - 'enclosure' : will look for an argument inside an enclosure (an open/close fence)
+     * - 'group': arguments follow directly the symbol, until an end of group token `<}>`
+     * - 'implicit': either an expression inside a pair of `()`, or just a primary
+     *    (i.e. we interpret `\cos x + 1` as `\cos(x) + 1`)
      */
-    matchArguments(kind: '' | 'group' | 'implicit'): Expression[] | null;
+    matchArguments(kind: '' | 'group' | 'implicit' | 'enclosure'): Expression[] | null;
     /** If matches the normalized open delimiter, returns the
      * expected closing delimiter.
      *

package/dist/types/compute-engine/latex-syntax/serialize-number.d.ts

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.0 */
 import { NumberFormattingOptions } from './public';
 export declare function serializeNumber(expr: Expression | null, options: NumberFormattingOptions): string;
 export declare function serializeEngineeringNotationNumber(value: number, options: NumberFormattingOptions): string;

package/dist/types/compute-engine/latex-syntax/serializer-style.d.ts

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.0 */
 export declare function getApplyFunctionStyle(_expr: Expression, _level: number): 'paren' | 'leftright' | 'big' | 'none';
 export declare function getGroupStyle(_expr: Expression, _level: number): 'paren' | 'leftright' | 'big' | 'none';
 export declare function getRootStyle(_expr: Expression | null, level: number): 'radical' | 'quotient' | 'solidus';

package/dist/types/compute-engine/latex-syntax/serializer.d.ts

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.0 */
 import { NumberFormattingOptions, LatexString, SerializeLatexOptions } from './public';
 import { IndexedLatexDictionary, SymbolEntry } from './dictionary/definitions';
 import { WarningSignalHandler } from '../../common/signals';

package/dist/types/compute-engine/latex-syntax/tokenizer.d.ts

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.0 */
  * ## Reference
  * TeX source code:
  * {@link  http://tug.org/texlive/devsrc/Build/source/texk/web2c/tex.web | Tex.web}

package/dist/types/compute-engine/numerics/numeric-complex.d.ts

@@ -1,3 +1,3 @@
-/* 0.5.0 */
+/* 0.6.0 */
 export declare function gamma(c: Complex): Complex;
 export declare function lngamma(c: Complex): Complex;

package/dist/types/compute-engine/numerics/numeric-decimal.d.ts

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.0 */
 import { IComputeEngine } from '../public';
 export declare function gcd(a: Decimal, b: Decimal): Decimal;
 export declare function lcm(a: Decimal, b: Decimal): Decimal;

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

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.0 */
 export declare const MACHINE_PRECISION: number;
 export declare const MACHINE_TOLERANCE_BITS = 7;
 export declare const MACHINE_TOLERANCE: number;

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

@@ -1,2 +1,2 @@
-/* 0.5.0 */
+/* 0.6.0 */
 export declare function isPrime(n: number): boolean | undefined;

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

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.0 */
  * The most important classes are {@link ComputeEngine} and
  * {@link BoxedExpression}.
  *
@@ -122,13 +122,59 @@ export declare type BoxedRule = [
     condition: undefined | ((wildcards: Substitution) => boolean)
 ];
 export declare type BoxedRuleSet = Set<BoxedRule>;
+export declare type ParametricDomainFunction = 'Function' | 'Union' | 'List' | 'Record' | 'Tuple' | 'Intersection' | 'Range' | 'Interval' | 'Optional' | 'Some' | 'Head' | 'Symbol' | 'Literal';
+export declare type ParametricDomain = [
+    ParametricDomainFunction,
+    ...DomainExpression[]
+];
+export declare type DomainExpression = string | ParametricDomain;
 /**
  * Domains can be defined as a union or intersection of domains:
  * - `["Union", "Number", "Boolean"]` A number or a boolean.
  * - `["SetMinus", "Number", 1]`  Any number except "1".
  *
  */
-export declare type DomainExpression = BoxedExpression;
+export interface Domain extends BoxedExpression {
+    isSubdomainOf(dom: Domain | string): boolean;
+    isMemberOf(expr: BoxedExpression): boolean;
+    readonly domainExpression: DomainExpression;
+    codomain: Domain | null;
+    readonly isNothing: boolean;
+    is(s: BoxedExpression): boolean;
+    readonly isBoolean: boolean;
+    readonly isNumeric: boolean;
+    readonly isFunction: boolean;
+    readonly isPredicate: boolean;
+    /**
+     * If true, when all the arguments are numeric, the result of the
+     * evaluation is numeric. Numeric is any value with a domain of `Number`.
+     *
+     * Example of numeric functions: `Add`, `Multiply`, `Power`, `Abs`
+     *
+     * Default: false
+     */
+    readonly isNumericFunction: boolean;
+    readonly isRealFunction: boolean;
+    /**
+     * If true, when all the arguments are boolean, the result of the
+     * evaluation is a boolean. Boolean is any value with a domain of `MaybeBoolean`.
+     *
+     * Example of logic functions: `And`, `Or`, `Not`, `Implies`
+     *
+     * **Default:** false
+     */
+    readonly isLogicOperator: boolean;
+    /**
+     * The function represent a relation between the first argument and
+     * the second argument, and evaluates to a boolean indicating if the relation
+     * is satisfied.
+     *
+     * For example, `Equal`, `Less`, `Approx`, etc...
+     *
+     * **Default:** false
+     */
+    readonly isRelationalOperator: boolean;
+}
 /**
  * Options to control the serialization to MathJSON when using `BoxedExpression.json`.
  */
@@ -216,7 +262,7 @@ export interface BoxedExpression {
      * @category Object Methods
      *
      */
-    is(rhs: any): boolean;
+    is(rhs: unknown): boolean;
     /** @internal */
     get hash(): number;
     /** An optional short description of the symbol or function head.
@@ -468,12 +514,6 @@ export interface BoxedExpression {
      *
      */
     get string(): string | null;
-    /** True if this domain is a subset of domain `d`
-     *
-     * @category Expression Properties
-     *
-     */
-    isSubsetOf(d: BoxedExpression | string): undefined | boolean;
     /** True if the value of this expression is a number.
      *
      * `isExtendedComplex || isNaN` = `isReal || isImaginary || isInfinity || isNaN`
@@ -693,11 +733,17 @@ export interface BoxedExpression {
      * first in commutative functions
      */
     get complexity(): number;
-    /** The domain of this expression, using the value of the expression,
-     * definitions associated with this expression and assumptions if necessary */
-    get domain(): BoxedExpression;
+    /** The domain of this expression. */
+    get domain(): Domain;
     /** Symbols that represent a variable, can have their domain modified */
-    set domain(domain: BoxedExpression | string);
+    set domain(domain: Domain | string);
+    /** The domain of the value of this expression, using the value of the expression,
+     * definitions associated with this expression and assumptions if necessary.
+     *
+     * For symbols, the `domain` and `valueDomain` are the same.  For functions,
+     * the `valueDomain` is the codomain of the function.
+     */
+    get valueDomain(): Domain;
     /** For symbols and functions, a possible definition associated with the expression */
     get functionDefinition(): BoxedFunctionDefinition | undefined;
     get symbolDefinition(): BoxedSymbolDefinition | undefined;
@@ -975,9 +1021,14 @@ export declare type BaseDefinition = {
      *
      * For symbols, this is the domain of their value.
      *
-     * For functions, this is the domain of their result (aka codomain)
+     * For functions, this is the signature of the function
+     *
+     * When `domain` is a handler, calculate the domain (or signature) based on
+     * the arguments (for expressions others than functions, `args` is an empty
+     * array). If the function cannot be applied to the arguments, return
+     * `null`.
      */
-    domain?: BoxedExpression | string;
+    domain?: Domain | DomainExpression | string | ((ce: IComputeEngine, args: BoxedExpression[]) => Domain | DomainExpression);
 };
 export declare type BoxedBaseDefinition = {
     name: string;
@@ -990,7 +1041,7 @@ export declare type BoxedBaseDefinition = {
      * This field is usually undefined, but its value is set by `getDefinition()`
      */
     scope: RuntimeScope | undefined;
-    domain?: BoxedExpression;
+    domain?: Domain | ((ce: IComputeEngine, args: BoxedExpression[]) => Domain | DomainExpression);
     _purge(): undefined;
 };
 /**
@@ -1053,34 +1104,6 @@ export declare type FunctionDefinitionFlags = {
      * **Default**: `false`
      */
     involution: boolean;
-    /**
-     * If true, when all the arguments are numeric, the result of the
-     * evaluation is numeric. Numeric is any value with a domain of `Number`.
-     *
-     * Example of numeric functions: `Add`, `Multiply`, `Power`, `Abs`
-     *
-     * Default: false
-     */
-    numeric: boolean;
-    /**
-     * If true, when all the arguments are boolean, the result of the
-     * evaluation is a boolean. Boolean is any value with a domain of `MaybeBoolean`.
-     *
-     * Example of logic functions: `And`, `Or`, `Not`, `Implies`
-     *
-     * **Default:** false
-     */
-    logic: boolean;
-    /**
-     * The function represent a relation between the first argument and
-     * the second argument, and evaluates to a boolean indicating if the relation
-     * is satisfied.
-     *
-     * For example, `Equal`, `Less`, `Approx`, etc...
-     *
-     * **Default:** false
-     */
-    relationalOperator: boolean;
     /** If true, the value of this function is always the same for a given
      * set of arguments and it has no side effects.
      *
@@ -1252,31 +1275,6 @@ export declare type FunctionDefinition = BaseDefinition & Partial<FunctionDefini
      *
      */
     N?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined;
-    /**
-     *
-     * Calculate the domain of the result, based on the value of the arguments.
-     *
-     * If the domain of the result is always the same, use the `domain` property
-     * instead.
-     *
-     * The argument `args` represent the arguments of the function.
-     *
-     * The return value is `null` if the input arguments cannot be handled by
-     * this definition.
-     *
-     * Otherwise, the return value is the domain of the result.
-     *
-     * Return `"Nothing"` if the arguments are acceptable, but the evaluation
-     * will fail, for example in some cases if there are missing arguments.
-     *
-     * This function is used to select the correct definition when there are
-     * multiple definitions for the same function name.
-     *
-     * For example it allows to distinguish between a `Add` function that
-     * applies to numbers and an `Add` function that applies to tensors.
-     *
-     */
-    evalDomain?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | string | null;
     /** Dimensional analysis
      * @experimental
      */
@@ -1295,7 +1293,6 @@ export declare type BoxedFunctionDefinition = BoxedBaseDefinition & FunctionDefi
     simplify?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined;
     evaluate?: BoxedLambdaExpression | ((ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined);
     N?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | undefined;
-    evalDomain?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression | string | null;
     evalDimension?: (ce: IComputeEngine, args: BoxedExpression[]) => BoxedExpression;
     sgn?: (ce: IComputeEngine, args: BoxedExpression[]) => -1 | 0 | 1 | undefined;
     compile?: (expr: BoxedExpression) => CompiledExpression;
@@ -1361,7 +1358,7 @@ export declare type SymbolDefinition = BaseDefinition & Partial<SymbolFlags> & P
      * `Pi`, the actual value depends on the `precision` setting of the
      * `ComputeEngine` */
     value?: LatexString | SemiBoxedExpression | ((ce: IComputeEngine) => SemiBoxedExpression | null);
-    domain?: string | BoxedExpression;
+    domain?: string | Domain;
 };
 export interface BoxedSymbolDefinition extends BoxedBaseDefinition, Partial<SymbolFlags>, SymbolDefinitionFlags {
     get value(): BoxedExpression | undefined;
@@ -1427,7 +1424,7 @@ export interface IComputeEngine {
     readonly iterationLimit: number;
     /** @experimental */
     readonly recursionLimit: number;
-    defaultDomain: null | BoxedExpression;
+    defaultDomain: null | Domain;
     /** {@inheritDoc  NumericMode} */
     numericMode: NumericMode;
     tolerance: number;
@@ -1452,7 +1449,7 @@ export interface IComputeEngine {
     /**
      * Return `undefined` if no definition exist for this `head.
      */
-    getFunctionDefinition(head: string, wikidata?: string): undefined | BoxedFunctionDefinition;
+    getFunctionDefinition(head: string, args?: BoxedExpression[]): undefined | BoxedFunctionDefinition;
     /**
      * Returned a boxed expression from the input.
      *
@@ -1466,7 +1463,7 @@ export interface IComputeEngine {
     /** Return a canonical boxed string */
     string(s: string, metadata?: Metadata): BoxedExpression;
     /** Return a canonical boxed domain */
-    domain(domain: BoxedExpression | string, metadata?: Metadata): BoxedExpression;
+    domain(domain: SemiBoxedExpression | Domain | string, metadata?: Metadata): Domain;
     /** Return a canonical expression.
      *
      * Note that the result may not be a function, or may have a different
@@ -1577,7 +1574,7 @@ export interface IComputeEngine {
      *
      *
      */
-    assume(symbol: LatexString | SemiBoxedExpression, domain: BoxedExpression): AssumeResult;
+    assume(symbol: LatexString | SemiBoxedExpression, domain: Domain): AssumeResult;
     assume(predicate: LatexString | SemiBoxedExpression): AssumeResult;
     assume(arg1: LatexString | SemiBoxedExpression, arg2?: BoxedExpression): AssumeResult;
     /** Remove all assumptions about one or more symbols */
@@ -1614,4 +1611,3 @@ export interface IComputeEngine {
     /** @internal */
     _unregister(expr: BoxedExpression): void;
 }
-export declare function getVars(expr: BoxedExpression): string[];

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

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.0 */
 export declare function boxRules(ce: IComputeEngine, rs: Iterable<Rule>): BoxedRuleSet;
 /**
  * Apply the rules in the ruleset and return a modified expression.

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

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.0 */
 /**
  * A set of simplification rules.
  *

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

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.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.5.0 */
+/* 0.6.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.5.0 */
+/* 0.6.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.5.0 */
+/* 0.6.0 */
 /**
  * Coefficient of a univariate (single variable) polynomial.
  *

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

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

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

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.0 */
 export declare class Sum {
     private engine;
     private _literal;

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

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.0 */
 /**
  * If expression is a product or a division, collect all the terms with a
  * negative exponents in the denominator, and all the terms

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

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

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

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.0 */
     /** A human readable string to annotate an expression, since JSON does not
      * allow comments in its encoding */
     comment?: string;

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

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.0 */
 /**
  * These constants are the 'primitive' functions and constants that are used
  * for some basic manipulations such as parsing, and transforming to canonical
@@ -53,6 +53,8 @@ export declare function headName(expr: Expression | null): string;
 export declare function op(expr: Expression | null, n: number): Expression | null;
 export declare function nops(expr: Expression): number;
 export declare function symbol(expr: Expression | null): string | null;
+export declare function string(expr: Expression | null): string | null;
+export declare function dictionary(expr: Expression | null): null | Record<string, Expression>;
 export declare function machineValue(expr: Expression | null): number | null;
 /**
  * Return a rational (numer over denom) representation of the expression,
@@ -77,9 +79,6 @@ export declare function applyRecursively(expr: Expression, fn: (x: Expression) =
  * Apply a function to the arguments of a function and return an array of T
  */
 export declare function mapArgs<T>(expr: Expression, fn: (x: Expression) => T): T[];
-export declare function dictionary(expr: Expression): {
-    [key: string]: Expression;
-} | null;
 /**
  * Return num as a number if it's a valid JSON number (that is
  * a valid JavaScript number but not NaN or +/-Infinity) or

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

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.6.0 */
 export { isAtomic, isSymbolObject, isStringObject, isFunctionObject, isDictionaryObject, stringValue as getStringValue, head, headName, symbol, tail, applyRecursively, mapArgs, op, nops, dictionary as getDictionary, asValidJSONNumber, } 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.5.0";
+export declare const version = "0.6.0";