@cortex-js/compute-engine 0.32.0 → 0.32.1

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

@@ -0,0 +1,896 @@
+/* 0.32.1 */
+import type { Expression, MathJsonSymbol } from '../../math-json/types';
+import { BoxedType, TypeString } from '../types';
+import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
+export type SymbolTable = {
+    parent: SymbolTable | null;
+    ids: {
+        [id: MathJsonSymbol]: BoxedType;
+    };
+};
+/**
+ * A `LatexToken` is a token as returned by `Parser.peek`.
+ *
+ * It can be one of the indicated tokens, or a string that starts with a
+ * `\` for LaTeX commands, or a LaTeX character which includes digits,
+ * letters and punctuation.
+ *
+ * @category Latex Parsing and Serialization
+ */
+export type LatexToken = string | '<{>' | '<}>' | '<space>' | '<$>' | '<$$>';
+/** A LatexString is a regular string of LaTeX, for example:
+ * `\frac{\pi}{2}`
+ *
+ * @category Latex Parsing and Serialization
+ */
+export type LatexString = string;
+/**
+ * Open and close delimiters that can be used with {@linkcode MatchfixEntry}
+ * record to define new LaTeX dictionary entries.
+ *
+ * @category Latex Parsing and Serialization
+ */
+export type Delimiter = '.' | ')' | '(' | ']' | '[' | '{' /** \lbrace */ | '}' /** \rbrace */ | '<' /** \langle  */ | '>' /** \rangle  */ | '|' | '||' | '\\lceil' | '\\rceil' | '\\lfloor' | '\\rfloor' | '\\llbracket' | '\\rrbracket';
+/** @category Latex Parsing and Serialization */
+export type DelimiterScale = 'normal' | 'scaled' | 'big' | 'none';
+/**
+ * @category Latex Parsing and Serialization
+ */
+export type LibraryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collections' | 'control-structures' | 'combinatorics' | 'complex' | 'core' | 'data-structures' | 'dimensions' | 'domains' | 'linear-algebra' | 'logic' | 'number-theory' | 'numeric' | 'other' | 'physics' | 'polynomials' | 'relop' | 'sets' | 'statistics' | 'styling' | 'symbols' | 'trigonometry' | 'units';
+/**
+ *
+ * :::info[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.
+ *
+ * The precedence ranges from 0 to 1000. The larger the number, the higher the
+ * precedence, the more "binding" the operator is.
+ *
+ * ## Operator Precedence Table
+ *
+ * | Precedence | Operators | Description |
+ * |------------|-----------|-------------|
+ * | **880** | `\lnot` `\neg` `++` `--` `+` `-` (prefix) | Prefix/postfix unary |
+ * | **810** | `!` `'` `!!` `'''` | Factorial, prime (postfix) |
+ * | **800** | `_` (subscript) | Subscript |
+ * | **780** | `\degree` `\prime` | Degree, prime symbols |
+ * | **740** | `\%` | Percent |
+ * | **720** | `\/` (inline division) | Inline division |
+ * | **700** | `^` `\overset` `\underset` | Exponentiation, over/underscript |
+ * | **650** | (invisible multiply) `\cdot` | Implicit multiplication |
+ * | **600** | `\div` `\frac` | Division |
+ * | **390** | `\times` `*` `/` | Multiplication |
+ * | **350** | `\cup` `\cap` | Set union/intersection |
+ * | **275** | `+` `-` (infix) | Addition, subtraction |
+ * | **270** | `\to` `\rightarrow` `\mapsto` | Arrows |
+ * | **265** | `\setminus` `\smallsetminus` `:` (range) | Set difference, range |
+ * | **260** | `:=` | Assignment |
+ * | **255** | `\ne` | Not equal |
+ * | **250** | `\not\approxeq` | Not approximately equal |
+ * | **247** | `\approx` | Approximately |
+ * | **245-246** | `=` `<` `>` `\lt` `\gt` `\nless` `\ngtr` | Equality, comparison |
+ * | **241-244** | `\le` `\leq` `\ge` `\geq` `>=` | Less/greater or equal |
+ * | **240** | `\in` `\notin` `\subset` `\supset` ... | Set membership/relations |
+ * | **235** | `\land` `\wedge` `\&` | Logical AND |
+ * | **232** | `\veebar` `\barwedge` (Xor, Nand, Nor) | Logical XOR, NAND, NOR |
+ * | **230** | `\lor` `\vee` `\parallel` | Logical OR |
+ * | **220** | `\implies` `\Rightarrow` `\vdash` `\models` | Implication, entailment |
+ * | **219** | `\iff` `\Leftrightarrow` `\equiv` | Equivalence |
+ * | **200** | `\forall` `\exists` `\exists!` | Quantifiers |
+ * | **160** | `\mid` `\vert` (set builder) | Set builder notation |
+ * | **19-20** | `,` `;` `\ldots` | Sequence separators |
+ *
+ * ## Key Relationships
+ *
+ * - **Comparisons bind tighter than logic**: `x = 1 \lor y = 2` parses as
+ *   `(x = 1) \lor (y = 2)`, not `x = (1 \lor y) = 2`
+ * - **AND binds tighter than OR**: `a \land b \lor c` parses as
+ *   `(a \land b) \lor c`
+ * - **Logic operators bind tighter than implication**: `a \lor b \implies c`
+ *   parses as `(a \lor b) \implies c`
+ *
+ * Some constants are defined below for common precedence values.
+ *
+ * **Note**: MathML defines
+ * [some operator precedence](https://www.w3.org/TR/2009/WD-MathML3-20090924/appendixc.html),
+ * but it has some issues and inconsistencies. However,
+ * whenever possible we adopted the MathML precedence.
+ *
+ * The JavaScript operator precedence is documented
+ * [here](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_precedence).
+ *
+ * :::
+ *
+ * @category Latex Parsing and Serialization
+ */
+export type Precedence = number;
+/** @hidden */
+export declare const COMPARISON_PRECEDENCE: Precedence;
+/** @hidden */
+export declare const ASSIGNMENT_PRECEDENCE: Precedence;
+/** @hidden */
+export declare const ARROW_PRECEDENCE: Precedence;
+/** @hidden */
+export declare const ADDITION_PRECEDENCE: Precedence;
+/** @hidden */
+export declare const MULTIPLICATION_PRECEDENCE: Precedence;
+/** @hidden */
+export declare const DIVISION_PRECEDENCE: Precedence;
+/** @hidden */
+export declare const INVISIBLE_OP_PRECEDENCE: Precedence;
+/** @hidden */
+export declare const EXPONENTIATION_PRECEDENCE: Precedence;
+/** @hidden */
+export declare const POSTFIX_PRECEDENCE: Precedence;
+/**
+ * This indicates a condition under which parsing should stop:
+ * - an operator of a precedence higher than specified has been encountered
+ * - the last token has been reached
+ * - or if a condition is provided, the condition returns true
+ *
+ * @category Latex Parsing and Serialization
+ */
+export type Terminator = {
+    minPrec: Precedence;
+    condition?: (parser: Parser) => boolean;
+};
+/**
+ * **Custom parsing handler.**
+ *
+ * When this handler is invoked the parser points right after the LaTeX
+ * fragment that triggered it.
+ *
+ * Tokens can be consumed with `parser.nextToken()` and other parser methods
+ * such as `parser.parseGroup()`, `parser.parseOptionalGroup()`, etc...
+ *
+ * If it was in an infix or postfix context, `lhs` will represent the
+ * left-hand side argument. In a prefix or matchfix context, `lhs` is `null`.
+ *
+ * In a superfix (`^`) or subfix (`_`) context (that is if the first token of
+ * the trigger is `^` or `_`), `lhs` is `["Superscript", lhs, rhs]`
+ * and `["Subscript", lhs, rhs]`, respectively.
+ *
+ * The handler should return `null` if the tokens could not be parsed
+ * (didn't match the syntax that was expected), or the matching expression
+ * otherwise.
+ *
+ * If the tokens were parsed but should be ignored, the handler should
+ * return `Nothing`.
+ *
+ * @category Latex Parsing and Serialization
+ */
+export type ParseHandler = ExpressionParseHandler | SymbolParseHandler | FunctionParseHandler | EnvironmentParseHandler | PostfixParseHandler | InfixParseHandler | MatchfixParseHandler;
+/**
+ * @category Latex Parsing and Serialization
+ */
+export type ExpressionParseHandler = (parser: Parser, until?: Readonly<Terminator>) => Expression | null;
+/**
+ * @category Latex Parsing and Serialization
+ */
+export type PrefixParseHandler = (parser: Parser, until?: Readonly<Terminator>) => Expression | null;
+/**
+ * @category Latex Parsing and Serialization
+ */
+export type SymbolParseHandler = (parser: Parser, until?: Readonly<Terminator>) => Expression | null;
+/**
+ * @category Latex Parsing and Serialization
+ */
+export type FunctionParseHandler = (parser: Parser, until?: Readonly<Terminator>) => Expression | null;
+/**
+ * @category Latex Parsing and Serialization
+ */
+export type EnvironmentParseHandler = (parser: Parser, until?: Readonly<Terminator>) => Expression | null;
+/**
+ * @category Latex Parsing and Serialization
+ */
+export type PostfixParseHandler = (parser: Parser, lhs: Expression, until?: Readonly<Terminator>) => Expression | null;
+/**
+ * @category Latex Parsing and Serialization
+ */
+export type InfixParseHandler = (parser: Parser, lhs: Expression, until: Readonly<Terminator>) => Expression | null;
+/**
+ * @category Latex Parsing and Serialization
+ */
+export type MatchfixParseHandler = (parser: Parser, body: Expression) => Expression | null;
+/**
+ * @category Latex Parsing and Serialization
+ */
+export 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` */
+/**
+ * A trigger is the set of tokens that will make an entry in the
+ * LaTeX dictionary eligible to parse the stream and generate an expression.
+ * If the trigger matches, the `parse` handler is called, if available.
+ *
+ * The trigger can be specified either as a LaTeX string (`latexTrigger`) or
+ * as an symbol (`symbolTrigger`). A symbol match several
+ * LaTeX expressions that are equivalent, for example `\operatorname{gcd}` or
+ *  `\mathbin{gcd}`, match the `"gcd"` symbol
+ *
+ * `matchfix` operators use `openTrigger` and `closeTrigger` instead.
+ *
+ * @category Latex Parsing and Serialization
+ */
+export type Trigger = {
+    latexTrigger?: LatexString | LatexToken[];
+    symbolTrigger?: MathJsonSymbol;
+};
+/**
+ * Maps a string of LaTeX tokens to a function or symbol and vice-versa.
+ * @category Latex Parsing and Serialization
+ */
+export type BaseEntry = {
+    /**
+     * Map a MathJSON symbol to this entry.
+     *
+     * Each entry should have at least a `name` or a `parse` handler.
+     *
+     * An entry with no `name` cannot be serialized: the `name` is used to map
+     * a MathJSON function or symbol name to the appropriate entry for
+     * serializing.
+     *
+     * However, an entry with no `name` can be used to define a synonym (for
+     * example for the symbol `\varnothing` which is a synonym for `\emptyset`).
+     *
+     * If no `parse` handler is provided, only the trigger is used to select this
+     * entry. Otherwise, if the trigger of the entry matches the current
+     * token, the `parse` handler is invoked.
+     */
+    name?: MathJsonSymbol;
+    /**
+     * Transform an expression into a LaTeX string.
+     * If no `serialize` handler is provided, the trigger is used.
+     */
+    serialize?: LatexString | SerializeHandler;
+};
+/**
+ * @category Latex Parsing and Serialization
+ */
+export type DefaultEntry = BaseEntry & Trigger & {
+    parse?: Expression | ExpressionParseHandler;
+};
+/**
+ * @category Latex Parsing and Serialization
+ */
+export type ExpressionEntry = BaseEntry & Trigger & {
+    kind: 'expression';
+    parse?: Expression | ExpressionParseHandler;
+    precedence?: Precedence;
+};
+/**
+ * @category Latex Parsing and Serialization
+ */
+export type MatchfixEntry = BaseEntry & {
+    kind: 'matchfix';
+    /**
+     * If `kind` is `'matchfix'`: the `openTrigger` and `closeTrigger`
+     * properties are required.
+     */
+    openTrigger: Delimiter | LatexToken[];
+    closeTrigger: Delimiter | LatexToken[];
+    /** When invoked, the parser is pointing after the close delimiter.
+     * The argument of the handler is the body, i.e. the content between
+     * the open delimiter and the close delimiter.
+     */
+    parse?: MatchfixParseHandler;
+};
+/**
+ * @category Latex Parsing and Serialization
+ */
+export type InfixEntry = BaseEntry & Trigger & {
+    /**
+     * Infix position, with an operand before and an operand after: `a ⊛ b`.
+     *
+     * Example: `+`, `\times`.
+     */
+    kind: 'infix';
+    /**
+     * - **`none`**: a ? b ? c -> syntax error
+     * - **`any`**: a + b + c -> +(a, b, c)
+     * - **`left`**: a / b / c -> /(/(a, b), c)
+     * - **`right`**: a = b = c -> =(a, =(b, c))
+     *
+     * - `any`-associative operators have an unlimited number of arguments
+     * - `left`, `right` or `none` associative operators have two arguments
+     *
+     */
+    associativity?: 'right' | 'left' | 'none' | 'any';
+    precedence?: Precedence;
+    parse?: string | InfixParseHandler;
+};
+/**
+ * @category Latex Parsing and Serialization
+ */
+export type PostfixEntry = BaseEntry & Trigger & {
+    /**
+     * Postfix position, with an operand before: `a ⊛`
+     *
+     * Example: `!`.
+     */
+    kind: 'postfix';
+    precedence?: Precedence;
+    parse?: string | PostfixParseHandler;
+};
+/**
+ * @category Latex Parsing and Serialization
+ */
+export type PrefixEntry = BaseEntry & Trigger & {
+    /**
+     * Prefix position, with an operand after: `⊛ a`
+     *
+     * Example: `-`, `\not`.
+     */
+    kind: 'prefix';
+    precedence: Precedence;
+    parse?: string | PrefixParseHandler;
+};
+/**
+ * A LaTeX dictionary entry for an environment, that is a LaTeX
+ * construct using `\begin{...}...\end{...}`.
+ * @category Latex Parsing and Serialization
+ */
+export type EnvironmentEntry = BaseEntry & {
+    kind: 'environment';
+    parse: EnvironmentParseHandler;
+    symbolTrigger: MathJsonSymbol;
+};
+/**
+ * @category Latex Parsing and Serialization
+ */
+export type SymbolEntry = BaseEntry & Trigger & {
+    kind: 'symbol';
+    /** Used for appropriate wrapping (i.e. when to surround it with parens) */
+    precedence?: Precedence;
+    parse: Expression | SymbolParseHandler;
+};
+/**
+ * A function is a symbol followed by:
+ * - some postfix operators such as `\prime`
+ * - an optional list of arguments in an enclosure (parentheses)
+ *
+ * For more complex situations, for example implicit arguments or
+ * inverse functions postfix (i.e. ^{-1}), use a custom parse handler with a
+ * entry of kind `expression`.
+ * @category Latex Parsing and Serialization
+ */
+export type FunctionEntry = BaseEntry & Trigger & {
+    kind: 'function';
+    parse?: Expression | FunctionParseHandler;
+};
+/**
+ *
+ * A dictionary entry is a record that maps a LaTeX token or string of tokens
+ * ( a trigger) to a MathJSON expression or to a parsing handler.
+ *
+ * Set the {@linkcode ComputeEngine.latexDictionary} property to an array of
+ * dictionary entries to define custom LaTeX parsing and serialization.
+ *
+ * @category Latex Parsing and Serialization
+ *
+ */
+export type LatexDictionaryEntry = OneOf<[
+    ExpressionEntry | MatchfixEntry | InfixEntry | PostfixEntry | PrefixEntry | SymbolEntry | FunctionEntry | EnvironmentEntry | DefaultEntry
+]>;
+/** @internal */
+export declare function isExpressionEntry(entry: LatexDictionaryEntry): entry is ExpressionEntry;
+/** @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;
+/** @internal */
+export declare function isPrefixEntry(entry: LatexDictionaryEntry): entry is PrefixEntry;
+/** @internal */
+export declare function isPostfixEntry(entry: LatexDictionaryEntry): entry is PostfixEntry;
+/** @internal */
+export declare function isEnvironmentEntry(entry: LatexDictionaryEntry): entry is EnvironmentEntry;
+/**
+ * A LaTeX dictionary is a collection of LaTeX dictionary entries.
+ *
+ * Each entry in the dictionary indicates how to parse and serialize a
+ * particular LaTeX token or string of tokens.
+ *
+ * @category Latex Parsing and Serialization
+ * @internal
+ */
+export type LatexDictionary = ReadonlyArray<Partial<LatexDictionaryEntry>>;
+/**
+ * These options control how numbers are parsed and serialized.
+ * @category Serialization
+ */
+export type NumberFormat = {
+    positiveInfinity: LatexString;
+    negativeInfinity: LatexString;
+    notANumber: LatexString;
+    imaginaryUnit: LatexString;
+    /**
+     * A string representing the decimal separator, the string separating
+     * the whole portion of a number from the fractional portion, i.e.
+     * the "." in "3.1415".
+     *
+     * Some countries use a comma rather than a dot. In this case it is
+     * recommended to use `"{,}"` as the separator: the surrounding brackets
+     * ensure there is no additional gap after the comma.
+     *
+     * **Default**: `"."`
+     */
+    decimalSeparator: LatexString;
+    /**
+     * A string representing the separator between groups of digits,
+     * to make numbers with many digits easier to read.
+     *
+     * If a single string is provided, it is used to group digits in the
+     * whole and the fractional part of the number. If two strings are provided,
+     * the first is used for the whole part and the second for the fractional
+     * part.
+     *
+     * Caution: some values may lead to unexpected results.
+     *
+     * For example, if the `digitGroupSeparator` is `,` (comma) the expression
+     * `\operatorname{Hypot}(1,2)` will parse as `["Hypot", 1.2]` rather than
+     * `["Hypot", 1, 2]`. You can however use `{,}` which will avoid this issue
+     * and display with correct spacing.
+     *
+     * **Default**: `"\\,"` (thin space, 3/18mu) (Resolution 7 of the 1948 CGPM)
+     */
+    digitGroupSeparator: LatexString | [LatexString, LatexString];
+    /**
+     * Maximum length of digits between digit group separators.
+     *
+     * If a single number is provided, it is used for the whole and the fractional
+     * part of the number. If two numbers are provided, the first is used for the
+     * whole part and the second for the fractional part.
+     *
+     * If '`"lakh"`' is provided, the number is grouped in groups of 2 digits,
+     * except for the last group which has 3 digits. For example: `1,00,00,000`.
+     *
+     *
+     * **Default**: `3`
+     */
+    digitGroup: 'lakh' | number | [number | 'lakh', number];
+    exponentProduct: LatexString;
+    beginExponentMarker: LatexString;
+    endExponentMarker: LatexString;
+    truncationMarker: LatexString;
+    repeatingDecimal: 'auto' | 'vinculum' | 'dots' | 'parentheses' | 'arc' | 'none';
+};
+/** @category Serialization */
+export type NumberSerializationFormat = NumberFormat & {
+    /**
+     * The maximum number of significant digits in serialized numbers.
+     * - `"max"`: all availabe digits are serialized.
+     * - `"auto"`: use the same precision as the compute engine.
+     *
+     * Default: `"auto"`
+     */
+    fractionalDigits: 'auto' | 'max' | number;
+    notation: 'auto' | 'engineering' | 'scientific' | 'adaptiveScientific';
+    avoidExponentsInRange: undefined | null | [negativeExponent: number, positiveExponent: number];
+};
+/**
+ *
+ * The LaTeX parsing options can be used with the `ce.parse()` method.
+ *
+ * @category Latex Parsing and Serialization
+ */
+export type ParseLatexOptions = NumberFormat & {
+    /**
+     * If true, ignore space characters in math mode.
+     *
+     * **Default**: `true`
+     *
+     */
+    skipSpace: boolean;
+    /**
+     * When parsing a decimal number, e.g. `3.1415`:
+     *
+     * - `"auto"` or `"decimal"`: if a decimal number, parse it as an approximate
+     *   decimal number with a whole part and a fractional part
+     * - `"rational"`: if a decimal number, parse it as an exact rational number
+     *   with a numerator  and a denominator. If not a decimal number, parse
+     *   it as a regular number.
+     * - `"never"`: do not parse numbers, instead return each token making up
+     *  the number (minus sign, digits, decimal marker, etc...).
+     *
+     * Note: if the number includes repeating digits (e.g. `1.33(333)`),
+     * it will be parsed as a decimal number even if this setting is `"rational"`.
+     *
+     * **Default**: `"auto"`
+     *
+     */
+    parseNumbers: 'auto' | 'rational' | 'decimal' | 'never';
+    /**
+     * This handler is invoked when the parser encounters a
+     * that has not yet been declared.
+     *
+     * The `symbol` argument is a [valid symbol](/math-json/#symbols).
+     *
+     */
+    getSymbolType: (symbol: MathJsonSymbol) => BoxedType;
+    /** This handler is invoked when the parser encounters an unexpected token.
+     *
+     * The `lhs` argument is the left-hand side of the token, if any.
+     *
+     * The handler can access the unexpected token with `parser.peek`. If
+     * it is a token that should be recognized, the handler can consume it
+     * by calling `parser.nextToken()`.
+     *
+     * The handler should return an expression or `null` if the token is not
+     * recognized.
+     */
+    parseUnexpectedToken: (lhs: Expression | null, parser: Parser) => Expression | null;
+    /**
+     * If true, the expression will be decorated with the LaTeX
+     * fragments corresponding to each elements of the expression.
+     *
+     * The top-level expression, that is the one returned by `parse()`, will
+     * include the verbatim LaTeX input that was parsed. The sub-expressions
+     * may contain a slightly different LaTeX, for example with consecutive spaces
+     * replaced by one, with comments removed and with some low-level LaTeX
+     * commands replaced, for example `\egroup` and `\bgroup`.
+     *
+     * **Default:** `false`
+     */
+    preserveLatex: boolean;
+    /**
+     * Controls how quantifier scope is determined when parsing expressions
+     * like `\forall x. P(x) \rightarrow Q(x)`.
+     *
+     * - `"tight"`: The quantifier binds only to the immediately following
+     *   well-formed formula, stopping at logical connectives (`\rightarrow`,
+     *   `\implies`, `\land`, `\lor`, etc.). This follows standard First-Order
+     *   Logic conventions. Use explicit parentheses for wider scope:
+     *   `\forall x. (P(x) \rightarrow Q(x))`.
+     *
+     * - `"loose"`: The quantifier scope extends to the end of the expression
+     *   or until a lower-precedence operator is encountered.
+     *
+     * **Default:** `"tight"`
+     *
+     * @example
+     * // With "tight" (default):
+     * // \forall x. P(x) \rightarrow Q(x)
+     * // parses as: (∀x. P(x)) → Q(x)
+     *
+     * // With "loose":
+     * // \forall x. P(x) \rightarrow Q(x)
+     * // parses as: ∀x. (P(x) → Q(x))
+     */
+    quantifierScope: 'tight' | 'loose';
+};
+/**
+ *
+ * The expected format of numbers in the LaTeX string can be specified with
+ * the `ce.parse()` method.
+ *
+ * @category Latex Parsing and Serialization
+ */
+/**
+ * An instance of `Parser` is provided to the `parse` handlers of custom
+ * LaTeX dictionary entries.
+ *
+ * @category Latex Parsing and Serialization
+ */
+export interface Parser {
+    readonly options: Required<ParseLatexOptions>;
+    getSymbolType(id: MathJsonSymbol): BoxedType;
+    pushSymbolTable(): void;
+    popSymbolTable(): void;
+    addSymbol(id: MathJsonSymbol, type: BoxedType | TypeString): void;
+    /** True if currently parsing inside a quantifier body (ForAll, Exists, etc.) */
+    readonly inQuantifierScope: boolean;
+    /** Enter a quantifier scope for parsing the body of ForAll, Exists, etc. */
+    enterQuantifierScope(): void;
+    /** Exit the current quantifier scope */
+    exitQuantifierScope(): void;
+    /** The index of the current token */
+    index: number;
+    /** True if the last token has been reached.
+     * Consider also `atTerminator()`.
+     */
+    readonly atEnd: boolean;
+    /** Return true if the terminator condition is met or if the last token
+     * has been reached.
+     */
+    atTerminator(t: Terminator | undefined): boolean;
+    /** Return the next token, without advancing the index */
+    readonly peek: LatexToken;
+    /** Return the next token and advance the index */
+    nextToken(): LatexToken;
+    /** Return a string representation of the expression
+     * between `start` and `end` (default: the whole expression)
+     *
+     *
+     */
+    latex(start: number, end?: number): string;
+    /** Return an error expression with the specified code and arguments */
+    error(code: string | [string, ...Expression[]], fromToken: number): Expression;
+    /** If there are any space, advance the index until a non-space is encountered */
+    skipSpace(): boolean;
+    /** Skip over "visual space" which
+    includes space tokens, empty groups `{}`, and commands such as `\,` and `\!` */
+    skipVisualSpace(): void;
+    /** If the next token matches the target advance and return true. Otherwise
+     * return false
+     */
+    match(token: LatexToken): boolean;
+    /** Return true if the next tokens match the argument, an array of tokens, or null otherwise
+     */
+    matchAll(tokens: LatexToken[]): boolean;
+    /** Return the next token if it matches any of the token in the argument or null otherwise
+     */
+    matchAny(tokens: LatexToken[]): LatexToken;
+    /** 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.
+     */
+    parseChar(): string | null;
+    /**
+     * Parse an expression in a LaTeX group enclosed in curly brackets `{}`.
+     * These are often used as arguments to LaTeX commands, for example
+     * `\frac{1}{2}`.
+     *
+     * Return `null` if none was found
+     * Return `Nothing` if an empty group `{}` was found
+     */
+    parseGroup(): Expression | null;
+    /**
+     * Some LaTeX commands (but not all) can accept arguments as single
+     * tokens (i.e. without braces), for example `^2`, `\sqrt3` or `\frac12`
+     *
+     * This argument will usually be a single token, but can be a sequence of
+     * tokens (e.g. `\sqrt\frac12` or `\sqrt\operatorname{speed}`).
+     *
+     * The following tokens are excluded from consideration in order to fail
+     * early when encountering a likely syntax error, for example `x^(2)`
+     * instead of `x^{2}`. With `(` in the list of excluded tokens, the
+     * match will fail and the error can be recovered.
+     *
+     * The excluded tokens include `!"#$%&(),/;:?@[]`|~", `\left`, `\bigl`, etc...
+     */
+    parseToken(): Expression | null;
+    /**
+     * Parse an expression enclosed in a LaTeX optional group enclosed in square brackets `[]`.
+     *
+     * Return `null` if none was found.
+     */
+    parseOptionalGroup(): Expression | null;
+    /** Parse an enclosure (open paren/close paren, etc..) and return the expression inside the enclosure */
+    parseEnclosure(): Expression | null;
+    /**
+     * Some LaTeX commands have arguments that are not interpreted as
+     * expressions, but as strings. For example, `\begin{array}{ccc}` (both
+     * `array` and `ccc` are strings), `\color{red}` or `\operatorname{lim sup}`.
+     *
+     * If the next token is the start of a group (`{`), return the content
+     * of the group as a string. This may include white space, and it may need
+     * to be trimmed at the start and end of the string.
+     *
+     * LaTeX commands are typically not allowed inside a string group (for example,
+     * `\alpha` would result in an error), but we do not enforce this.
+     *
+     * If `optional` is true, this should be an optional group in square brackets
+     * otherwise it is a regular group in braces.
+     */
+    parseStringGroup(optional?: boolean): string | null;
+    /**
+     * A symbol can be:
+     * - a single-letter symbol: `x`
+     * - a single LaTeX command: `\pi`
+     * - a multi-letter symbol: `\operatorname{speed}`
+     */
+    parseSymbol(until?: Partial<Terminator>): Expression | null;
+    /**
+     * Parse an expression in a tabular format, where rows are separated by `\\`
+     * and columns by `&`.
+     *
+     * Return rows of sparse columns: empty rows are indicated with `Nothing`,
+     * and empty cells are also indicated with `Nothing`.
+     */
+    parseTabular(): null | Expression[][];
+    /**
+     * Parse an argument list, for example: `(12, x+1)` or `\left(x\right)`
+     *
+     * - 'enclosure' : will look for arguments inside an enclosure
+     *    (an open/close fence) (**default**)
+     * - 'implicit': either an expression inside a pair of `()`, or just a primary
+     *    (i.e. we interpret `\cos x + 1` as `\cos(x) + 1`)
+     *
+     * Return an array of expressions, one for each argument, or `null` if no
+     * argument was found.
+     */
+    parseArguments(kind?: 'implicit' | 'enclosure', until?: Terminator): ReadonlyArray<Expression> | null;
+    /**
+     * Parse a postfix operator, such as `'` or `!`.
+     *
+     * Prefix, infix and matchfix operators are handled by `parseExpression()`
+     *
+     */
+    parsePostfixOperator(lhs: Expression | null, until?: Partial<Terminator>): Expression | null;
+    /**
+     * Parse an expression:
+     *
+     * ```
+     * <expression> ::=
+     *  | <primary> ( <infix-op> <expression> )?
+     *  | <prefix-op> <expression>
+     *
+     * <primary> :=
+     *   (<number> | <symbol> | <function-call> | <matchfix-expr>)
+     *   (<subsup> | <postfix-operator>)*
+     *
+     * <matchfix-expr> :=
+     *   <matchfix-op-open> <expression> <matchfix-op-close>
+     *
+     * <function-call> ::=
+     *   | <function><matchfix-op-group-open><expression>[',' <expression>]<matchfix-op-group-close>
+     * ```
+     *
+     * This is the top-level parsing entry point.
+     *
+     * Stop when an operator of precedence less than `until.minPrec`
+     * or the sequence of tokens `until.tokens` is encountered
+     *
+     * `until` is `{ minPrec:0 }` by default.
+     */
+    parseExpression(until?: Partial<Terminator>): Expression | null;
+    /**
+     * Parse a number.
+     */
+    parseNumber(): Expression | null;
+    /**
+     * Boundaries are used to detect the end of an expression.
+     *
+     * They are used for unusual syntactic constructs, for example
+     * `\int \sin x dx` where the `dx` is not an argument to the `\sin`
+     * function, but a boundary of the integral.
+     *
+     * They are also useful when handling syntax errors and recovery.
+     *
+     * For example, `\begin{bmatrix} 1 & 2 { \end{bmatrix}` has an
+     * extraneous `{`, but the parser will attempt to recover and continue
+     * parsing when it encounters the `\end{bmatrix}` boundary.
+     */
+    addBoundary(boundary: LatexToken[]): void;
+    removeBoundary(): void;
+    get atBoundary(): boolean;
+    matchBoundary(): boolean;
+    boundaryError(msg: string | [string, ...Expression[]]): Expression;
+}
+/**
+ *
+ * The LaTeX serialization options can used with the `expr.toLatex()` method.
+ *
+ * @category Latex Parsing and Serialization
+ */
+export type SerializeLatexOptions = NumberSerializationFormat & {
+    /**
+     * If true, prettify the LaTeX output.
+     *
+     * For example, render `\frac{a}{b}\frac{c}{d}` as `\frac{ac}{bd}`
+     *
+     */
+    prettify: boolean;
+    /**
+     * Controls the materialization of the lazy collections.
+     *
+     * - If `true`, lazy collections are materialized, i.e. it is rendered as a
+     *   LaTeX expression with all its elements.
+     * - If `false`, the expression is not materialized, i.e. it is
+     *   rendered as a LaTeX command with its arguments.
+     * - If a number is provided, it is the maximum number of elements
+     *   that will be materialized.
+     * - If a pair of numbers is provided, it is the number of elements
+     *   of the head and the tail that will be materialized, respectively.
+     */
+    materialization: boolean | number | [number, number];
+    /**
+     * LaTeX string used to render an invisible multiply, e.g. in '2x'.
+     *
+     * If empty, both operands are concatenated, i.e. `2x`.
+     *
+     * Use `\cdot` to insert a `\cdot` operator between them, i.e. `2 \cdot x`.
+     *
+     * Empty by default.
+     */
+    invisibleMultiply: LatexString;
+    /**
+     * LaTeX string used to render [mixed numbers](https://en.wikipedia.org/wiki/Fraction#Mixed_numbers) e.g. '1 3/4'.
+     *
+     * Leave it empty to join the main number and the fraction, i.e. render it
+     * as `1\frac{3}{4}`.
+     *
+     * Use `+` to insert an explicit `+` operator between them,
+     *  i.e. `1+\frac{3}{4}`
+     *
+     * Empty by default.
+     */
+    invisiblePlus: LatexString;
+    /**
+     * LaTeX string used to render an explicit multiply operator.
+     *
+     * For example, `\times`, `\cdot`, etc...
+     *
+     * Default: `\times`
+     */
+    multiply: LatexString;
+    /**
+     * Serialize the expression `["Error", "'missing'"]`,  with this LaTeX string
+     *
+     */
+    missingSymbol: LatexString;
+    applyFunctionStyle: (expr: Expression, level: number) => DelimiterScale;
+    groupStyle: (expr: Expression, level: number) => DelimiterScale;
+    rootStyle: (expr: Expression, level: number) => 'radical' | 'quotient' | 'solidus';
+    fractionStyle: (expr: Expression, level: number) => 'quotient' | 'block-quotient' | 'inline-quotient' | 'inline-solidus' | 'nice-solidus' | 'reciprocal' | 'factor';
+    logicStyle: (expr: Expression, level: number) => 'word' | 'boolean' | 'uppercase-word' | 'punctuation';
+    powerStyle: (expr: Expression, level: number) => 'root' | 'solidus' | 'quotient';
+    numericSetStyle: (expr: Expression, level: number) => 'compact' | 'regular' | 'interval' | 'set-builder';
+};
+/**
+ *
+ * An instance of `Serializer` is provided to the `serialize` handlers of custom
+ * LaTeX dictionary entries.
+ *
+ * @category Latex Parsing and Serialization
+ *
+ */
+export interface Serializer {
+    readonly options: Required<SerializeLatexOptions>;
+    readonly dictionary: IndexedLatexDictionary;
+    /** "depth" of the expression:
+     * - 0 for the root
+     * - 1 for a subexpression of the root
+     * - 2 for subexpressions of the subexpressions of the root
+     * - etc...
+     *
+     * This allows the serialized LaTeX to vary depending on the depth of the
+     * expression.
+     *
+     * For example use `\Bigl(` for the top level, and `\bigl(` or `(` for others.
+     */
+    level: number;
+    /** Output a LaTeX string representing the expression */
+    serialize: (expr: Expression | null | undefined) => string;
+    serializeFunction(expr: Expression, def?: IndexedLatexDictionaryEntry): LatexString;
+    serializeSymbol(expr: Expression): LatexString;
+    /** Output `s` surrounded by delimiters.
+     *
+     * If `delimiters` is not specified, use `()`
+     *
+     */
+    wrapString(s: LatexString, style: DelimiterScale, delimiters?: string): LatexString;
+    /** A string with the arguments of expr fenced appropriately and separated by
+     * commas.
+     */
+    wrapArguments(expr: Expression): LatexString;
+    /** Add a group fence around the expression if it is
+     * an operator of precedence less than or equal to `prec`.
+     */
+    wrap: (expr: Expression | null | undefined, prec?: number) => LatexString;
+    /** Add a group fence around the expression if it is
+     * short (not a function)
+     */
+    wrapShort(expr: Expression | null | undefined): LatexString;
+    /** Styles */
+    applyFunctionStyle: (expr: Expression, level: number) => DelimiterScale;
+    groupStyle: (expr: Expression, level: number) => DelimiterScale;
+    rootStyle: (expr: Expression, level: number) => 'radical' | 'quotient' | 'solidus';
+    fractionStyle: (expr: Expression, level: number) => 'quotient' | 'block-quotient' | 'inline-quotient' | 'inline-solidus' | 'nice-solidus' | 'reciprocal' | 'factor';
+    logicStyle: (expr: Expression, level: number) => 'word' | 'boolean' | 'uppercase-word' | 'punctuation';
+    powerStyle: (expr: Expression, level: number) => 'root' | 'solidus' | 'quotient';
+    numericSetStyle: (expr: Expression, level: number) => 'compact' | 'regular' | 'interval' | 'set-builder';
+}
+/** The `serialize` handler of a custom LaTeX dictionary entry can be
+ * a function of this type.
+ *
+ * @category Latex Parsing and Serialization
+ *
+ */
+export type SerializeHandler = (serializer: Serializer, expr: Expression) => string;