@cortex-js/compute-engine 0.4.4 → 0.5.0

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

@@ -1,4 +1,4 @@
-/* 0.4.4 */
+/* 0.5.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/order.d.ts

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

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

@@ -1,4 +1,4 @@
-/* 0.4.4 */
+/* 0.5.0 */
 import Decimal from 'decimal.js';
 import { Expression } from '../../math-json/math-json-format';
 import { BoxedExpression, IComputeEngine, Metadata } from '../public';

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

@@ -1,4 +1,4 @@
-/* 0.4.4 */
+/* 0.5.0 */
 export declare function isLatexString(s: any): s is string;
 export declare function latexString(s: any): string | null;
 /**

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

@@ -1,33 +1,62 @@
-/* 0.4.4 */
-import { DictionaryCategory, LatexDictionaryEntry, LatexString, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
-import { Decimal } from 'decimal.js';
+/* 0.5.0 */
 import { Complex } from 'complex.js';
+import { Expression, MathJsonNumber } from '../math-json/math-json-format';
 import { SignalMessage, WarningSignal } from '../common/signals';
+import type { DictionaryCategory, LatexDictionaryEntry, LatexString, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
 import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefinition, IComputeEngine, Dictionary, ExpressionMapInterface, NumericMode as NumericMode, Pattern, RuntimeScope, Scope, SemiBoxedExpression, Substitution, SymbolDefinition, BoxedRuleSet, Rule, JsonSerializationOptions, ComputeEngineStats, Metadata } from './public';
 /**
- * Create a `CustomEngine` instance to customize its behavior and the syntax
- * and operation dictionaries it uses.
  *
- * The constructor of `ComputeEngine` will compile and optimize the dictionary
- * upfront.
+ * To use the CortexJS Compute Engine, create a `ComputeEngine` instance.
+ *
+ * Use the instance to create expressions with `ce.parse()` and `ce.box()`.
+ *
+ *
+ * ```ts
+ * const ce = new ComputeEngine();
+ * let expr = ce.parse("e^{i\\pi}");
+ * console.log(expr.N().latex);
+ * // ➔ "-1"
+ *
+ * expr = ce.box(["Expand", ["Power", ["Add", "a", "b"], 2]]);
+ * console.log(expr.evaluate().latex);
+ * // ➔ "a^2 +  2ab + b^2"
+ *
+ * ```
  */
 export declare class ComputeEngine implements IComputeEngine {
+    /** @internal */
     readonly ZERO: BoxedExpression;
+    /** @internal */
     readonly ONE: BoxedExpression;
+    /** @internal */
     readonly TWO: BoxedExpression;
+    /** @internal */
     readonly HALF: BoxedExpression;
+    /** @internal */
     readonly NEGATIVE_ONE: BoxedExpression;
+    /** @internal */
     readonly I: BoxedExpression;
+    /** @internal */
     readonly NAN: BoxedExpression;
+    /** @internal */
     readonly POSITIVE_INFINITY: BoxedExpression;
+    /** @internal */
     readonly NEGATIVE_INFINITY: BoxedExpression;
+    /** @internal */
     readonly COMPLEX_INFINITY: BoxedExpression;
+    /** @internal */
     DECIMAL_NAN: Decimal;
+    /** @internal */
     DECIMAL_ZERO: Decimal;
+    /** @internal */
     DECIMAL_ONE: Decimal;
+    /** @internal */
     DECIMAL_TWO: Decimal;
+    /** @internal */
     DECIMAL_HALF: Decimal;
+    /** @internal */
     DECIMAL_PI: Decimal;
+    /** @internal */
     DECIMAL_NEGATIVE_ONE: Decimal;
     private _precision;
     private _numericMode;
@@ -49,14 +78,18 @@ export declare class ComputeEngine implements IComputeEngine {
     /**
      * The current scope.
      *
-     * A scope is a dictionary that contains the definition of local symbols.
+     * A **scope** stores the definition of symbols and assumptions.
      *
      * Scopes form a stack, and definitions in more recent
      * scopes can obscure definitions from older scopes.
      *
+     * The `ce.context` property represents the current scope.
+     *
      */
     context: RuntimeScope;
-    /** Absolute time beyond which evaluation should not proceed */
+    /** Absolute time beyond which evaluation should not proceed.
+     * @internal
+     */
     deadline?: number;
     /**
      * Return dictionaries suitable for the specified categories, or `"all"`
@@ -68,18 +101,29 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     static getDictionaries(categories?: DictionaryCategory[] | 'all'): Readonly<Dictionary>[];
     /**
-     * Construct a new `ComputeEngine` environment.
-     *
-     * If no `options.dictionaries` is provided a default set of dictionaries
-     * is used.
+     * Construct a new `ComputeEngine` instance.
      *
-     * The `ComputeEngine.getDictionaries()` method can be called
-     * to access a subset of dictionaries, e.g. for arithmetic, calculus, etc...
+     * Dictionaries define functions and symbols (in `options.dictionaries`) and
+     * the LaTeX syntax (in `options.latexDictionaries`). If no dictionaries
+     * are provided, the default ones are used.
      *
      * The order of the dictionaries matter: the definitions from the later ones
      * override the definitions from earlier ones. The first dictionary should
      * be the `'core'` dictionary which include some basic definitions such
      * as domains (`Boolean`, `Number`, etc...) that are used by later dictionaries.
+     *
+     * @param options.numericMode The default mode is `auto`. Use `machine` to only
+     * use 64-bit float, use `decimal` to always use arbitrary precision floating
+     * point numbers or `complex` for complex numbers.
+     *
+     * @param options.numericPrecision Specific how many digits of precision for the
+     * numeric calculations. Default is 100.
+     *
+     * @param options.tolerance If the absolute value of the difference of two numbers
+     * is less than `toleranc`, they are considered equal. Used by `chop()` as well.
+     *
+     * @param options.defaultDomain If an unknown symbol is encountered, assume it should
+     * be a variable in this domain. **Default** `ExtendedRealNumber`
      */
     constructor(options?: {
         dictionaries?: Readonly<Dictionary>[];
@@ -95,15 +139,21 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      * This needs to happen for example when the numeric precision changes.
      *
+     * @internal
      */
     purge(): void;
+    /** @internal */
     _register(expr: BoxedExpression): void;
+    /** @internal */
     _unregister(expr: BoxedExpression): void;
     get stats(): ComputeEngineStats;
+    /** @internal */
     _decimal: Decimal.Constructor;
+    /** @internal */
     decimal: (a: Decimal.Value) => Decimal;
+    /** @internal */
     complex: (a: number | Complex, b?: number) => Complex;
-    /** The precision, or number of significant digits, for numerical calculations
+    /** The precision, or number of significant digits, for numeric calculations
      * such as when calling `ce.N()`.
      *
      * To  make calculations using more digits, at the cost of expended memory
@@ -114,24 +164,22 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     get precision(): number;
     set precision(p: number | 'machine');
-    /**
-     * Mode to use for numerical calculations:
-     *
-     * - `auto`:  use machine number if the precision is 15 or less, Decimal
-     * otherwise. Complex numbers are allowed.
-     * - `number`: use the machine format (64-bit float, 52-bit mantissa, about
-     * 15 digits of precision).
-     * - `decimal`: arbitrary precision floating-point numbers, as provided by the
-     * "decimal.js" library
-     * - `complex`: machine and complex numbers: two 64-bit float, as provided by the
-     * "complex.js" library
-     *
-     */
     get numericMode(): NumericMode;
     set numericMode(f: NumericMode);
+    /** @experimental */
     get timeLimit(): number;
+    /** @experimental */
     get iterationLimit(): number;
+    /** @experimental */
     get recursionLimit(): number;
+    /**
+     * If an unknown symbol is encountered, assume it should
+     * be a variable in this domain.
+     *
+     * If set to `null`, unknown symbols will trigger an error.
+     *
+     * **Default:** `"ExtendedRealNumber"`
+     */
     get defaultDomain(): BoxedExpression | null;
     set defaultDomain(domain: BoxedExpression | string | null);
     /**
@@ -141,6 +189,10 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     get tolerance(): number;
     set tolerance(val: number);
+    /** Replace a number that is close to 0 with the exact integer 0.
+     *
+     * How close to 0 the number has to be to be considered 0 is determined by {@link tolerance}.
+     */
     chop(n: number): number;
     chop(n: Decimal): Decimal | 0;
     chop(n: Complex): Complex | 0;
@@ -185,8 +237,11 @@ export declare class ComputeEngine implements IComputeEngine {
      * This can occur if:
      * - an error has been signaled
      * - the time limit or memory limit has been exceeded
+     *
+     * @internal
      */
     shouldContinueExecution(): boolean;
+    /** @internal */
     checkContinueExecution(): void;
     assert(condition: boolean, expr: BoxedExpression, msg: string, code?: SignalMessage): void;
     /**
@@ -201,9 +256,11 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     signal(expr: BoxedExpression, msg: string, code?: SignalMessage): void;
     signal(sig: WarningSignal): void;
+    /** @internal */
     cache<T>(cacheName: string, build: () => T, purge: (T: any) => T | undefined): T;
     box(expr: Decimal | Complex | [num: number, denom: number] | SemiBoxedExpression): BoxedExpression;
     fn(head: string, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
+    /** @internal */
     _fn(head: string | BoxedExpression, ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     error(val: BoxedExpression, message: string, messageArg: SemiBoxedExpression): BoxedExpression;
     add(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
@@ -220,8 +277,8 @@ export declare class ComputeEngine implements IComputeEngine {
     number(value: number | MathJsonNumber | Decimal | Complex | [num: number, denom: number], metadata?: Metadata): BoxedExpression;
     rules(rules: Rule[]): BoxedRuleSet;
     pattern(expr: LatexString | SemiBoxedExpression): Pattern;
-    parse(s: null): null;
     parse(s: LatexString | string): BoxedExpression;
+    parse(s: null): null;
     parse(s: LatexString | string | null): null | BoxedExpression;
     serialize(x: Expression | BoxedExpression): string;
     get latexOptions(): NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions;
@@ -238,19 +295,6 @@ export declare class ComputeEngine implements IComputeEngine {
      * ```
      */
     ask(pattern: LatexString | SemiBoxedExpression): Substitution[];
-    /**
-     * Add an assumption.
-     *
-     * Return `contradiction` if the new assumption is incompatible with previous
-     * ones.
-     *
-     * Return `tautology` if the new assumption is redundant with previous ones.
-     *
-     * Return `ok` if the assumption was successfully added to the assumption set.
-     *
-     * Note that the assumption is put into canonical form before being added.
-     *
-     */
     assume(symbol: LatexString | SemiBoxedExpression, domain: string | BoxedExpression): AssumeResult;
     assume(predicate: LatexString | SemiBoxedExpression): AssumeResult;
     forget(symbol: undefined | string | string[]): void;

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

@@ -1,3 +1,3 @@
-/* 0.4.4 */
+/* 0.5.0 */
 export declare function costFunction(expr: BoxedExpression): number;
 export declare const DEFAULT_COST_FUNCTION: typeof costFunction;

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

@@ -1,4 +1,4 @@
-/* 0.4.4 */
+/* 0.5.0 */
 /** The canonical form of `Add`:
  * - removes `0`
  * - adds up small integers and rational numbers

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

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

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

@@ -1,4 +1,4 @@
-/* 0.4.4 */
+/* 0.5.0 */
 /** The canonical form of `Multiply`:
  * - remove `1`
  * - combine literal small integers and rationals

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

@@ -1,4 +1,4 @@
-/* 0.4.4 */
+/* 0.5.0 */
 /**
  *
  * Return `null` if there is no canonicalization necessary and the result is

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

@@ -1,2 +1,2 @@
-/* 0.4.4 */
+/* 0.5.0 */
 export declare const ARITHMETIC_DICTIONARY: Dictionary[];

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

@@ -1,2 +1,2 @@
-/* 0.4.4 */
+/* 0.5.0 */
 export declare const COLLECTIONS_DICTIONARY: Dictionary;

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

@@ -1,2 +1,2 @@
-/* 0.4.4 */
+/* 0.5.0 */
 export declare const CORE_DICTIONARY: Dictionary[];

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

@@ -1,4 +1,4 @@
-/* 0.4.4 */
+/* 0.5.0 */
 import { IComputeEngine, Dictionary } from '../public';
 export declare function getDefaultDictionaries(categories?: DictionaryCategory[] | 'all'): Readonly<Dictionary>[];
 export declare const DICTIONARIES: {

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

@@ -1,2 +1,2 @@
-/* 0.4.4 */
+/* 0.5.0 */
 export declare const LOGIC_DICTIONARY: Dictionary;

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

@@ -1,2 +1,2 @@
-/* 0.4.4 */
+/* 0.5.0 */
 export declare const POLYNOMIALS_DICTIONARY: Dictionary[];

package/dist/types/compute-engine/dictionary/relational-operator.d.ts

@@ -1,2 +1,2 @@
-/* 0.4.4 */
+/* 0.5.0 */
 export declare const RELOP_DICTIONARY: Dictionary;

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

@@ -1,2 +1,2 @@
-/* 0.4.4 */
+/* 0.5.0 */
 export declare const SETS_DICTIONARY: Dictionary;

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

@@ -1,2 +1,2 @@
-/* 0.4.4 */
+/* 0.5.0 */
 export declare const TRIGONOMETRY_DICTIONARY: Dictionary[];

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

@@ -1,4 +1,4 @@
-/* 0.4.4 */
+/* 0.5.0 */
 import { Decimal } from 'decimal.js';
 import { BoxedExpression } from './public';
 /** Quickly determine the numeric domain of a number or constant

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

@@ -1,2 +1,2 @@
-/* 0.4.4 */
+/* 0.5.0 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.4.4 */
+/* 0.5.0 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.4.4 */
+/* 0.5.0 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

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

@@ -1,4 +1,4 @@
-/* 0.4.4 */
+/* 0.5.0 */
 import { LatexDictionary, Serializer } from '../public';
 export declare function serializeLatex(serializer: Serializer, expr: Expression | null): string;
 export declare const DEFINITIONS_CORE: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.4.4 */
+/* 0.5.0 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.4.4 */
+/* 0.5.0 */
 export declare const DEFINITIONS_LOGIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.4.4 */
+/* 0.5.0 */
 export declare const DEFINITIONS_OTHERS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.4.4 */
+/* 0.5.0 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.4.4 */
+/* 0.5.0 */
 export declare const DEFINITIONS_SYMBOLS: LatexDictionary;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.4.4 */
+/* 0.5.0 */
 import { WarningSignal } from '../../../common/signals';
 export declare type CommonEntry = {
     name?: string;

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

@@ -1,4 +1,4 @@
-/* 0.4.4 */
+/* 0.5.0 */
 import { Serializer } from './serializer';
 import { Expression } from '../../math-json/math-json-format';
 import { WarningSignalHandler } from '../../common/signals';

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

@@ -1,4 +1,4 @@
-/* 0.4.4 */
+/* 0.5.0 */
 import { ParseLatexOptions, LatexToken, NumberFormattingOptions, Delimiter, Terminator, Parser } from './public';
 import { IndexedLatexDictionary, InfixEntry, PostfixEntry, PrefixEntry, SymbolEntry } from './dictionary/definitions';
 import { WarningSignalHandler } from '../../common/signals';

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

@@ -1,4 +1,4 @@
-/* 0.4.4 */
+/* 0.5.0 */
 import { Expression } from '../../math-json/math-json-format';
 import type { IComputeEngine } from '../public';
 /**
@@ -13,7 +13,11 @@ export declare type LatexToken = string | '<{>' | '<}>' | '<space>' | '<$>' | '<
  * `\frac{\pi}{2}`
  */
 export declare type LatexString = string;
-export declare type Delimiter = ')' | '(' | ']' | '[' | '{' | '<' | '>' | '}' | '|' | '||' | '\\lceil' | '\\lfloor' | '\\rceil' | '\\rfloor';
+/**
+ * Open and close delimiters that can be used with {@link MatchfixEntry}
+ * record to define new LaTeX dictionary entries.
+ */
+export declare type Delimiter = ')' | '(' | ']' | '[' | '{' /** \lbrace */ | '}' /** \rbrace */ | '<' /** \langle  */ | '>' /** \rangle  */ | '|' | '||' | '\\lceil' | '\\rceil' | '\\lfloor' | '\\rfloor';
 export declare type DictionaryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collections' | 'combinatorics' | 'core' | 'dimensions' | 'domains' | 'linear-algebra' | 'logic' | 'numeric' | 'other' | 'physics' | 'polynomials' | 'relop' | 'sets' | 'statistics' | 'symbols' | 'trigonometry' | 'units';
 /**
  * This indicates a condition under which parsing should stop:
@@ -108,11 +112,11 @@ export declare type InfixEntry = BaseEntry & {
     /**
      * Infix position, with an operand before and an operand after: `a ⊛ b`.
      *
-     *      Example: `+`, `\times`
+     * Example: `+`, `\times`.
      */
     kind: 'infix';
     /**
-     * - **`both`**: a + b + c -> +(a, b, c)
+     * - **`both`**: a + b + c  +(a, b, c)
      * - **`left`**: a / b / c -> /(/(a, b), c)
      * - **`right`**: a = b = c -> =(a, =(b, c))
      * - **`non`**: a < b < c -> syntax error
@@ -131,7 +135,7 @@ export declare type PostfixEntry = BaseEntry & {
     /**
      * Postfix position, with an operand before: `a ⊛`
      *
-     *      Example: `!`
+     * Example: `!`.
      */
     kind: 'postfix';
     precedence?: number;
@@ -141,22 +145,23 @@ export declare type PrefixEntry = BaseEntry & {
     /**
      * Prefix position, with an operand after: `⊛ a`
      *
-     *      Example: `-`, `\not`
+     * Example: `-`, `\not`.
      */
     kind: 'prefix';
     precedence: number;
     parse: PrefixParseHandler;
 };
+/**
+ * A LaTeX dictionary entry for an environment, that is a LaTeX
+ * construct using `\begin{...}...\end{...}`.
+ */
 export declare type EnvironmentEntry = BaseEntry & {
-    /**
-     * The name of an environment, as used in `\begin{matrix}` where
-     * `"matrix"` is the name of the environment.
-     */
     kind: 'environment';
     parse: EnvironmentParseHandler;
 };
 export declare type SymbolEntry = BaseEntry & {
     kind: 'symbol';
+    /** Used for appropriate wrapping (i.e. when to surround it with parens) */
     precedence?: number;
     /**
      * Indicate if this symbol can be followed by arguments.
@@ -207,6 +212,9 @@ export declare type SymbolEntry = BaseEntry & {
     requiredLatexArg?: number;
     parse: Expression | SymbolParseHandler;
 };
+/**
+ * A simple LaTeX dictionary entry, for example for a command like `\pi`.
+ */
 export declare type DefaultEntry = BaseEntry & {
     precedence?: number;
     arguments?: 'group' | 'implicit' | '';
@@ -215,11 +223,17 @@ export declare type DefaultEntry = BaseEntry & {
     parse?: Expression | SymbolParseHandler;
 };
 export declare type LatexDictionaryEntry = DefaultEntry | MatchfixEntry | InfixEntry | PostfixEntry | PrefixEntry | SymbolEntry | EnvironmentEntry;
+/** @internal */
 export declare function isSymbolEntry(entry: LatexDictionaryEntry): entry is SymbolEntry;
+/** @internal */
 export declare function isMatchfixEntry(entry: LatexDictionaryEntry): entry is MatchfixEntry;
+/** @internal */
 export declare function isInfixEntry(entry: LatexDictionaryEntry): entry is InfixEntry;
+/** @internal */
 export declare function isPrefixEntry(entry: LatexDictionaryEntry): entry is PrefixEntry;
+/** @internal */
 export declare function isPostfixEntry(entry: LatexDictionaryEntry): entry is PostfixEntry;
+/** @internal */
 export declare function isEnvironmentEntry(entry: LatexDictionaryEntry): entry is EnvironmentEntry;
 export declare type LatexDictionary = LatexDictionaryEntry[];
 export declare type ParseLatexOptions = {
@@ -284,7 +298,13 @@ export declare type ParseLatexOptions = {
     parseUnknownToken: (token: LatexToken, parser: Parser) => 'symbol' | 'function' | 'skip' | 'error';
     /**
      * If true, the expression will be decorated with the LaTeX
-     * fragments corresponding to each elements of the expression
+     * fragments corresponding to each elements of the expression.
+     *
+     * The top-level expression, that is the one returned by `parse()`, will
+     * include the verbatim LaTeX input that was parsed. The sub-expressions
+     * may contain a slightly different LaTeX, for example with consecutive spaces
+     * replaced by one, with comments removed and with some low-level LaTeX
+     * commands replaced, for example `\egroup` and `\bgroup`.
      */
     preserveLatex: boolean;
 };
@@ -447,7 +467,7 @@ export interface Parser {
     readonly atEnd: boolean;
     /** Return the next token, without advancing the index */
     readonly peek: LatexToken;
-    /** Return true if the terminator conditin is met */
+    /** Return true if the terminator condition is met */
     atTerminator(t: Terminator): boolean;
     /** Return an array of string corresponding to tokens ahead.
      * The index is unchanged.
@@ -516,16 +536,22 @@ export interface Parser {
     matchMiddleDelimiter(delimiter: '|' | ':' | LatexToken): boolean;
     matchSupsub(lhs: Expression | null): Expression | null;
     /**
-     * <primary> :=
-     * (<number> | <symbol> | <latex-command> | <function-call> | <matchfix-expr>)
-     * (<subsup> | <postfix-operator>)*
-     *
-     * <matchfix-expr> :=
-     *  <matchfix-op-open> <expression> <matchfix-op-close>
      *
-     * <function-call> ::=
-     *  | <function><matchfix-op-group-open><expression>[',' <expression>]<matchfix-op-group-close>
+     * ```
+     *    <primary> :=
+     *       (<number> | <symbol> | <latex-command> | <function-call> | <matchfix-expr>)
+     *       (<subsup> | <postfix-operator>)*
+     * ```
      *
+     * ```
+     *    <matchfix-expr> :=
+     *        <matchfix-op-open> <expression> <matchfix-op-close>
+     *```
+     *
+     *```
+     *    <function-call> ::=
+     *      | <function><matchfix-op-group-open><expression>[',' <expression>]<matchfix-op-group-close>
+     *```
      * If not a primary, return `null` and do not advance the index.
      */
     matchPrimary(): Expression | null;

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

@@ -1,4 +1,4 @@
-/* 0.4.4 */
+/* 0.5.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.4.4 */
+/* 0.5.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,15 +1,13 @@
-/* 0.4.4 */
+/* 0.5.0 */
 import { NumberFormattingOptions, LatexString, SerializeLatexOptions } from './public';
 import { IndexedLatexDictionary, SymbolEntry } from './dictionary/definitions';
 import { WarningSignalHandler } from '../../common/signals';
-import { IComputeEngine } from '../public';
 export declare class Serializer {
     readonly onError: WarningSignalHandler;
     options: NumberFormattingOptions & SerializeLatexOptions;
-    readonly computeEngine?: IComputeEngine;
     readonly dictionary: IndexedLatexDictionary;
     level: number;
-    constructor(options: NumberFormattingOptions & SerializeLatexOptions, dictionary: IndexedLatexDictionary, computeEngine: undefined | IComputeEngine, onError: WarningSignalHandler);
+    constructor(options: NumberFormattingOptions & SerializeLatexOptions, dictionary: IndexedLatexDictionary, onError: WarningSignalHandler);
     updateOptions(opt: Partial<NumberFormattingOptions> & Partial<SerializeLatexOptions>): void;
     /**
      * Serialize the expression, and if the expression is an operator

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

@@ -1,4 +1,4 @@
-/* 0.4.4 */
+/* 0.5.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.4.4 */
+/* 0.5.0 */
 export declare function gamma(c: Complex): Complex;
 export declare function lngamma(c: Complex): Complex;