@cortex-js/compute-engine 0.14.0 → 0.16.0

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

@@ -1,8 +1,8 @@
-/* 0.14.0 */
+/* 0.16.0 */
 import { Complex } from 'complex.js';
 import { Expression, MathJsonNumber } from '../math-json/math-json-format';
-import type { LibraryCategory, LatexDictionary, LatexDictionaryEntry, LatexString, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
-import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefinition, IComputeEngine, IdTable, ExpressionMapInterface, NumericMode, Pattern, RuntimeScope, Scope, SemiBoxedExpression, SymbolDefinition, BoxedRuleSet, Rule, JsonSerializationOptions, ComputeEngineStats, Metadata, BoxedDomain, DomainExpression, FunctionDefinition, Rational, BoxedSubstitution, Substitution } from './public';
+import type { LibraryCategory, LatexDictionaryEntry, LatexString, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
+import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefinition, IComputeEngine, IdentifierDefinitions, ExpressionMapInterface, NumericMode, Pattern, RuntimeScope, Scope, SemiBoxedExpression, SymbolDefinition, BoxedRuleSet, Rule, JsonSerializationOptions, ComputeEngineStats, Metadata, BoxedDomain, DomainExpression, FunctionDefinition, Rational, BoxedSubstitution, AssignValue } from './public';
 /**
  *
  * To use the CortexJS Compute Engine, create a `ComputeEngine` instance.
@@ -93,8 +93,6 @@ export declare class ComputeEngine implements IComputeEngine {
     private _commonNumbers;
     /** @internal */
     private _commonDomains;
-    /** @internal */
-    private _latexDictionary?;
     /**
      * The current scope.
      *
@@ -121,19 +119,20 @@ export declare class ComputeEngine implements IComputeEngine {
      * manipulate them.
      *
      */
-    static getStandardLibrary(categories?: LibraryCategory[] | LibraryCategory | 'all'): Readonly<IdTable>[];
+    static getStandardLibrary(categories?: LibraryCategory[] | LibraryCategory | 'all'): readonly IdentifierDefinitions[];
     /**
      * Construct a new `ComputeEngine` instance.
      *
      * Identifier tables define functions and symbols (in `options.ids`).
-     * If no table is provided the standard library is used (`ComputeEngine.getStandardLibrary()`)
+     * If no table is provided the MathJSON Standard Library is used (`ComputeEngine.getStandardLibrary()`)
      *
      * The LaTeX syntax dictionary is defined in `options.latexDictionary`.
      *
      * 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.
+     * as domains (`Booleans`, `Numbers`, etc...) that are used by later
+     * dictionaries.
      *
      * @param options.numericMode The default mode is `"auto"`. Use `"machine"`
      * to perform numeric calculations using 64-bit floats. Use `"bignum"` to
@@ -148,13 +147,12 @@ export declare class ComputeEngine implements IComputeEngine {
      * `chop()` as well.
      *
      * @param options.defaultDomain If an unknown symbol is encountered, assume
-     * this is its domain. **Default** `ExtendedRealNumber`
+     * this is its domain. **Default** `ExtendedRealNumbers`
      */
     constructor(options?: {
         numericMode?: NumericMode;
         numericPrecision?: number;
-        ids?: Readonly<IdTable>[];
-        latexDictionary?: readonly LatexDictionaryEntry[];
+        ids?: readonly IdentifierDefinitions[];
         tolerance?: number;
         defaultDomain?: string;
     });
@@ -202,7 +200,7 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      * If set to `null`, unknown symbols will trigger an error.
      *
-     * **Default:** `"ExtendedRealNumber"`
+     * **Default:** `"ExtendedRealNumbers"`
      */
     get defaultDomain(): BoxedDomain | null;
     set defaultDomain(domain: BoxedDomain | string | null);
@@ -225,7 +223,7 @@ export declare class ComputeEngine implements IComputeEngine {
     isBignum(a: unknown): a is Decimal;
     isComplex(a: unknown): a is Complex;
     private get latexSyntax();
-    static getLatexDictionary(domain?: LibraryCategory | 'all'): Readonly<LatexDictionary>;
+    static getLatexDictionary(domain?: LibraryCategory | 'all'): readonly Readonly<object>[];
     set costFunction(fn: ((expr: BoxedExpression) => number) | undefined);
     get costFunction(): (expr: BoxedExpression) => number;
     /**
@@ -248,21 +246,57 @@ export declare class ComputeEngine implements IComputeEngine {
      * Add (or replace) a definition for a symbol in the current scope.
      */
     defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
+    _defineSymbol(name: string, def: SymbolDefinition): BoxedSymbolDefinition;
     defineFunction(name: string, def: FunctionDefinition): BoxedFunctionDefinition;
+    _defineFunction(name: string, def: FunctionDefinition): BoxedFunctionDefinition;
     /**
      *
      * Create a new scope and add it to the top of the scope stack
      *
-     * The `options.scope` property can be used to specify custom precision,
+     * The `scope` argument can be used to specify custom precision,
      * etc... for this scope
      *
+     *
      */
-    pushScope(ids?: Readonly<IdTable> | Readonly<IdTable>[], scope?: Partial<Scope>): void;
+    pushScope(scope?: Partial<Scope>): IComputeEngine;
     /** Remove the topmost scope from the scope stack.
      */
-    popScope(): void;
-    set(identifiers: Substitution<SemiBoxedExpression | null | undefined>): void;
-    let(identifiers: IdTable): void;
+    popScope(): IComputeEngine;
+    swapScope(scope: RuntimeScope | null): RuntimeScope | null;
+    _printScope(options?: {
+        details?: boolean;
+    }, scope?: RuntimeScope | null, depth?: number): RuntimeScope | null;
+    /**
+     * Declare one or more identifiers:
+     *
+     * associate an identifier with a definition, at minimum a domain, optionally
+     * a value and some other flags.
+     */
+    declare(id: string, def: DomainExpression | SymbolDefinition | FunctionDefinition): IComputeEngine;
+    declare(identifiers: {
+        [id: string]: DomainExpression | SymbolDefinition | FunctionDefinition;
+    }): IComputeEngine;
+    /**
+     * Assign a value to one or more identifiers.
+     *
+     * Domain of value must be compatible with existing domain.
+     *
+     * Declare identifier if it hasn't been declared yet.
+     *
+     */
+    assign(id: string, value: AssignValue): IComputeEngine;
+    assign(ids: {
+        [id: string]: AssignValue;
+    }): IComputeEngine;
+    /**
+     * Same as assign(), but for internal use:
+     * - skips validity checks
+     * - does not auto-declare
+     * - if assigning to a function, must pass a JS function
+     *
+     * @internal
+     */
+    _assign(id: string, value: AssignValue): IComputeEngine;
     get assumptions(): ExpressionMapInterface<boolean>;
     /**
      * Return false if the execution should stop.
@@ -319,7 +353,9 @@ export declare class ComputeEngine implements IComputeEngine {
     parse(latex: LatexString | string | null, options?: {
         canonical?: boolean;
     }): null | BoxedExpression;
-    serialize(x: Expression | BoxedExpression): string;
+    serialize(x: Expression | BoxedExpression, options?: {
+        canonical?: boolean;
+    }): string;
     get latexOptions(): NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions;
     set latexOptions(opts: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>);
     get jsonSerializationOptions(): Readonly<JsonSerializationOptions>;
@@ -329,14 +365,12 @@ export declare class ComputeEngine implements IComputeEngine {
      * Return a list of all the assumptions that match a pattern.
      *
      * ```js
-     *  ce.assume(x, 'PositiveInteger');
+     *  ce.assume(['Element', 'x', 'PositiveIntegers');
      *  ce.ask(['Greater', 'x', '_val'])
      *  //  -> [{'val': 0}]
      * ```
      */
-    ask(pattern: LatexString | SemiBoxedExpression): BoxedSubstitution[];
-    infer(symbol: BoxedExpression | string, _domain: BoxedDomain | DomainExpression): AssumeResult;
-    assume(symbol: LatexString | SemiBoxedExpression, domainValue: BoxedDomain | Expression | BoxedExpression): AssumeResult;
-    assume(predicate: LatexString | SemiBoxedExpression): AssumeResult;
+    ask(pattern: SemiBoxedExpression): BoxedSubstitution[];
+    assume(predicate: SemiBoxedExpression): AssumeResult;
     forget(symbol: undefined | string | string[]): void;
 }

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

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

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

@@ -1,24 +1,9 @@
-/* 0.14.0 */
+/* 0.16.0 */
 import { Decimal } from 'decimal.js';
-import { BoxedExpression, Rational } from './public';
+import { DomainLiteral, Rational, SemiBoxedExpression } from './public';
 /** Quickly determine the numeric domain of a number or constant
  * For the symbols, this is a hard-coded optimization that doesn't rely on the
  * dictionaries. The regular path is in `internalDomain()`
  */
-export declare function inferNumericDomain(value: number | Decimal | Complex | Rational): string;
-/**
- * Simple description of a numeric domain as a base domain, a min and
- * max value, possibly open ends, and some excluded values.
- */
-export type NumericDomainInfo = {
-    domain?: string;
-    min?: number;
-    max?: number;
-    open?: 'left' | 'right' | 'both';
-    /** Values from _excludedValues_ are considered not in this domain */
-    excludedValues?: number[];
-    /** If defined, the values in this domain must follow the relation
-     * _period_ * _n_ + _phase_ when _n_ is in _domain_.
-     */
-    multiple?: [period: number, domain: BoxedExpression, phase: number];
-};
+export declare function inferNumericDomain(value: number | Decimal | Complex | Rational): DomainLiteral;
+export declare function inferDomain(expr: SemiBoxedExpression): DomainLiteral;

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

@@ -0,0 +1,84 @@
+/* 0.16.0 */
+/**
+ * From an expression, create an iterator that can be used
+ * to enumerate values.
+ *
+ * `expr` can be a collection, a function, an expression, a string.
+ *
+ * - ["Range", 5]
+ * - ["List", 1, 2, 3]
+ * - "'hello world'"
+ *
+ */
+export declare function iterable(expr: BoxedExpression): Iterator<BoxedExpression> | undefined;
+/**
+ * indexable(expr) return a JS function with one argument.
+ *
+ * Evaluate expr.
+ * If expr is indexable function (def with at handler), return handler.
+ * Otherwise, call makeLambda, then return function that set scope
+ * with one arg, then evaluate result of makeLambda.
+ */
+export declare function indexable(expr: BoxedExpression): ((index: number) => BoxedExpression | undefined) | undefined;
+/**
+ * From an expression, return a predicate function, which can be used to filter.
+ */
+export declare function predicate(_expr: BoxedExpression): (...args: BoxedExpression[]) => boolean;
+/**
+ * From an expression, create an ordering function, which can be used to sort.
+ */
+export declare function order(_expr: BoxedExpression): (a: BoxedExpression, b: BoxedExpression) => -1 | 0 | 1;
+/**
+ * Given an expression, rewrite it to a canonical Function form.
+ *
+ *
+ * - explicit parameters (no change)
+ *      ["Function", ["Add, "x", 1], "x"]
+ *      -> ["Function", ["Add, "x", 1], "x"]
+ *
+ * - single anonymous parameters:
+ *      ["Add", "_", 1]
+ *      -> ["Function", ["Add", "_", 1], "_"]
+ *
+ * - multiple anonymous parameters:
+ *      ["Add", "_1", "_2"]
+ *      -> ["Function", ["Add", "_1", "_2"], "_1", "_2"]
+ *
+ */
+export declare function canonicalFunctionExpression(expr: BoxedExpression): BoxedExpression | undefined;
+/**
+ * Apply arguments to an expression which is either
+ * - a '["Function"]' expression
+ * - an expression with anonymous parameters, e.g. ["Add", "_", 1]
+ * - the identifier for a function, e.g. "Sin".
+ */
+export declare function apply(fn: BoxedExpression, args: BoxedExpression[]): BoxedExpression;
+/**
+ * Return a lambda function, assuming a scoped environment has been
+ * created and there is a single numeric argument
+ */
+export declare function makeLambdaN1(expr: BoxedExpression): ((arg: number) => number) | undefined;
+/**
+ * Given an expression such as:
+ * - ["Function", ["Add", 1, "x"], "x"]
+ * - ["Function", ["Divide", "_", 2]]
+ * - ["Multiply, "_", 3]
+ * - ["Add, "_1", "_2"]
+ * - "Sin"
+ *
+ * return a JS function that can be called with arguments.
+ */
+export declare function applicable(fn: BoxedExpression): (args: BoxedExpression[]) => BoxedExpression | undefined;
+/**
+ * Use applicableN when the function is known to be a function of a single
+ * variable and the argument is a number.
+ *
+ * Unlike "apply", applicable returns a function  that can be called
+ * with an argument.
+ *
+ */
+export declare function applicableN1(fn: BoxedExpression): (x: number) => number;
+/**
+ * Give a string like "f(x,y)" return, ["f", ["x", "y"]]
+ */
+export declare function parseFunctionSignature(s: string): [id: string, args: string[] | undefined];

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

@@ -1,2 +1,2 @@
-/* 0.14.0 */
+/* 0.16.0 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.14.0 */
+/* 0.16.0 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.14.0 */
+/* 0.16.0 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

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

@@ -0,0 +1,2 @@
+/* 0.16.0 */
+export declare const DEFINITIONS_COMPLEX: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.14.0 */
+/* 0.16.0 */
 export declare const DEFINITIONS_CORE: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.14.0 */
+/* 0.16.0 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.14.0 */
+/* 0.16.0 */
 export declare const DEFINITIONS_LOGIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.14.0 */
+/* 0.16.0 */
 export declare const DEFINITIONS_OTHERS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.14.0 */
+/* 0.16.0 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

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

@@ -0,0 +1,2 @@
+/* 0.16.0 */
+export declare const DEFINITIONS_STATISTICS: LatexDictionary;

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

@@ -1,3 +1,3 @@
-/* 0.14.0 */
+/* 0.16.0 */
 export declare const SYMBOLS: [string, string, number][];
 export declare const DEFINITIONS_SYMBOLS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.14.0 */
+/* 0.16.0 */
 export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;

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

@@ -1,4 +1,4 @@
-/* 0.14.0 */
+/* 0.16.0 */
 import { WarningSignal } from '../../../common/signals';
 export type CommonEntry = {
     /** Note: a name is required if a serialize handler is provided */

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

@@ -1,4 +1,4 @@
-/* 0.14.0 */
+/* 0.16.0 */
 import { Serializer } from './serializer';
 import { Expression } from '../../math-json/math-json-format';
 import { WarningSignalHandler } from '../../common/signals';
@@ -19,8 +19,10 @@ export declare class LatexSyntax {
     get dictionary(): readonly LatexDictionaryEntry[];
     set dictionary(val: readonly LatexDictionaryEntry[]);
     updateOptions(opt: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>): void;
-    static getDictionary(category?: LibraryCategory | 'all'): Readonly<LatexDictionary>;
+    static getDictionary(category?: LibraryCategory | 'all'): readonly Readonly<object>[];
     parse(latex: LatexString): Expression;
-    serialize(expr: Expression): LatexString;
+    serialize(expr: Expression, options?: {
+        canonical?: boolean;
+    }): LatexString;
     get serializer(): Serializer;
 }

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

@@ -1,4 +1,4 @@
-/* 0.14.0 */
+/* 0.16.0 */
 import { Parser } from './public';
 /** For error handling, if we have a identifier prefix, assume
  * the identifier is invalid (it would have been captured by

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

@@ -1,4 +1,4 @@
-/* 0.14.0 */
+/* 0.16.0 */
 import { IndexedLatexDictionary, IndexedLatexDictionaryEntry, IndexedInfixEntry, IndexedPostfixEntry, IndexedPrefixEntry, IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry } from './dictionary/definitions';
 import { IComputeEngine } from '../public';
 import { Expression } from '../../math-json/math-json-format';
@@ -94,6 +94,40 @@ export declare class _Parser implements Parser {
     matchAll(tokens: LatexToken[]): boolean;
     matchAny(tokens: LatexToken[]): LatexToken;
     matchChar(): string | null;
+    /** If the next token matches the open delimiter, set a boundary with
+     * the close token and return true.
+     *
+     * Note this method handles generic delimiters, i.e. '(' will math both
+     * '(', '\left(', '\bigl(', etc...
+     *
+     * Note that the definitions for matchfix may need to include synonyms
+     * for example:
+     *
+     * {
+     *    openDelimiter: '(',
+     *    closeDelimiter: ')'
+     * }
+     *
+     * and
+     *
+     * {
+     *   openDelimiter: '\\lparen',
+     *   closeDelimiter: '\\rparen'
+     * }
+     *
+     * For:
+     * - '[': '\\lbrack' and '\\['
+     * - ']': '\\rbrack' and '\\]'
+     * - '{': '\\lbrace' and '\\}'
+     * - '}': '\\rbrace' and '\\}'
+     * - '<': '\\langle'
+     * - '>': '\\rangle'
+     * - '|': '\\vert'
+     * - '||': '\\Vert'
+     * - '|': '\\lvert' and '\\rvert'
+     * - '||': '\\lVert' and '\\rVert'
+     */
+    private matchDelimiter;
     parseGroup(): Expression | null;
     parseToken(): Expression | null;
     parseOptionalGroup(): Expression | null;
@@ -154,6 +188,8 @@ export declare class _Parser implements Parser {
      * return `['\right', '\rparen']`, which can be matched with `matchAll()`
      *
      * If you need to match several tokens, use `matchAll()`
+     *
+     * @internal
      */
     private matchOpenDelimiter;
     /** For error handling, when there is potentially a mismatched delimiter.

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

@@ -1,4 +1,4 @@
-/* 0.14.0 */
+/* 0.16.0 */
 import { Expression } from '../../math-json/math-json-format';
 import type { IComputeEngine } from '../public';
 /**
@@ -18,14 +18,18 @@ export type LatexString = string;
  * record to define new LaTeX dictionary entries.
  */
 export type Delimiter = ')' | '(' | ']' | '[' | '{' /** \lbrace */ | '}' /** \rbrace */ | '<' /** \langle  */ | '>' /** \rangle  */ | '|' | '||' | '\\lceil' | '\\rceil' | '\\lfloor' | '\\rfloor';
-export type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collections' | 'control-structures' | 'combinatorics' | 'core' | 'data-structures' | 'dimensions' | 'domains' | 'linear-algebra' | 'logic' | 'numeric' | 'other' | 'physics' | 'polynomials' | 'relop' | 'sets' | 'statistics' | 'styling' | 'symbols' | 'trigonometry' | 'units';
-/** Theory of operations:
+export type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collections' | 'control-structures' | 'combinatorics' | 'complex' | 'core' | 'data-structures' | 'dimensions' | 'domains' | 'linear-algebra' | 'logic' | 'numeric' | 'other' | 'physics' | 'polynomials' | 'relop' | 'sets' | 'statistics' | 'styling' | 'symbols' | 'trigonometry' | 'units';
+/**
+ *
+ * ## THEORY OF OPERATIONS
  *
  * The precedence of an operator is a number that indicates the order in which
- * operators are applied. For example, in `1 + 2 * 3`, the `*` operator has
- * a higher precedence than the `+` operator, so it is applied first.
+ * operators are applied.
  *
- * The precendence range from 0 to 1000. The higher the number, the higher the
+ * For example, in `1 + 2 * 3`, the `*` operator has a **higher** precedence
+ * than the `+` operator, so it is applied first.
+ *
+ * The precendence range from 0 to 1000. The larger the number, the higher the
  * precedence, the more "binding" the operator is.
  *
  * Here are some rough ranges for the precedence:
@@ -46,6 +50,8 @@ export type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collectio
  * - 100: not used
  * - 0: `,`, `;`, etc...
  *
+ * Some constants are defined below for common precedence values.
+ *
  *
  * Note: MathML defines some operator precendence, but it has some
  * issues and inconsistencies. However, whenever possible we adopted the
@@ -55,6 +61,14 @@ export type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collectio
  * here: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_precedence
  */
 export type Precedence = number;
+export declare const COMPARISON_PRECEDENCE = 245;
+export declare const ASSIGNMENT_PRECEDENCE = 260;
+export declare const ARROW_PRECEDENCE = 270;
+export declare const ADDITION_PRECEDENCE = 275;
+export declare const MULTIPLICATION_PRECEDENCE = 390;
+export declare const DIVISION_PRECEDENCE = 600;
+export declare const EXPONENTIATION_PRECEDENCE = 700;
+export declare const POSTFIX_PRECEDENCE = 810;
 /**
  * This indicates a condition under which parsing should stop:
  * - an operator of a precedence higher than specified has been encountered
@@ -453,6 +467,10 @@ export interface Serializer {
      * for the top level, and `\bigl(` or `(` for others.
      */
     level: number;
+    /** If true, apply transformations to the expression so the output
+     * doesn't necesarily match the raw MathJSON, but is more visually pleasing
+     * and easier to read. If false, output the raw MathJSON. */
+    canonical?: boolean;
     /** Output a LaTeX string representing the expression */
     serialize: (expr: Expression | null) => string;
     wrapString(s: string, style: 'paren' | 'leftright' | 'big' | 'none', fence?: string): string;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.14.0 */
+/* 0.16.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.14.0 */
+/* 0.16.0 */
 import { WarningSignalHandler } from '../../common/signals';
 import { NumberFormattingOptions, LatexString, SerializeLatexOptions } from './public';
 import { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
@@ -7,6 +7,7 @@ export declare class Serializer {
     options: NumberFormattingOptions & SerializeLatexOptions;
     readonly dictionary: IndexedLatexDictionary;
     level: number;
+    canonical: undefined | boolean;
     constructor(options: NumberFormattingOptions & SerializeLatexOptions, dictionary: IndexedLatexDictionary, onError: WarningSignalHandler);
     updateOptions(opt: Partial<NumberFormattingOptions> & Partial<SerializeLatexOptions>): void;
     /**
@@ -30,7 +31,9 @@ export declare class Serializer {
     serializeDictionary(dict: {
         [key: string]: Expression;
     }): string;
-    serialize(expr: Expression | null): LatexString;
+    serialize(expr: Expression | null, options?: {
+        canonical?: boolean;
+    }): LatexString;
     applyFunctionStyle(expr: Expression, level: number): 'paren' | 'leftright' | 'big' | 'none';
     groupStyle(expr: Expression, level: number): 'paren' | 'leftright' | 'big' | 'none';
     rootStyle(expr: Expression, level: number): 'radical' | 'quotient' | 'solidus';

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

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

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

@@ -1,4 +1,4 @@
-/* 0.14.0 */
+/* 0.16.0 */
 /** The canonical form of `Add`:
  * - removes `0`
  * - capture complex numbers (a + ib or ai +b)

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

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

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

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

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

@@ -1,4 +1,4 @@
-/* 0.14.0 */
+/* 0.16.0 */
 /**
  *
  */

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

@@ -1,2 +1,3 @@
-/* 0.14.0 */
-export declare const ARITHMETIC_LIBRARY: IdTable[];
+/* 0.16.0 */
+export type CanonicalArithmeticFunctions = 'Add' | 'Negate' | 'Multiply' | 'Divide' | 'Power' | 'Ln';
+export declare const ARITHMETIC_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.14.0 */
-export declare const CALCULUS_LIBRARY: IdTable[];
+/* 0.16.0 */
+export declare const CALCULUS_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.14.0 */
-export declare const COLLECTIONS_LIBRARY: IdTable;
+/* 0.16.0 */
+export declare const COLLECTIONS_LIBRARY: IdentifierDefinitions;

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

@@ -0,0 +1,2 @@
+/* 0.16.0 */
+export declare const COMPLEX_LIBRARY: IdentifierDefinitions[];

package/dist/types/compute-engine/library/control-structures.d.ts

@@ -0,0 +1,2 @@
+/* 0.16.0 */
+export declare const CONTROL_STRUCTURES_LIBRARY: IdentifierDefinitions[];

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

@@ -1,2 +1,2 @@
-/* 0.14.0 */
-export declare const CORE_LIBRARY: IdTable[];
+/* 0.16.0 */
+export declare const CORE_LIBRARY: IdentifierDefinitions[];

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

@@ -1,16 +1,15 @@
-/* 0.14.0 */
+/* 0.16.0 */
 export declare const DOMAIN_CONSTRUCTORS: string[];
 export declare const DOMAIN_ALIAS: {
-    NumericFunction: (string | string[])[];
-    RealFunction: (string | string[])[];
-    TrigonometricFunction: string[];
-    LogicOperator: (string | string[])[];
-    Predicate: (string | string[])[];
-    RelationalOperator: string[];
+    NumericFunctions: (string | string[])[];
+    RealFunctions: (string | string[])[];
+    LogicOperators: (string | string[])[];
+    Predicates: (string | string[])[];
+    RelationalOperators: string[];
 };
 export declare function isDomainLiteral(s: string | null): s is DomainLiteral;
 export declare function isSubdomainLiteral(lhs: string, rhs: string): boolean;
 /** Return all the domain literals that are an ancestor of `dom`
  */
 export declare function ancestors(dom: string): string[];
-export declare function domainSetsLibrary(): IdTable;
+export declare function domainSetsLibrary(): IdentifierDefinitions;