@cortex-js/compute-engine 0.5.0 → 0.7.0

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

@@ -1,24 +1,35 @@
-/* 0.5.0 */
-import { ParseLatexOptions, LatexToken, NumberFormattingOptions, Delimiter, Terminator, Parser } from './public';
+/* 0.7.0 */
 import { IndexedLatexDictionary, InfixEntry, PostfixEntry, PrefixEntry, SymbolEntry } from './dictionary/definitions';
-import { WarningSignalHandler } from '../../common/signals';
 import { IComputeEngine } from '../public';
+import { Expression } from '../../math-json/math-json-format';
 export declare const DEFAULT_LATEX_NUMBER_OPTIONS: NumberFormattingOptions;
 export declare const DEFAULT_PARSE_LATEX_OPTIONS: ParseLatexOptions;
 export declare class _Parser implements Parser {
-    readonly onError: WarningSignalHandler;
+    readonly computeEngine: IComputeEngine;
     readonly options: NumberFormattingOptions & ParseLatexOptions;
-    readonly engine: IComputeEngine;
-    readonly _dictionary: IndexedLatexDictionary;
     index: number;
-    _lastPeek: string;
-    _peekCounter: number;
-    readonly _tokens: LatexToken[];
-    constructor(tokens: LatexToken[], options: NumberFormattingOptions & ParseLatexOptions, dictionary: IndexedLatexDictionary, computeEngine: IComputeEngine, onError: WarningSignalHandler);
+    private readonly _tokens;
+    private _positiveInfinityTokens;
+    private _negativeInfinityTokens;
+    private _notANumberTokens;
+    private _decimalMarkerTokens;
+    private _groupSeparatorTokens;
+    private _exponentProductTokens;
+    private _beginExponentMarkerTokens;
+    private _endExponentMarkerTokens;
+    private _truncationMarkerTokens;
+    private _beginRepeatingDigitsTokens;
+    private _endRepeatingDigitsTokens;
+    private _imaginaryNumberTokens;
+    private readonly _dictionary;
+    private _boundaries;
+    private _lastPeek;
+    private _peekCounter;
+    constructor(tokens: LatexToken[], options: NumberFormattingOptions & ParseLatexOptions, dictionary: IndexedLatexDictionary, computeEngine: IComputeEngine);
     updateOptions(opt: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions>): void;
-    clone(start: number, end: number): Parser;
     get atEnd(): boolean;
     get peek(): LatexToken;
+    next(): LatexToken;
     /**
      * Return true if
      * - at end of the token stream
@@ -27,12 +38,18 @@ export declare class _Parser implements Parser {
      * Note: the `minPrec` condition is not checked. It should be checked separately.
      */
     atTerminator(t?: Terminator): boolean;
+    /** True if the current token matches any of the boundaries we are waiting for */
+    get atBoundary(): boolean;
+    addBoundary(boundary: LatexToken[]): void;
+    removeBoundary(): void;
+    matchBoundary(): boolean;
+    boundaryError(msg: string | [string, ...Expression[]]): Expression;
     latex(start: number, end?: number): string;
     latexAhead(n: number): string;
     latexBefore(): string;
     latexAfter(): string;
     /**
-     * Return at most `lookahead` strings made from the tokens
+     * Return at most `this._dictionary.lookahead` strings made from the tokens
      * ahead.
      *
      * The index in the returned array correspond to the number of tokens.
@@ -44,13 +61,16 @@ export declare class _Parser implements Parser {
      */
     lookAhead(): string[];
     /** Return all the definitions that potentially match the tokens ahead */
+    peekDefinitions(kind: 'function'): [FunctionEntry, number][] | null;
     peekDefinitions(kind: 'symbol'): [SymbolEntry, number][] | null;
     peekDefinitions(kind: 'postfix'): [PostfixEntry, number][] | null;
-    peekDefinitions(kind: 'postfix'): [PostfixEntry, number][] | null;
-    peekDefinitions(kind: 'operator'): [InfixEntry | PrefixEntry | PostfixEntry, number][] | null;
     peekDefinitions(kind: 'infix'): [InfixEntry, number][] | null;
     peekDefinitions(kind: 'prefix'): [PrefixEntry, number][] | null;
-    next(): LatexToken;
+    peekDefinitions(kind: 'operator'): [InfixEntry | PrefixEntry | PostfixEntry, number][] | null;
+    skipSpaceTokens(): void;
+    /** While parsing in math mode, skip applicable spaces.
+     * Do not use to skip spaces e.g. while parsing a string. See `skipSpaceTokens()` instead.
+     */
     skipSpace(): boolean;
     matchChar(): string | null;
     matchColor(_background?: boolean): string | null;
@@ -58,11 +78,16 @@ export declare class _Parser implements Parser {
     match(token: LatexToken): boolean;
     matchAll(tokens: LatexToken | LatexToken[]): boolean;
     matchAny(tokens: LatexToken[]): LatexToken;
-    matchWhile(tokens: LatexToken[]): LatexToken[];
-    matchSign(): string;
-    matchDecimalDigits(): string;
-    matchSignedInteger(): string;
+    matchSequence(tokens: LatexToken[]): LatexToken[];
+    matchOptionalSign(): string;
+    matchDecimalDigits(options?: {
+        withGrouping?: boolean;
+    }): string;
+    matchSignedInteger(options?: {
+        withGrouping?: boolean;
+    }): string;
     matchExponent(): string;
+    matchRepeatingDecimal(): string;
     matchNumber(): string;
     /**
      * A Latex number can be a decimal, hex or octal number.
@@ -79,12 +104,12 @@ 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
-     *  (i.e. we interpret `\cos x + 1` as `\cos(x) + 1`)
+     * - 'enclosure' : will look for an argument inside an enclosure (open/close fence)
+     * - 'implicit': either an expression inside a pair of `()`, or just a product
+     *  (i.e. we interpret `\cos 2x + 1` as `\cos(2x) + 1`)
      */
-    matchArguments(kind: undefined | '' | 'group' | 'implicit'): Expression[] | null;
-    /** If matches the normalized open delimiter, returns the
+    matchArguments(kind: undefined | '' | 'enclosure' | 'implicit'): Expression[] | null;
+    /** If matches the normalized open delimiter, return the
      * expected closing delimiter.
      *
      * For example, if `delimiter` is `(`, it would match `\left\lparen` and
@@ -95,56 +120,56 @@ export declare class _Parser implements Parser {
     matchOpenDelimiter(openDelim: Delimiter, closeDelim: Delimiter): LatexToken[] | null;
     matchMiddleDelimiter(delimiter: '|' | ':' | LatexToken): boolean;
     /**
-     * An enclosure is an opening matchfix operator, an expression, optionally
-     * followed multiple times by a separator and another expression,
+     * An enclosure is an opening matchfix operator, an optional expression,
+     * optionally followed multiple times by a separator and another expression,
      * and finally a closing matching operator.
      */
     matchEnclosure(): Expression | null;
     /**
-     * A symbol can be:
-     * - a constant: `\pi`
-     * - a variable: `x`
-     * - a function with explicit arguments `f(x)`
-     * - a function with implicit arguments: `\cos x`
-     * - a command: `\frac{2}{3}`
+     * Match a single variable name. It can be:
+     * - a symbol
+     * - a simple multi-letter identifier: `\mathrm{speed}`
+     * - a complex multi-letter identifier: `\alpha_12` or `\mathit{speed\unicode{"2012}of\unicode{"2012}sound}`
+     * - a command: `\alpha`  @todo
+     * - a complex name such as `\alpha_12` or `\mathit{speed\unicode{"2012}of\unicode{"2012}sound}` (see serializer.ts) @todo:
+     * @todo: matchSymbol should use matchIdentifier
      */
-    matchSymbol(): Expression | null;
-    matchOptionalLatexArgument(): Expression | null;
+    matchIdentifier(): string | null;
     /**
-     * Match a required LaTeX argument:
-     * - either enclosed in `{}`
-     * - or a single token.
+     * A function is a function identifier followed by arguments
+     * - a function with explicit arguments `f(x)`
+     * - a function with explicit arguments `\mathrm{floor}(x)`
+     * - a function name: `\mathrm{floor}`
+     * - a function with implicit arguments: `\cos x` (via a  custom parser)
      *
-     * Return null if an argument was not found
-     * Return 'Nothing' if an empty argument `{}` was found
      */
-    matchRequiredLatexArgument(): Expression | null;
+    matchFunction(): Expression | null;
     /**
-     *  Match a sequence superfix/subfix operator, e.g. `^{*}`
-     *
-     * Superfix and subfix need special handling:
-     *
-     * - they act mostly like an infix operator, but they are commutative, i.e.
-     * `x_a^b` should be parsed identically to `x^b_a`.
-     *
-     * - furthermore, in LaTeX, consecutive `^` or `_` are treated as concatenated,
-     * that is `x^a^b` parses the same as `x^{ab}`.
-     *
+     * A symbol can be:
+     * - a single-letter variable: `x`
+     * - a single LaTeX command: `\pi`
      */
+    matchSymbol(): Expression | null;
+    matchOptionalLatexArgument(): Expression | null;
+    matchRequiredLatexArgument(): Expression | null;
     matchSupsub(lhs: Expression | null): Expression | null;
     matchPostfix(lhs: Expression | null): Expression | null;
-    matchString(until: {
-        tokens: LatexToken[];
-    } & Partial<Terminator>): string;
-    matchEnvironmentName(command: '\\begin' | '\\end', envName: string): boolean;
+    /** Match a string used as a LaTeX identifier, for example an environment
+     * name.
+     * Not suitable for general purpose text, e.g. argument of a `\text{}
+     * command. See `matchChar()` instead.
+     */
+    matchString(): string;
+    /** Match a string as an argument (in a `{}` pair) */
+    matchStringArgument(): string | null;
     /**
-     * Match an expression in a tabular format,
-     * where row are separated by `\\` and columns by `&`
+     * Match an expression in a tabular format, where rows are separated by `\\`
+     * and columns by `&`.
      *
-     * Return rows of sparse columns as a list: empty rows are indicated with NOTHING,
-     * and empty cells are also indicated with NOTHING.
+     * Return rows of sparse columns: empty rows are indicated with `Nothing`,
+     * and empty cells are also indicated with `Nothing`.
      */
-    matchTabular(endName: string): null | Expression;
+    matchTabular(): null | Expression[][];
     matchEnvironment(): Expression | null;
     /**
      * Apply an invisible operator between two expressions.
@@ -167,8 +192,8 @@ export declare class _Parser implements Parser {
      * - x2 -> no
      * => lhs is a number, rhs is a number, but not a literal
      */
-    applyInvisibleOperator(terminator: Terminator, rawLhs: Expression | null): Expression | null;
-    matchUnknownLatexCommand(): Expression | null;
+    applyInvisibleOperator(terminator: Terminator, lhs: Expression | null): Expression | null;
+    matchUnexpectedLatexCommand(): Expression | null;
     /**
      * <primary> :=
      * (<number> | <symbol> | <environment> | <matchfix-expr>) <subsup>* <postfix-operator>*
@@ -188,11 +213,12 @@ export declare class _Parser implements Parser {
      *  | <prefix-op> <primary>
      *  | <primary> <infix-op> <expression>
      *
-     * Stop when an operator of precedence less than `minPrec` is encountered
+     * Stop when an operator of precedence less than `until.minPrec` is encountered
      */
     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;
+    error(code: string | [string, ...Expression[]], fromToken: number): Expression;
 }

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

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.7.0 */
 import { Expression } from '../../math-json/math-json-format';
 import type { IComputeEngine } from '../public';
 /**
@@ -18,17 +18,15 @@ export declare type LatexString = string;
  * 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';
+export declare type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collections' | 'control-structures' | 'combinatorics' | 'core' | 'dimensions' | 'domains' | 'linear-algebra' | 'logic' | 'numeric' | 'other' | 'physics' | 'polynomials' | 'relop' | 'sets' | 'statistics' | 'styling' | 'symbols' | 'trigonometry' | 'units';
 /**
  * This indicates a condition under which parsing should stop:
- * - a specific string of tokens has been encountered
  * - an operator of a precedence higher than specified has been encountered
  * - the last token has been reached
  * - or if a function is provided, the function returns true;
  */
 export declare type Terminator = {
     minPrec: number;
-    tokens?: LatexToken[];
     condition?: (parser: Parser) => boolean;
 };
 /**
@@ -54,11 +52,13 @@ export declare type Terminator = {
  */
 export declare type EnvironmentParseHandler = (parser: Parser, reqArgs: Expression[], optArgs: Expression[]) => Expression | null;
 export declare type SymbolParseHandler = (parser: Parser) => Expression | null;
+export declare type FunctionParseHandler = (parser: Parser) => Expression | null;
 export declare type PostfixParseHandler = (parser: Parser, lhs: Expression) => Expression | null;
 export declare type PrefixParseHandler = (parser: Parser, until: Terminator) => Expression | null;
 export declare type InfixParseHandler = (parser: Parser, until: Terminator, lhs: Expression) => Expression | null;
 export declare type MatchfixParseHandler = (parser: Parser, body: Expression) => Expression | null;
-export declare type ParseHandler = SymbolParseHandler | EnvironmentParseHandler | PostfixParseHandler | PrefixParseHandler | InfixParseHandler | MatchfixParseHandler;
+export declare type ParseHandler = SymbolParseHandler | FunctionParseHandler | EnvironmentParseHandler | PostfixParseHandler | PrefixParseHandler | InfixParseHandler | MatchfixParseHandler;
+export declare type LatexArgumentType = '{expression}' /** A required math mode expression */ | '[expression]' /** An optional math mode expression */ | '{text}' /** A required expression in text mode */ | '[text]' /** An optional expression in text mode */ | '{unit}' /** A required unit expression, e.g. `3em` */ | '[unit]' /** An optional unit expression, e.g. `3em` */ | '{glue}' /** A required glue expression, e.g. `25 mu plus 3em ` */ | '[glue]' /** An optional glue expression, e.g. `25 mu plus 3em ` */ | '{string}' /** A required text string, terminated by a non-literal token */ | '[string]' /** An optional text string, terminated by a non-literal token */ | '{color}' /** A required color expression, e.g. `red` or `#00ff00` */ | '[color]'; /** An optional color expression, e.g. `red` or `#00ff00` */
 /**
  * Maps a string of LaTeX tokens to a function or symbol and vice-versa.
  *
@@ -163,8 +163,13 @@ export declare type SymbolEntry = BaseEntry & {
     kind: 'symbol';
     /** Used for appropriate wrapping (i.e. when to surround it with parens) */
     precedence?: number;
+    parse: Expression | SymbolParseHandler;
+};
+export declare type FunctionEntry = BaseEntry & {
+    kind: 'function';
     /**
      * 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 +177,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,45 +192,21 @@ 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
-     * square brackets).
-     *
-     * For example, for the `\sqrt` command, 1: `\sqrt[3]{x}`
-     *
-     */
-    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
-     * curly braces).
-     *
-     * For example, for the `\frac` command, 2: `\frac{1}{n}`
-     *
-     */
-    requiredLatexArg?: number;
-    parse: Expression | SymbolParseHandler;
+    parse: Expression | FunctionParseHandler;
 };
 /**
  * A simple LaTeX dictionary entry, for example for a command like `\pi`.
  */
 export declare type DefaultEntry = BaseEntry & {
     precedence?: number;
-    arguments?: 'group' | 'implicit' | '';
-    optionalLatexArg?: number;
-    requiredLatexArg?: number;
     parse?: Expression | SymbolParseHandler;
 };
-export declare type LatexDictionaryEntry = DefaultEntry | MatchfixEntry | InfixEntry | PostfixEntry | PrefixEntry | SymbolEntry | EnvironmentEntry;
+export declare type LatexDictionaryEntry = DefaultEntry | MatchfixEntry | InfixEntry | PostfixEntry | PrefixEntry | SymbolEntry | FunctionEntry | EnvironmentEntry;
 /** @internal */
 export declare function isSymbolEntry(entry: LatexDictionaryEntry): entry is SymbolEntry;
 /** @internal */
+export declare function isFunctionEntry(entry: LatexDictionaryEntry): entry is FunctionEntry;
+/** @internal */
 export declare function isMatchfixEntry(entry: LatexDictionaryEntry): entry is MatchfixEntry;
 /** @internal */
 export declare function isInfixEntry(entry: LatexDictionaryEntry): entry is InfixEntry;
@@ -257,7 +238,7 @@ export declare type ParseLatexOptions = {
     /**
      * If true, ignore space characters.
      *
-     * Default: `true`
+     * **Default**: `true`
      *
      */
     skipSpace: boolean;
@@ -276,26 +257,26 @@ export declare type ParseLatexOptions = {
      * Otherwise, return each token making up the number (minus sign, digits,
      * decimal separator, etc...).
      *
-     * Default: `true`
+     * **Default**: `true`
      */
     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.
@@ -305,6 +286,8 @@ export declare type ParseLatexOptions = {
      * 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`.
+     *
+     * **Default:** `false`
      */
     preserveLatex: boolean;
 };
@@ -333,8 +316,8 @@ export declare type SerializeLatexOptions = {
      */
     multiply: LatexString;
     /**
-     * When an expression contains the symbol `Missing`, serialize it
-     * with this LaTeX string
+     * When an expression contains the error expression `["Error", 'missing']`,
+     * serialize it with this LaTeX string
      */
     missingSymbol: LatexString;
     applyFunctionStyle: (expr: Expression, level: number) => 'paren' | 'leftright' | 'big' | 'none';
@@ -356,10 +339,10 @@ export declare type NumberFormattingOptions = {
      * the '.' in '3.1415'.
      *
      * Some countries use a comma rather than a dot. In this case it is
-     * recommended to use `"{,}"` as the marker: the surrounding bracket ensure
+     * recommended to use `"{,}"` as the marker: the surrounding brackets ensure
      * there is no additional gap after the comma.
      *
-     * Default: `"."`
+     * **Default**: `"."`
      */
     decimalMarker: LatexString;
     /**
@@ -368,10 +351,10 @@ export declare type NumberFormattingOptions = {
      *
      * If you change it to another value, be aware that this may lead to
      * unexpected results. For example, if changing it to `,` the expression
-     * `x_{1,2}` will parse as `x` with a subscript of `1.2`, rather than `x`
-     * with two subscripts, `1` and `2`.
+     * `\mathrm{Hypot}(1,2)` will parse as `["Hypot", 1.2]` rather than
+     * `["Hypot", 1, 2]`.
      *
-     * Default: `"\\,"` (thin space, 3/18mu) (Resolution 7 of the 1948 CGPM)
+     * **Default**: `"\\,"` (thin space, 3/18mu) (Resolution 7 of the 1948 CGPM)
      */
     groupSeparator: LatexString;
     exponentProduct: LatexString;
@@ -419,7 +402,7 @@ export declare class LatexSyntax {
      * Use the value returned by this function to the `options` argument of the
      * constructor.
      */
-    static getDictionary(domain?: DictionaryCategory | 'all'): Readonly<LatexDictionary>;
+    static getDictionary(domain?: LibraryCategory | 'all'): Readonly<LatexDictionary>;
     parse(latex: LatexString): Expression;
     serialize(expr: Expression): LatexString;
 }
@@ -439,7 +422,11 @@ export interface Serializer {
     level: number;
     /** Output a LaTeX string representing the expression */
     serialize: (expr: Expression | null) => string;
-    wrapString(s: string, style: 'paren' | 'leftright' | 'big' | 'none'): string;
+    wrapString(s: string, style: 'paren' | 'leftright' | 'big' | 'none', fence?: string): string;
+    /** A string with the arguments of expr fenced appropriately and separated by
+     * commas.
+     */
+    wrapArguments(expr: Expression): string;
     /** Add a group fence around the expression if it is
      * an operator of precedence less than or equal to `prec`.
      */
@@ -459,7 +446,6 @@ export interface Serializer {
 }
 export declare type SerializeHandler = (serializer: Serializer, expr: Expression) => string;
 export interface Parser {
-    readonly onError: WarningSignalHandler;
     readonly options: Required<ParseLatexOptions>;
     readonly computeEngine?: IComputeEngine;
     index: number;
@@ -481,6 +467,10 @@ export interface Parser {
     latexAfter(): string;
     /** If there are any space, advance the index until a non-space is encountered */
     skipSpace(): boolean;
+    addBoundary(boundary: LatexToken[]): void;
+    removeBoundary(): void;
+    matchBoundary(): boolean;
+    boundaryError(msg: string | [string, ...Expression[]]): Expression;
     /** If the next token is a character, return it and advance the index
      * This includes plain characters (e.g. 'a', '+'...), characters
      * defined in hex (^^ and ^^^^), the `\char` and `\unicode` command.
@@ -500,31 +490,40 @@ export interface Parser {
     match(tokens: LatexToken): boolean;
     matchAll(tokens: LatexToken | LatexToken[]): boolean;
     matchAny(tokens: LatexToken[]): LatexToken;
-    matchWhile(tokens: LatexToken[]): LatexToken[];
+    matchSequence(tokens: LatexToken[]): LatexToken[];
     /** If the next token matches a `+` or `-` sign, return it and advance the index.
      * Otherwise return `''` and do not advance */
-    matchSign(): string;
+    matchOptionalSign(): string;
     matchDecimalDigits(): string;
     matchSignedInteger(): string;
     matchExponent(): string;
     matchNumber(): string;
     /** Parse a tabular environment, until `\end{endName}`
      */
-    matchTabular(endName: string): null | Expression;
+    matchTabular(endName: string): null | Expression[][];
     applyInvisibleOperator(terminator: Terminator, lhs: Expression | null): Expression | null;
     /** 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;
+    /**
+     * Match a required LaTeX argument:
+     * - either enclosed in `{}`
+     * - or a single token.
+     *
+     * Return null if no argument was found
+     * Return `['Sequence']` if an empty argument `{}` was found
+     */
     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)
+     * - '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: '' | 'implicit' | 'enclosure'): Expression[] | null;
     /** If matches the normalized open delimiter, returns the
      * expected closing delimiter.
      *
@@ -534,6 +533,17 @@ export interface Parser {
      */
     matchOpenDelimiter(openDelim: Delimiter, closeDelim: Delimiter): LatexToken[] | null;
     matchMiddleDelimiter(delimiter: '|' | ':' | LatexToken): boolean;
+    /**
+     *  Match a sequence superfix/subfix operator, e.g. `^{*}`
+     *
+     * Superfix and subfix need special handling:
+     *
+     * - they act mostly like an infix operator, but they are commutative, i.e.
+     * `x_a^b` should be parsed identically to `x^b_a`.
+     *
+     * - furthermore, in LaTeX `x^a^b` parses the same as `x^a{}^b`.
+     *
+     */
     matchSupsub(lhs: Expression | null): Expression | null;
     /**
      *
@@ -555,6 +565,12 @@ export interface Parser {
      * If not a primary, return `null` and do not advance the index.
      */
     matchPrimary(): Expression | null;
+    /**
+     * A symbol can be:
+     * - a single-letter variable: `x`
+     * - a single LaTeX command: `\pi`
+     */
+    matchSymbol(): Expression | null;
     /**
      * Parse an expression:
      *
@@ -573,4 +589,6 @@ export interface Parser {
      * `until` is `{ minPrec:0 }` by default.
      */
     matchExpression(until?: Partial<Terminator>): Expression | null;
+    /** Return an error expression with the specified code and arguments */
+    error(code: string | [string, ...Expression[]], fromToken: number): Expression;
 }

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

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.7.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.7.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,5 +1,5 @@
-/* 0.5.0 */
-import { NumberFormattingOptions, LatexString, SerializeLatexOptions } from './public';
+/* 0.7.0 */
+import { NumberFormattingOptions, LatexString, SerializeLatexOptions, FunctionEntry } from './public';
 import { IndexedLatexDictionary, SymbolEntry } from './dictionary/definitions';
 import { WarningSignalHandler } from '../../common/signals';
 export declare class Serializer {
@@ -19,8 +19,10 @@ export declare class Serializer {
      *
      */
     wrapShort(expr: Expression | null): string;
-    wrapString(s: string, style: 'paren' | 'leftright' | 'big' | 'none'): string;
-    serializeSymbol(expr: Expression, def?: SymbolEntry): string;
+    wrapString(s: string, style: 'paren' | 'leftright' | 'big' | 'none', fence?: string): string;
+    wrapArguments(expr: Expression): string;
+    serializeSymbol(expr: Expression, def?: SymbolEntry | FunctionEntry): string;
+    serializeFunction(expr: Expression, def?: FunctionEntry | SymbolEntry): string;
     serializeDictionary(dict: {
         [key: string]: Expression;
     }): string;

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

@@ -1,4 +1,4 @@
-/* 0.5.0 */
+/* 0.7.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

@@ -0,0 +1,11 @@
+/* 0.7.0 */
+/** The canonical form of `Add`:
+ * - removes `0`
+ * - capture complex numbers (a + ib or ai +b)
+ * */
+export declare function canonicalAdd(ce: IComputeEngine, ops: BoxedExpression[]): BoxedExpression;
+export declare function domainAdd(_ce: IComputeEngine, args: BoxedDomain[]): BoxedDomain | null;
+export declare function simplifyAdd(ce: IComputeEngine, args: BoxedExpression[]): BoxedExpression | undefined;
+export declare function evalAdd(ce: IComputeEngine, args: BoxedExpression[], mode?: 'N' | 'eval'): BoxedExpression;
+export declare function canonicalSummation(ce: IComputeEngine, expr: BoxedExpression, range: BoxedExpression | undefined): BoxedExpression;
+export declare function evalSummation(ce: IComputeEngine, expr: BoxedExpression, range: BoxedExpression, mode: 'simplify' | 'N' | 'evaluate'): BoxedExpression | undefined;

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

@@ -0,0 +1,15 @@
+/* 0.7.0 */
+/**
+ * Canonical form of 'Divide' (and 'Rational')
+ * - remove denominator of 1
+ * - simplify the signs
+ * - factor out negate (make the numerator and denominator positive)
+ * - if numerator and denominator are integer literals, return a rational number
+ *   or Rational experssion
+ * - if Divide, transform into Multiply/Power
+ */
+export declare function canonicalDivide(ce: IComputeEngine, op1: BoxedExpression, op2: BoxedExpression): BoxedExpression;
+/**
+ * Simplify form of 'Divide' (and 'Rational')
+ */
+export declare function simplifyDivide(ce: IComputeEngine, op1: BoxedExpression, op2: BoxedExpression): BoxedExpression | undefined;