@cortex-js/compute-engine 0.4.0 → 0.4.3

package/dist/types/common/utils.d.ts

@@ -1,153 +0,0 @@
-/* 0.4.0 */
-import { Decimal } from 'decimal.js';
-import { Complex } from 'complex.js';
-import { Numeric } from '../compute-engine/public';
-/**
- * The `ExpressionX` type is used internally to make computations with
- * arbitrarily large floating point and complex numbers
- *
- */
-export declare type ExpressionX = Expression<Numeric>;
-/**
- * These constants are the 'primitive' functions and constants that are used
- * for some basic manipulations such as parsing, and transforming to canonical
- * form.
- *
- */
-export declare const PARENTHESES = "Parentheses";
-export declare const IDENTITY = "Identity";
-export declare const LATEX_TOKENS = "LatexTokens";
-export declare const LIST = "List";
-export declare const MISSING = "Missing";
-export declare const NOTHING = "Nothing";
-export declare const SEQUENCE = "Sequence";
-export declare const SEQUENCE2 = "Sequence2";
-export declare const ADD = "Add";
-export declare const DERIVATIVE = "Derivative";
-export declare const DIVIDE = "Divide";
-export declare const EXP = "Exp";
-export declare const INVERSE_FUNCTION = "InverseFunction";
-export declare const MULTIPLY = "Multiply";
-export declare const NEGATE = "Negate";
-export declare const POWER = "Power";
-export declare const PRIME = "Prime";
-export declare const ROOT = "Root";
-export declare const SQRT = "Sqrt";
-export declare const SUBTRACT = "Subtract";
-export declare const COMPLEX_INFINITY = "ComplexInfinity";
-export declare const PI = "Pi";
-export declare const EXPONENTIAL_E = "ExponentialE";
-export declare const IMAGINARY_UNIT = "ImaginaryUnit";
-export declare function isNumberObject(expr: Expression | null): expr is MathJsonRealNumber;
-export declare function isSymbolObject(expr: Expression | null): expr is MathJsonSymbol;
-export declare function isStringObject(expr: Expression | null): expr is MathJsonString;
-export declare function isFunctionObject<T extends number = number>(expr: Expression<T> | null): expr is MathJsonFunction<T>;
-export declare function isDictionaryObject<T extends number = number>(expr: Expression<T>): expr is MathJsonRealNumber;
-export declare function getNumberValue<T extends number = number>(expr: Expression<T> | null): number | null;
-/** Only return non-null if the expression is a Complex number.
- * Return null if it's a number, or a symbol (other than  `ImaginaryUnit` or
- * `ComplexInfinity`)
- *
- */
-export declare function getComplexValue(expr: Complex | Expression | null): Complex | null;
-/**
- * Return a multiple of the imaginary unit, e.g.
- * - 'ImaginaryUnit'
- * - ['Negate', 'ImaginaryUnit']
- * - ['Multiply', 5, 'ImaginaryUnit']
- * - ['Multiply', 'ImaginaryUnit', 5]
- */
-export declare function getImaginaryValue(expr: Expression): number | null;
-export declare function getDecimalValue(expr: Decimal | Expression | null): Decimal | null;
-/**  If expr is a string literal, return it.
- *
- * A string literal is a JSON string that begins and ends with
- * **U+0027 APOSTROPHE** : **`'`** or an object literal with a `str` key.
- */
-export declare function getStringValue(expr: Expression | null): string | null;
-/**
- * Return a rational (numer over denom) representation of the expression,
- * if possible, `[null, null]` otherwise.
- *
- * The expression can be:
- * - Some symbols: "ThreeQuarte", "Half"...
- * - ["Power", d, -1]
- * - ["Power", n, 1]
- * - ["Divide", n, d]
- *
- * The denominator is always > 0.
- */
-export declare function getRationalValue(expr: Expression): [number, number] | [null, null];
-/**
- *  Reduce the numerator and denominator:
- * `\frac{2}{4} -> \frac{1}{2})`
- */
-export declare function simplifyRational([numer, denom]: [number, number] | [null, null]): [number, number] | [null, null];
-/**
- * Return the numerator and denominator of a product with the specified symbol.
- * For example:
- * `3π` -> [3, 1]
- * `3π/2` -> [3, 2]
- * `1/2 * π` -> [1, 2]
- */
-export declare function getRationalSymbolicValue(expr: Expression, symbol: string): [number, number] | [null, null];
-/** True if the expression is of the form \frac{n}{m} where n and m are both integers
- *
- * Note this detects fewer patterns than `getRationalValue()`, but it is
- * intended to detect rational numbers used with invisible plus, i.e. `1\frac{1}{2}`
- *
- */
-export declare function isRationalNumber(expr: Expression): boolean;
-/**
- * Return the head of any expression, including symbols and numbers.
- *
- */
-export declare function getHead(expr: Expression): Expression | null;
-/**
- * The head of a function can be a string or an expression.
- *
- * Return `null` if the expression is not a function.
- *
- * Examples:
- * * `["Negate", 5]`  -> `"Negate"`
- * * `[["Prime", "f"], "x"]` -> `["Prime", "f"]`
- */
-export declare function getFunctionHead<T extends number = number>(expr: Expression<T> | null): Expression<T> | null;
-/**
- * True if the expression is a number, a symbol or a string
- * (i.e. not a function and not a dictionary)
- */
-export declare function isAtomic(expr: Expression | null): boolean;
-export declare function getFunctionName<T extends number = number>(expr: Expression<T> | null): typeof MULTIPLY | typeof POWER | typeof DIVIDE | typeof ADD | typeof SUBTRACT | typeof NEGATE | typeof DERIVATIVE | typeof INVERSE_FUNCTION | typeof LATEX_TOKENS | typeof SQRT | typeof ROOT | typeof PARENTHESES | typeof LIST | typeof MISSING | typeof PRIME | typeof IDENTITY | typeof NOTHING | typeof SEQUENCE | typeof SEQUENCE2 | typeof PRIME | 'PartialDerivative' | 'Union' | 'Intersection' | 'SetMinus' | 'Cosh' | 'Exp' | 'Re' | 'And' | 'Not' | 'Equal' | 'NotEqual' | 'Element' | 'NotElement' | 'Complex' | 'Hold' | 'Evaluate' | '';
-export declare function getSymbolName(expr: Expression | null): string | null;
-/**
- * Return all the elements but the first one, i.e. the arguments of a
- * function.
- */
-export declare function getTail<T extends number = number>(expr: Expression<T> | null): Expression<T>[];
-export declare function applyRecursively<T extends number = number>(expr: Expression<T>, fn: (x: Expression<T>) => Expression<T>): Expression<T>;
-/**
- * Apply a function to the arguments of a function and return an array of T
- */
-export declare function mapArgs<T>(expr: Expression, fn: (x: Expression) => T): T[];
-export declare function getArg<T extends number = number>(expr: Expression<T> | null, n: number): Expression<T> | null;
-export declare function getArgCount<T extends number = number>(expr: Expression<T>): number;
-export declare function getDictionary<T extends number = number>(expr: Expression<T>): {
-    [key: string]: Expression<T>;
-} | null;
-/**
- * Structurally compare two expressions, ignoring metadata.
- *
- * Compare with `match()` which ignores differences in representation.
- *
- * @revisit: is this really needed? Or just use `match()`?
- */
-export declare function equalExpr<T extends number = number>(lhs: Expression<T> | null, rhs: Expression<T> | null): boolean;
-/**
- * Return the nth term in expr.
- * If expr is not a "add" function, returns null.
- */
-/**
- * Return the coefficient of the expression, assuming vars are variables.
- */
-export declare function coef(_expr: Expression, _vars: string[]): Expression | null;

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

@@ -1,11 +0,0 @@
-/* 0.4.0 */
-export declare class ExpressionMap<T extends number, U> {
-    readonly _items: Map<Expression<T>, U>;
-    constructor(source?: ExpressionMap<T, U> | Iterable<[T, U]>);
-    has(expr: Expression<T>): boolean;
-    get(expr: Expression<T>): U | undefined;
-    set(expr: Expression<T>, value: U): void;
-    delete(expr: Expression<T>): void;
-    [Symbol.iterator](): IterableIterator<[Expression<T>, U]>;
-    entries(): IterableIterator<[Expression<T>, U]>;
-}

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

@@ -1,2 +0,0 @@
-/* 0.4.0 */
-export declare function gamma(c: Complex): Complex;

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

@@ -1,12 +0,0 @@
-/* 0.4.0 */
-export declare const DECIMAL_ZERO: Decimal;
-export declare const DECIMAL_ONE: Decimal;
-export declare const DECIMAL_MINUS_ONE: Decimal;
-export declare const DECIMAL_NAN: Decimal;
-export declare const DECIMAL_POS_INFINITY: Decimal;
-export declare const DECIMAL_NEG_INFINITY: Decimal;
-export declare function gcd(a: Decimal, b: Decimal): Decimal;
-export declare function lcm(a: Decimal, b: Decimal): Decimal;
-export declare function factorial(n: Decimal | number): Decimal;
-export declare function lngamma(z: Decimal | number): Decimal;
-export declare function gamma(z: Decimal | number): Decimal;

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

@@ -1,21 +0,0 @@
-/* 0.4.0 */
-export declare const MACHINE_PRECISION: number;
-export declare const MACHINE_TOLERANCE_BITS = 7;
-export declare const MACHINE_TOLERANCE: number;
-export declare const NUMERICAL_TOLERANCE: number;
-/**
- * Returns the smallest floating-point number greater than x.
- * Denormalized values may not be supported.
- */
-export declare function nextUp(x: number): number;
-export declare function nextDown(x: number): number;
-export declare const SMALL_PRIMES: Set<number>;
-export declare const LARGEST_SMALL_PRIME = 7919;
-export declare function primeFactors(_n: number): {
-    [factor: number]: number;
-};
-export declare function gcd(a: number, b: number): number;
-export declare function lcm(a: number, b: number): number;
-export declare function factorial(n: number): number;
-export declare function lngamma(z: number): number;
-export declare function gamma(z: number): number;

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

@@ -1,22 +0,0 @@
-/* 0.4.0 */
-import { Expression } from '../public';
-import { Numeric } from './public';
-export declare type Substitution<T extends number = number> = {
-    [symbol: string]: Expression<T>;
-};
-export declare function matchRecursive(expr: ExpressionX, pattern: ExpressionX, substitution: Substitution<Numeric>, options: {
-    numericalTolerance: number;
-}): Substitution<Numeric> | null;
-export declare function match<T extends number = number>(pattern: Expression<T>, expr: Expression<T>, options?: {
-    numericalTolerance: number;
-}): Substitution<T> | null;
-export declare function match1(expr: Expression, pattern: Expression, options: {
-    numericalTolerance: number;
-}): Expression | null;
-export declare function count(exprs: Iterable<Expression>, pattern: Expression, options: {
-    numericalTolerance: number;
-}): number;
-export declare function matchList(exprs: Iterable<Expression>, pattern: Expression, options: {
-    numericalTolerance: number;
-}): Substitution[];
-export declare function substitute<T extends number = Numeric>(expr: Expression<T>, substitution: Substitution<T>): Expression<T>;

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

@@ -1,42 +0,0 @@
-/* 0.4.0 */
-import { ComputeEngine, Domain } from './public';
-export declare function isInteger(ce: ComputeEngine, expr: Expression): boolean;
-export declare function isNumeric(_ce: ComputeEngine, _expr: Expression | null): boolean | undefined;
-export declare function isZero(ce: ComputeEngine, expr: Expression): boolean | undefined;
-export declare function isNotZero(engine: ComputeEngine, expr: Expression): boolean | undefined;
-export declare function isInfinity(ce: ComputeEngine, expr: Expression | null): boolean | undefined;
-export declare function isFinite(_ce: ComputeEngine, _expr: Expression | null): boolean | undefined;
-export declare function isPosInfinity(ce: ComputeEngine, expr: Expression | null): boolean | undefined;
-export declare function isNegInfinity(ce: ComputeEngine, expr: Expression | null): boolean | undefined;
-export declare function isPositive(ce: ComputeEngine, expr: Expression | null): boolean | undefined;
-export declare function isOne(ce: ComputeEngine, expr: Expression): boolean | undefined;
-export declare function isNegativeOne(ce: ComputeEngine, expr: Expression): boolean | undefined;
-/** Is `expr` >= 0? */
-export declare function isNonNegative(ce: ComputeEngine, expr: Expression): boolean | undefined;
-/** Is `expr` < 0? */
-export declare function isNegative(ce: ComputeEngine, expr: Expression): boolean | undefined;
-/** Is `expr` <= 0? */
-export declare function isNonPositive(ce: ComputeEngine, expr: Expression): boolean | undefined;
-export declare function isReal(_ce: ComputeEngine, expr: Expression | null): boolean | undefined;
-/** Is `expr` an element of RR, including ±∞? */
-export declare function isExtendedReal(_ce: ComputeEngine, _expr: Expression): boolean | undefined;
-/** Is `expr` an element of QQ (can be written as p/q)? */
-export declare function isRational(_ce: ComputeEngine, _expr: Expression): boolean | undefined;
-/** Is `expr` an algebraic number, i.e. not transcendental (π, e)? */
-export declare function isAlgebraic(_ce: ComputeEngine, _expr: Expression): boolean | undefined;
-/** Is `expr` a complex number? */
-export declare function isComplex(_ce: ComputeEngine, _expr: Expression): boolean | undefined;
-/** Is `expr` an element of `dom`? */
-export declare function isElement(_ce: ComputeEngine, _expr: Expression, _set: Expression): boolean | undefined;
-/** Test if `lhs` is a subset of `rhs`.
- *
- * `lhs` and `rhs` can be set expressions, i.e.
- * `["SetMinus", "ComplexNumber", 0]`
- *
- */
-export declare function isSubsetOf(ce: ComputeEngine, lhs: Domain | null, rhs: Domain | null): boolean;
-export declare function isEqual(_ce: ComputeEngine, _lhs: Expression, _rhs: Expression): boolean | undefined;
-export declare function isLess(_ce: ComputeEngine, _lhs: Expression, _rhs: Expression): boolean | undefined;
-export declare function isLessEqual(_ce: ComputeEngine, _lhs: Expression, _rhs: Expression): boolean | undefined;
-export declare function isGreater(_ce: ComputeEngine, _lhs: Expression, _rhs: Expression): boolean | undefined;
-export declare function isGreaterEqual(_ce: ComputeEngine, _lhs: Expression, _rhs: Expression): boolean | undefined;

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

@@ -1,15 +0,0 @@
-/* 0.4.0 */
-import { ComputeEngine } from './public';
-export declare class CortexError {
-    signal: ErrorSignal;
-    constructor(errorSignal: Signal);
-    toString(): string;
-}
-/**
- * Return the set of variables (free or not) in an expression.
- * Doesn't return free varas because doesn't account for variable declaration
- * and scopes.
- */
-export declare function getVariables(ce: ComputeEngine, expr: Expression): Set<string>;
-export declare function isCanonical(ce: ComputeEngine, expr: Expression): boolean;
-export declare function hasWildcards(expr: Expression): boolean;

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

@@ -1,2 +0,0 @@
-/* 0.4.0 */
-export declare const DEFINITIONS_ALGEBRA: LatexDictionary<any>;

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

@@ -1,3 +0,0 @@
-/* 0.4.0 */
-import { Numeric } from '../compute-engine/public';
-export declare const DEFINITIONS_ARITHMETIC: LatexDictionary<Numeric>;

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

@@ -1,2 +0,0 @@
-/* 0.4.0 */
-export declare const DEFINITIONS_CALCULUS: LatexDictionary<any>;

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

@@ -1,3 +0,0 @@
-/* 0.4.0 */
-import { Numeric } from '../compute-engine/public';
-export declare const DEFINITIONS_CORE: LatexDictionary<Numeric>;

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

@@ -1,2 +0,0 @@
-/* 0.4.0 */
-export declare const DEFINITIONS_INEQUALITIES: LatexDictionary<number>;

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

@@ -1,3 +0,0 @@
-/* 0.4.0 */
-import { Numeric } from '../compute-engine/public';
-export declare const DEFINITIONS_OTHERS: LatexDictionary<Numeric>;

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

@@ -1,2 +0,0 @@
-/* 0.4.0 */
-export declare const DEFINITIONS_SETS: LatexDictionary<any>;

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

@@ -1,3 +0,0 @@
-/* 0.4.0 */
-import { LatexDictionary } from './public';
-export declare const DEFINITIONS_SYMBOLS: LatexDictionary<Numeric>;

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

@@ -1,3 +0,0 @@
-/* 0.4.0 */
-import { Numeric } from '../compute-engine/public';
-export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary<Numeric>;

package/dist/types/latex-syntax/definitions.d.ts

@@ -1,40 +0,0 @@
-/* 0.4.0 */
-import { LatexDictionary, LatexString, LatexToken, ParserFunction, SerializerFunction, LatexDictionaryEntry } from './public';
-import { Numeric } from '../compute-engine/public';
-export declare type IndexedLatexDictionaryEntry<T extends number = number> = {
-    name: string;
-    trigger?: {
-        symbol?: LatexToken | LatexToken[];
-        matchfix?: LatexToken | LatexToken[];
-        infix?: LatexToken | LatexToken[];
-        prefix?: LatexToken | LatexToken[];
-        postfix?: LatexToken | LatexToken[];
-        superfix?: LatexToken | LatexToken[];
-        subfix?: LatexToken | LatexToken[];
-    };
-    parse: Expression<T> | ParserFunction<T>;
-    serialize: SerializerFunction<T> | LatexString;
-    associativity: 'right' | 'left' | 'non' | 'both';
-    precedence: number;
-    arguments: 'group' | 'implicit' | '';
-    optionalLatexArg: number;
-    requiredLatexArg: number;
-    separator: LatexString;
-    closeFence: LatexString;
-};
-export declare type IndexedLatexDictionary<T extends number = number> = {
-    lookahead: number;
-    name: Map<string, IndexedLatexDictionaryEntry<T>>;
-    prefix: (Map<LatexString, IndexedLatexDictionaryEntry<T>> | null)[];
-    infix: (Map<LatexString, IndexedLatexDictionaryEntry<T>> | null)[];
-    postfix: (Map<LatexString, IndexedLatexDictionaryEntry<T>> | null)[];
-    matchfix: (Map<LatexString, IndexedLatexDictionaryEntry<T>> | null)[];
-    superfix: (Map<LatexString, IndexedLatexDictionaryEntry<T>> | null)[];
-    subfix: (Map<LatexString, IndexedLatexDictionaryEntry<T>> | null)[];
-    symbol: (Map<LatexString, IndexedLatexDictionaryEntry<T>> | null)[];
-    environment: Map<string, IndexedLatexDictionaryEntry<T>>;
-};
-export declare function indexLatexDictionary<T extends number = number>(dic: readonly LatexDictionaryEntry<T>[], onError: ErrorListener<ErrorCode>): IndexedLatexDictionary<T>;
-export declare const DEFAULT_LATEX_DICTIONARY: {
-    [category in DictionaryCategory]?: LatexDictionary<Numeric>;
-};

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

@@ -1,27 +0,0 @@
-/* 0.4.0 */
-import { DictionaryCategory, Expression, ErrorCode, ErrorListener } from '../public';
-import { Numeric } from '../compute-engine/public';
-export declare class LatexSyntax<T extends number = number> {
-    onError: ErrorListener<ErrorCode>;
-    options: Required<NumberFormattingOptions> & Required<ParseLatexOptions> & Required<SerializeLatexOptions>;
-    private dictionary;
-    constructor(options?: NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions & {
-        dictionary?: readonly LatexDictionaryEntry<T>[];
-        onError?: ErrorListener<ErrorCode>;
-    });
-    static getDictionary(domain?: DictionaryCategory | 'all'): Readonly<LatexDictionary<any>>;
-    parse(latex: LatexString): Expression;
-    serialize(expr: Expression<T>): LatexString;
-}
-export declare function parse<T extends number = Numeric>(latex: LatexString, options?: NumberFormattingOptions & ParseLatexOptions & {
-    dictionary?: Readonly<LatexDictionary<T>>;
-    onError?: ErrorListener<ErrorCode>;
-}): Expression;
-/**
- * Serialize a MathJSON expression as a Latex string.
- *
- */
-export declare function serialize<T extends number = number>(expr: Expression<T>, options?: NumberFormattingOptions & SerializeLatexOptions & {
-    dictionary?: Readonly<LatexDictionary<T>>;
-    onError?: ErrorListener<ErrorCode>;
-}): LatexString;

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

@@ -1,138 +0,0 @@
-/* 0.4.0 */
-import { ParseLatexOptions, LatexDictionaryEntry, LatexToken, NumberFormattingOptions } from './public';
-import { IndexedLatexDictionary } from './definitions';
-export declare class Scanner<T extends number = number> implements Scanner<T> {
-    index: number;
-    readonly tokens: LatexToken[];
-    readonly onError: ErrorListener<ErrorCode>;
-    readonly dictionary: IndexedLatexDictionary<T>;
-    readonly options: Required<NumberFormattingOptions> & Required<ParseLatexOptions>;
-    private invisibleOperatorPrecedence;
-    constructor(tokens: LatexToken[], options: Required<NumberFormattingOptions> & Required<ParseLatexOptions>, dictionary: IndexedLatexDictionary<T>, onError: ErrorListener<ErrorCode>);
-    clone(start: number, end: number): Scanner<T>;
-    balancedClone(open: LatexToken | LatexToken[], close: LatexToken | LatexToken[], silentError?: boolean): Scanner<T> | null;
-    get atEnd(): boolean;
-    get peek(): LatexToken;
-    latex(start: number, end?: number): string;
-    latexAhead(n: number): string;
-    latexBefore(): string;
-    latexAfter(): string;
-    /**
-     * Return at most `maxLookahead` strings made from the tokens
-     * ahead.
-     *
-     * The index in the returned array correspond to the number of tokens.
-     * Note that since a token can be longer than one char ('\\pi', but also
-     * some astral plane unicode characters), the length of the string
-     * does not match that index. However, knowing the index is important
-     * to know by how many tokens to advance.
-     *
-     */
-    lookAhead(): string[];
-    peekDefinition(kind: 'symbol' | 'infix' | 'matchfix' | 'prefix' | 'postfix' | 'superfix' | 'subfix' | 'operator'): [LatexDictionaryEntry<T> | null, number];
-    next(): LatexToken;
-    skipSpace(): boolean;
-    match(target: LatexToken): boolean;
-    matchAll(target: LatexToken | LatexToken[]): boolean;
-    matchAny(targets: LatexToken[]): LatexToken;
-    matchWhile(targets: LatexToken[]): LatexToken[];
-    matchSign(): string;
-    matchDecimalDigits(): string;
-    matchSignedInteger(): string;
-    matchExponent(): string;
-    matchNumber(): string;
-    matchOperator(kind: 'infix' | 'prefix' | 'postfix', lhs?: Expression<T> | null, minPrec?: number): Expression<T> | null;
-    matchArguments(kind: undefined | '' | 'group' | 'implicit'): Expression<T>[] | null;
-    matchMatchfixOperator(): Expression<T> | null;
-    matchDefinition(kind: 'symbol' | 'infix' | 'matchfix' | 'prefix' | 'postfix' | 'superfix' | 'subfix' | 'operator'): [LatexDictionaryEntry<T> | null, Expression<T> | 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}`
-     */
-    matchSymbol(): Expression<T> | null;
-    matchOptionalLatexArgument(): Expression<T> | null;
-    /**
-     * Match a required latex argument:
-     * - either enclosed in `{}`
-     * - or a single token.
-     *
-     * Return null if an argument was not found
-     * Return '' if an empty argument `{}` was found
-     */
-    matchRequiredLatexArgument(): Expression<T> | null;
-    /**
-     *  Match a superfix/subfix operator, e.g. `^{*}`
-     */
-    matchSupsub(lhs: Expression<T> | null): Expression<T> | null;
-    matchPostfix(lhs: Expression<T> | null): Expression<T> | null;
-    matchString(): string;
-    matchEnvironmentName(command: '\\begin' | '\\end', envName: string): boolean;
-    /**
-     * Match an expression in a tabular format,
-     * where row 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.
-     */
-    matchTabular(): null | Expression<T>;
-    matchEnvironment(): Expression<T> | null;
-    /**
-     * Apply the operator `op` to the left-hand-side and right-hand-side
-     * expression. Applies the associativity rule specified by the definition,
-     * i.e. 'op(a, op(b, c))` -> `op(a, b, c)`, etc...
-     *
-     * `op` is the name of the operator which should have a corresponding
-     * definition.
-     *
-     * If `op` is an infix operator, it should have both a lhs and rhs.
-     * If `op` is a postfix operator, it should only have a lhs.
-     * If `op` is a prefix operator, the lhs is returned as the first element
-     * of the return tuple.
-     *
-     * @return a tuple: [lhs, rhs]
-     */
-    applyOperator(op: string, lhs: Expression<T> | null, rhs: Expression<T> | null): NonNullable<[Expression<T> | null, Expression<T> | null]>;
-    /**
-     * Apply an invisible operator between two expressions.
-     *
-     * If no `invisibleOperator` was specified, use the `latex` operator.
-     *
-     * If the lhs is a number and the rhs is a fraction of integers,
-     * assume an 'invisible plus', that is '2 3/4' -> ['add', 2, [divide, 3, 4]]
-     * unless `invisiblePlusOperator` is empty
-     *
-     */
-    applyInvisibleOperator(lhs: Expression<T> | null, rhs: Expression<T> | null): Expression<T> | null;
-    matchUnknownLatexCommand(): Expression<T> | null;
-    /**
-     * <primary> :=
-     * (<number> | <symbol> | <environment> | <matchfix-expr>) <subsup>* <postfix-operator>*
-     *
-     * <symbol> ::= (<symbol-id> | (<latex-command><latex-arguments>)) <arguments>
-     *
-     * <matchfix-expr> :=
-     *  <matchfix-op-open> <expression> [<matchfix-op-separator> <expression>] <matchfix-op-close>
-     *
-     */
-    matchPrimary(_minPrec?: number): Expression<T> | null;
-    matchBalancedExpression(open: LatexToken | LatexToken[], close: LatexToken | LatexToken[], onError?: ErrorListener<ErrorCode>): Expression<T> | null;
-    /**
-     *  Parse an expression:
-     *
-     * <expression> ::=
-     *  | <primary>
-     *  | <prefix-op> <primary>
-     *  | <primary> <infix-op> <expression>
-     *
-     * Stop when an operator of precedence less than `minPrec` is encountered
-     */
-    matchExpression(minPrec?: number): Expression<T> | null;
-    /**
-     * Add latex or other requested metadata to the expression
-     */
-    decorate(expr: Expression<T> | null, start: number): Expression<T> | null;
-}