@cortex-js/compute-engine 0.6.0 → 0.8.0

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

@@ -1,9 +1,9 @@
-/* 0.6.0 */
+/* 0.8.0 */
 import { Complex } from 'complex.js';
 import { Expression, MathJsonNumber } from '../math-json/math-json-format';
 import { SignalMessage, WarningSignal } from '../common/signals';
-import type { DictionaryCategory, LatexDictionary, 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, Domain, DomainExpression } from './public';
+import type { LibraryCategory, LatexDictionary, LatexDictionaryEntry, LatexString, NumberFormattingOptions, ParseLatexOptions, SerializeLatexOptions } from './latex-syntax/public';
+import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefinition, IComputeEngine, SymbolTable, ExpressionMapInterface, NumericMode as NumericMode, Pattern, RuntimeScope, Scope, SemiBoxedExpression, Substitution, SymbolDefinition, BoxedRuleSet, Rule, JsonSerializationOptions, ComputeEngineStats, Metadata, BoxedDomain, DomainExpression, BoxedLambdaExpression, FunctionDefinition } from './public';
 /**
  *
  * To use the CortexJS Compute Engine, create a `ComputeEngine` instance.
@@ -25,55 +25,70 @@ import { AssumeResult, BoxedExpression, BoxedFunctionDefinition, BoxedSymbolDefi
  */
 export declare class ComputeEngine implements IComputeEngine {
     /** @internal */
-    readonly ZERO: BoxedExpression;
+    readonly _ZERO: BoxedExpression;
     /** @internal */
-    readonly ONE: BoxedExpression;
+    readonly _ONE: BoxedExpression;
     /** @internal */
-    readonly TWO: BoxedExpression;
+    readonly _TWO: BoxedExpression;
     /** @internal */
-    readonly HALF: BoxedExpression;
+    readonly _HALF: BoxedExpression;
     /** @internal */
-    readonly NEGATIVE_ONE: BoxedExpression;
+    readonly _NEGATIVE_ONE: BoxedExpression;
     /** @internal */
-    readonly I: BoxedExpression;
+    readonly _I: BoxedExpression;
     /** @internal */
-    readonly NAN: BoxedExpression;
+    readonly _NAN: BoxedExpression;
     /** @internal */
-    readonly POSITIVE_INFINITY: BoxedExpression;
+    readonly _POSITIVE_INFINITY: BoxedExpression;
     /** @internal */
-    readonly NEGATIVE_INFINITY: BoxedExpression;
+    readonly _NEGATIVE_INFINITY: BoxedExpression;
     /** @internal */
-    readonly COMPLEX_INFINITY: BoxedExpression;
+    readonly _COMPLEX_INFINITY: BoxedExpression;
     /** @internal */
-    DECIMAL_NAN: Decimal;
+    _DECIMAL_NAN: Decimal;
     /** @internal */
-    DECIMAL_ZERO: Decimal;
+    _DECIMAL_ZERO: Decimal;
     /** @internal */
-    DECIMAL_ONE: Decimal;
+    _DECIMAL_ONE: Decimal;
     /** @internal */
-    DECIMAL_TWO: Decimal;
+    _DECIMAL_TWO: Decimal;
     /** @internal */
-    DECIMAL_HALF: Decimal;
+    _DECIMAL_HALF: Decimal;
     /** @internal */
-    DECIMAL_PI: Decimal;
+    _DECIMAL_PI: Decimal;
+    /** @internal */
+    _DECIMAL_NEGATIVE_ONE: Decimal;
     /** @internal */
-    DECIMAL_NEGATIVE_ONE: Decimal;
     private _precision;
+    /** @internal */
     private _numericMode;
+    /** @internal */
     private _latexSyntax?;
+    /** @internal */
     private _tolerance;
+    /** @internal */
     private _decimalTolerance;
+    /** @internal */
     private _cache;
+    /** @internal */
     private _stats;
+    /** @internal */
     private _cost?;
+    /** @internal */
     private _jsonSerializationOptions;
     /** The domain of unknown symbols. If `null` unknown symbols do not have a
      * definition automatically associated with them.
+     *
+     *  @internal
      */
     private _defaultDomain;
+    /** @internal */
     private _commonSymbols;
+    /** @internal */
     private _commonNumbers;
+    /** @internal */
     private _commonDomains;
+    /** @internal */
     private _latexDictionary?;
     /**
      * The current scope.
@@ -86,20 +101,20 @@ export declare class ComputeEngine implements IComputeEngine {
      * The `ce.context` property represents the current scope.
      *
      */
-    context: RuntimeScope;
+    context: RuntimeScope | null;
     /** Absolute time beyond which evaluation should not proceed.
      * @internal
      */
     deadline?: number;
     /**
-     * Return dictionaries suitable for the specified categories, or `"all"`
+     * Return symbol tables suitable for the specified categories, or `"all"`
      * for all categories (`"arithmetic"`, `"algebra"`, etc...).
      *
-     * A symbol dictionary defines how the symbols and function names in a MathJSON
+     * A symbol table defines how the symbols and function names in a MathJSON
      * expression should be interpreted, i.e. how to evaluate and manipulate them.
      *
      */
-    static getDictionaries(categories?: DictionaryCategory[] | 'all'): Readonly<Dictionary>[];
+    static getSymbolTables(categories?: LibraryCategory[] | LibraryCategory | 'all'): Readonly<SymbolTable>[];
     /**
      * Construct a new `ComputeEngine` instance.
      *
@@ -120,13 +135,13 @@ export declare class ComputeEngine implements IComputeEngine {
      * 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.
+     * is less than `tolerance`, 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>[];
+        symbolTables?: Readonly<SymbolTable>[];
         latexDictionary?: readonly LatexDictionaryEntry[];
         numericMode?: NumericMode;
         numericPrecision?: number;
@@ -141,18 +156,14 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      * @internal
      */
-    purge(): void;
+    reset(): void;
     /** @internal */
-    _register(expr: BoxedExpression): void;
+    _register(_expr: BoxedExpression): void;
     /** @internal */
-    _unregister(expr: BoxedExpression): void;
+    _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 numeric calculations
      * such as when calling `ce.N()`.
      *
@@ -180,8 +191,8 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      * **Default:** `"ExtendedRealNumber"`
      */
-    get defaultDomain(): Domain | null;
-    set defaultDomain(domain: Domain | string | null);
+    get defaultDomain(): BoxedDomain | null;
+    set defaultDomain(domain: BoxedDomain | string | null);
     /**
      * Values smaller than the tolerance are considered to be zero for the
      * purpose of comparison, i.e. if `|b - a| <= tolerance`, `b` is considered
@@ -189,6 +200,10 @@ export declare class ComputeEngine implements IComputeEngine {
      */
     get tolerance(): number;
     set tolerance(val: number);
+    /** @internal */
+    decimal(a: Decimal.Value): Decimal;
+    /** @internal */
+    complex(a: number | Complex, b?: number): Complex;
     /** 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}.
@@ -197,25 +212,30 @@ export declare class ComputeEngine implements IComputeEngine {
     chop(n: Decimal): Decimal | 0;
     chop(n: Complex): Complex | 0;
     private get latexSyntax();
-    static getLatexDictionary(domain?: DictionaryCategory | 'all'): Readonly<LatexDictionary>;
+    static getLatexDictionary(domain?: LibraryCategory | 'all'): Readonly<LatexDictionary>;
     set costFunction(fn: ((expr: BoxedExpression) => number) | undefined);
     get costFunction(): (expr: BoxedExpression) => number;
     /**
      * Return a matching symbol definition, starting with the current
-     * scope and going up the scope chain.
+     * scope and going up the scope chain. Prioritize finding a match by
+     * wikidata, if provided.
      */
-    getSymbolDefinition(symbol: string, wikidata?: string): undefined | BoxedSymbolDefinition;
+    lookupSymbol(symbol: string, wikidata?: string, scope?: RuntimeScope): undefined | BoxedSymbolDefinition;
     /**
-     * Return the definition for a function matching this head and
-     * these arguments.
+     * Return the definition for a function matching this head.
+     *
+     * Start looking in the current context, than up the scope chain.
      *
-     * Start looking in the current scope, than up the scope chain.
+     * This is a very rough lookup, since it doesn't account for the domain
+     * of the argument or the codomain. However, it is useful during parsing
+     * to differentiate between symbols that might represent a function application, e.g. `f` vs `x`.
      */
-    getFunctionDefinition(head: string, args?: BoxedExpression[]): undefined | BoxedFunctionDefinition;
+    lookupFunction(head: string, scope?: RuntimeScope): undefined | BoxedFunctionDefinition;
     /**
      * Add (or replace) a definition for a symbol in the current scope.
      */
     defineSymbol(def: SymbolDefinition): BoxedSymbolDefinition;
+    defineFunction(def: FunctionDefinition): BoxedFunctionDefinition;
     /**
      *
      * Create a new scope and add it to the top of the scope stack
@@ -225,7 +245,7 @@ export declare class ComputeEngine implements IComputeEngine {
      *
      */
     pushScope(options?: {
-        dictionary?: Readonly<Dictionary> | Readonly<Dictionary>[];
+        symbolTable?: Readonly<SymbolTable> | Readonly<SymbolTable>[];
         assumptions?: (LatexString | Expression)[];
         scope?: Partial<Scope>;
     }): void;
@@ -264,7 +284,8 @@ export declare class ComputeEngine implements IComputeEngine {
     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;
+    error(message: ['invalid-domain', ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedDomain;
+    error(message: string | [string, ...SemiBoxedExpression[]], where?: SemiBoxedExpression): BoxedExpression;
     add(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     mul(ops: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     power(base: BoxedExpression, exponent: number | [number, number] | BoxedExpression, metadata?: Metadata): BoxedExpression;
@@ -274,14 +295,15 @@ export declare class ComputeEngine implements IComputeEngine {
     pair(first: BoxedExpression, second: BoxedExpression, metadata?: Metadata): BoxedExpression;
     tuple(elements: BoxedExpression[], metadata?: Metadata): BoxedExpression;
     string(s: string, metadata?: Metadata): BoxedExpression;
-    symbol(sym: string, metadata?: Metadata): BoxedExpression;
-    domain(domain: BoxedExpression | DomainExpression | Domain, metadata?: Metadata): Domain;
+    symbol(name: string, metadata?: Metadata): BoxedExpression;
+    domain(domain: BoxedExpression | DomainExpression | BoxedDomain, metadata?: Metadata): BoxedDomain;
+    lambda(expr: SemiBoxedExpression, sig: BoxedDomain): BoxedLambdaExpression;
     number(value: number | MathJsonNumber | Decimal | Complex | [num: number, denom: number], metadata?: Metadata): BoxedExpression;
     rules(rules: Rule[]): BoxedRuleSet;
     pattern(expr: LatexString | SemiBoxedExpression): Pattern;
-    parse(s: LatexString | string): BoxedExpression;
+    parse(latex: LatexString | string): BoxedExpression;
     parse(s: null): null;
-    parse(s: LatexString | string | null): null | BoxedExpression;
+    parse(latex: LatexString | string | null): null | BoxedExpression;
     serialize(x: Expression | BoxedExpression): string;
     get latexOptions(): NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions;
     set latexOptions(opts: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>);
@@ -297,7 +319,8 @@ export declare class ComputeEngine implements IComputeEngine {
      * ```
      */
     ask(pattern: LatexString | SemiBoxedExpression): Substitution[];
-    assume(symbol: LatexString | SemiBoxedExpression, domain: string | BoxedExpression): AssumeResult;
+    infer(symbol: BoxedExpression | string, _domain: BoxedDomain | DomainExpression): AssumeResult;
+    assume(symbol: LatexString | SemiBoxedExpression, domainValue: BoxedDomain | DomainExpression | Expression | 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.6.0 */
+/* 0.8.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,4 +1,4 @@
-/* 0.6.0 */
+/* 0.8.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.6.0 */
+/* 0.8.0 */
 export declare const DEFINITIONS_ALGEBRA: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.6.0 */
+/* 0.8.0 */
 export declare const DEFINITIONS_ARITHMETIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.6.0 */
+/* 0.8.0 */
 export declare const DEFINITIONS_CALCULUS: LatexDictionary;

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

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

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

@@ -1,2 +1,2 @@
-/* 0.6.0 */
+/* 0.8.0 */
 export declare const DEFINITIONS_INEQUALITIES: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.6.0 */
+/* 0.8.0 */
 export declare const DEFINITIONS_LOGIC: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.6.0 */
+/* 0.8.0 */
 export declare const DEFINITIONS_OTHERS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.6.0 */
+/* 0.8.0 */
 export declare const DEFINITIONS_SETS: LatexDictionary;

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

@@ -1,2 +1,2 @@
-/* 0.6.0 */
+/* 0.8.0 */
 export declare const DEFINITIONS_SYMBOLS: LatexDictionary;

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

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

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

@@ -1,4 +1,4 @@
-/* 0.6.0 */
+/* 0.8.0 */
 import { WarningSignal } from '../../../common/signals';
 export declare type CommonEntry = {
     name?: string;
@@ -7,10 +7,12 @@ export declare type CommonEntry = {
 export declare type SymbolEntry = CommonEntry & {
     kind: 'symbol';
     precedence: number;
-    optionalLatexArg: number;
-    requiredLatexArg: number;
     parse: SymbolParseHandler;
 };
+export declare type FunctionEntry = CommonEntry & {
+    kind: 'function';
+    parse: FunctionParseHandler;
+};
 export declare type MatchfixEntry = CommonEntry & {
     kind: 'matchfix';
     openDelimiter: Delimiter | LatexToken[];
@@ -35,14 +37,13 @@ export declare type PostfixEntry = CommonEntry & {
 };
 export declare type EnvironmentEntry = CommonEntry & {
     kind: 'environment';
-    optionalLatexArg: number;
-    requiredLatexArg: number;
     parse: EnvironmentParseHandler;
 };
-export declare type IndexedLatexDictionaryEntry = SymbolEntry | MatchfixEntry | InfixEntry | PrefixEntry | PostfixEntry | EnvironmentEntry;
+export declare type IndexedLatexDictionaryEntry = FunctionEntry | SymbolEntry | MatchfixEntry | InfixEntry | PrefixEntry | PostfixEntry | EnvironmentEntry;
 export declare type IndexedLatexDictionary = {
     lookahead: number;
     name: Map<string, IndexedLatexDictionaryEntry>;
+    function: Map<string, FunctionEntry[]>;
     symbol: (Map<LatexString, SymbolEntry[]> | null)[];
     prefix: (Map<LatexString, PrefixEntry[]> | null)[];
     infix: (Map<LatexString, InfixEntry[]> | null)[];
@@ -52,5 +53,5 @@ export declare type IndexedLatexDictionary = {
 };
 export declare function indexLatexDictionary(dic: readonly LatexDictionaryEntry[], onError: (sig: WarningSignal) => void): IndexedLatexDictionary;
 export declare const DEFAULT_LATEX_DICTIONARY: {
-    [category in DictionaryCategory]?: LatexDictionary;
+    [category in LibraryCategory]?: LatexDictionary;
 };

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

@@ -1,4 +1,4 @@
-/* 0.6.0 */
+/* 0.8.0 */
 import { Serializer } from './serializer';
 import { Expression } from '../../math-json/math-json-format';
 import { WarningSignalHandler } from '../../common/signals';
@@ -6,7 +6,7 @@ import { IComputeEngine } from '../public';
 export declare const DEFAULT_SERIALIZE_LATEX_OPTIONS: Required<SerializeLatexOptions>;
 export declare class LatexSyntax {
     onError: WarningSignalHandler;
-    options: NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions;
+    readonly options: NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions;
     readonly computeEngine: IComputeEngine;
     private dictionary;
     private _serializer?;
@@ -16,7 +16,7 @@ export declare class LatexSyntax {
         onError?: WarningSignalHandler;
     });
     updateOptions(opt: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>): void;
-    static getDictionary(category?: DictionaryCategory | 'all'): Readonly<LatexDictionary>;
+    static getDictionary(category?: LibraryCategory | '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,24 +1,35 @@
-/* 0.6.0 */
-import { ParseLatexOptions, LatexToken, NumberFormattingOptions, Delimiter, Terminator, Parser } from './public';
+/* 0.8.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.
@@ -80,13 +105,11 @@ export declare class _Parser implements Parser {
     matchInfixOperator(lhs: Expression, until?: Terminator): Expression | null;
     /**
      * - '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`
+     * - '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 | '' | 'enclosure' | 'implicit' | 'group'): 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
@@ -97,55 +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 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}`
+     * 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: 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.
@@ -168,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>*
@@ -189,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
      */
     decorate(expr: Expression | null, start: number): Expression | null;
+    error(code: string | [string, ...Expression[]], fromToken: number): Expression;
 }