@cortex-js/compute-engine 0.24.0 → 0.25.0

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

@@ -1,26 +1,36 @@
-/* 0.24.0 */
-import { Expression } from '../../math-json/math-json-format';
-import type { IComputeEngine } from '../public';
+/* 0.25.0 */
+export type SymbolType = 'symbol' | 'function' | 'unknown';
+export type SymbolTable = {
+    parent: SymbolTable | null;
+    ids: {
+        [id: string]: SymbolType;
+    };
+};
 /**
- * A `LatexToken` is a token as returned by `Scanner.peek`.
+ * 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';
+/** @category Latex Parsing and Serialization */
+export type DelimiterScale = 'normal' | 'scaled' | 'big' | 'none';
 /**
  * @category Latex Parsing and Serialization
  */
@@ -96,7 +106,8 @@ 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;
+ * - or if a condition is provided, the condition returns true
+ *
  * @category Latex Parsing and Serialization
  */
 export type Terminator = {
@@ -106,11 +117,11 @@ export type Terminator = {
 /**
  * Custom parsing handler.
  *
- * When invoked the scanner points right after the LaTeX fragment that triggered
+ * When invoked the parser points right after the LaTeX fragment that triggered
  * this parsing handler.
  *
- * The scanner should be moved, by calling `scanner.next()` for every consumed
- * token.
+ * The parser should be moved, by calling `parser.nextToken()` for
+ * every consumed token.
  *
  * 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`.
@@ -159,15 +170,14 @@ export type MatchfixParseHandler = (parser: Parser, body: Expression) => Express
  */
 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` */
 /**
- * The trigger is the set of tokens that will make this record eligible to
- * parse the stream and generate an expression. If the trigger matches,
- * the `parse` handler is called, if available.
+ * 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 identifier (`identifierTrigger`), which can be wrapped in a LaTeX
- * command, for example `\operatorname{mod}` or `\mathbin{gcd}`, with `"gcd"`
- *  being the `identifierTrigger`.
- *
+ * as an identifier (`identifierTrigger`). An identifier match several
+ * LaTeEx expressions that are equivalent, for example `\operatorname{gcd}` or
+ *  `\mathbin{gcd}`, match the `"gcd"` identifier
  *
  * `matchfix` operators use `openTrigger` and `closeTrigger` instead.
  *
@@ -183,14 +193,16 @@ export type Trigger = {
  */
 export type BaseEntry = {
     /**
-     * Map a MathJSON function or symbol name to this entry.
+     * Map a MathJSON identifier 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`).
+     * 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
@@ -199,7 +211,7 @@ export type BaseEntry = {
     name?: string;
     /**
      * Transform an expression into a LaTeX string.
-     * If no `serialize` handler is provided, the `trigger` property is used
+     * If no `serialize` handler is provided, the trigger is used.
      */
     serialize?: LatexString | SerializeHandler;
 };
@@ -245,16 +257,16 @@ export type InfixEntry = BaseEntry & Trigger & {
      */
     kind: 'infix';
     /**
-     * - **`both`**: a + b + c  +(a, b, c)
+     * - **`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))
-     * - **`non`**: a < b < c -> syntax error
      *
-     * - a `both`-associative operator has an unlimited number of arguments
-     * - a `left`, `right` or `non` associative operator has at most two arguments
+     * - `any`-associative operators have an unlimited number of arguments
+     * - `left`, `right` or `none` associative operators have two arguments
      *
      */
-    associativity?: 'right' | 'left' | 'non' | 'both';
+    associativity?: 'right' | 'left' | 'none' | 'any';
     precedence?: Precedence;
     parse?: string | InfixParseHandler;
 };
@@ -320,7 +332,7 @@ export type FunctionEntry = BaseEntry & Trigger & {
 /**
  *
  * A dictionary entry is a record that maps a LaTeX token or string of tokens
- * to a MathJSON expression or to a parsing handler.
+ * ( 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.
@@ -346,19 +358,93 @@ export declare function isPostfixEntry(entry: LatexDictionaryEntry): entry is Po
 /** @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 = Array<Partial<LatexDictionaryEntry>>;
+export type LatexDictionary = ReadonlyArray<Partial<LatexDictionaryEntry>>;
+/**
+ * These options control how numbers are parsed and serialized.
+ */
+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';
+};
+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';
+    avoidExponentsInRange: undefined | null | [negativeExponent: number, positiveExponent: number];
+};
 /**
  *
- * The LaTeX parsing options can be set using the
- * {@linkcode ComputeEngine.latexOptions} property.
+ * The LaTeX parsing options can be used with the `ce.parse()` method.
  *
  * @category Latex Parsing and Serialization
  */
-export type ParseLatexOptions = {
+export type ParseLatexOptions = NumberFormat & {
     /**
      * If true, ignore space characters in math mode.
      *
@@ -367,18 +453,9 @@ export type ParseLatexOptions = {
      */
     skipSpace: boolean;
     /**
-     * When an unknown LaTeX command is encountered, attempt to parse
-     * any arguments it may have.
+     * When parsing a decimal number, e.g. `3.1415`:
      *
-     * For example, `\foo{x+1}` would produce `['\foo', ['Add', 'x', 1]]` if
-     * this property is true, `['LatexSymbols', '\foo', '<{>', 'x', '+', 1, '<{>']`
-     * otherwise.
-     */
-    parseArgumentsOfUnknownLatexCommands: boolean;
-    /**
-     * When parsing a decimal number (e.g. `3.1415`):
-     *
-     * - `"auto"` or `"decimal"`: if a decimal number parse it as an approximate
+     * - `"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
@@ -395,21 +472,32 @@ export type ParseLatexOptions = {
     parseNumbers: 'auto' | 'rational' | 'decimal' | 'never';
     /**
      * This handler is invoked when the parser encounters an identifier
-     * that does not have a corresponding entry in the dictionary.
+     * that has not yet been declared.
      *
      * The `identifier` argument is a (valid identifier)[/math-json/#identifiers].
      *
      * The handler can return:
      *
-     * - `"symbol"`: the identifier is a constant or variable name.
-     *
+     * - `"variable"`: the identifier is a variable
      * - `"function"`: the identifier is a function name. If an apply
      * function operator (typically, parentheses) follow, they will be parsed
      * as arguments to the function.
      *
      * - `"unknown"`: the identifier is not recognized.
      */
-    parseUnknownIdentifier: (identifier: string, parser: Parser) => 'symbol' | 'function' | 'unknown';
+    getIdentifierType: (identifier: string) => SymbolType;
+    /** 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.
@@ -424,213 +512,13 @@ export type ParseLatexOptions = {
      */
     preserveLatex: boolean;
 };
-/** @category Latex Parsing and Serialization */
-export type DelimiterScale = 'normal' | 'scaled' | 'big' | 'none';
-/**
- *
- * The LaTeX serialization options can be set using the
- * {@linkcode ComputeEngine.latexOptions} property.
- *
- * @category Latex Parsing and Serialization
- */
-export type SerializeLatexOptions = {
-    /**
-     * LaTeX string used to render an invisible multiply, e.g. in '2x'.
-     *
-     * Leave it empty to join the adjacent terms, 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 for an invisible plus with mixed numbers e.g. in '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 for an explicit multiply operator,
-     *
-     * Default: `\times`
-     */
-    multiply: LatexString;
-    /**
-     * When an expression contains the error expression `["Error", 'missing']`,
-     * serialize it 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';
-};
-/**
- *
- * The options to format numbers can be set using the
- * {@linkcode ComputeEngine.latexOptions} property.
- *
- * @category Latex Parsing and Serialization
- */
-export type NumberFormattingOptions = {
-    precision: number;
-    positiveInfinity: LatexString;
-    negativeInfinity: LatexString;
-    notANumber: LatexString;
-    /**
-     * A string representing the decimal marker, 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 marker: the surrounding brackets ensure
-     * there is no additional gap after the comma.
-     *
-     * **Default**: `"."`
-     */
-    decimalMarker: LatexString;
-    /**
-     * A string representing the separator between groups of digits,
-     * used to improve readability of numbers with lots of digits.
-     *
-     * If you change it to another value, be aware that this may lead to
-     * unexpected results. For example, if changing it to `,` the expression
-     * `\operatorname{Hypot}(1,2)` will parse as `["Hypot", 1.2]` rather than
-     * `["Hypot", 1, 2]`.
-     *
-     * **Default**: `"\\,"` (thin space, 3/18mu) (Resolution 7 of the 1948 CGPM)
-     */
-    groupSeparator: LatexString;
-    exponentProduct: LatexString;
-    beginExponentMarker: LatexString;
-    endExponentMarker: LatexString;
-    notation: 'engineering' | 'auto' | 'scientific';
-    truncationMarker: LatexString;
-    beginRepeatingDigits: LatexString;
-    endRepeatingDigits: LatexString;
-    imaginaryUnit: LatexString;
-    avoidExponentsInRange: undefined | null | [negativeExponent: number, positiveExponent: number];
-};
 /**
- * The {@linkcode ComputeEngine.latexSyntax} property is an instance of
- * `LatexSyntax` that can be used to parse and serialize LaTeX strings.
- *
- * Its methods are exposed with `ce.parse`, `ce.serialize` and
- * `ce.getLatexDictionary`.
- *
- * @category Latex Parsing and Serialization
- * @internal
- */
-export declare class LatexSyntax {
-    /**
-     *
-     * @param options.onError - Called when a non-fatal error is encountered. When parsing,
-     * the parser will attempt to recover and continue.
-     *
-     */
-    constructor(options?: NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions & {
-        onError?: WarningSignalHandler;
-        dictionary?: LatexDictionary;
-    });
-    /**
-     * Return a LaTeX dictionary suitable for the specified category, or `"all"`
-     * for all categories (`"arithmetic"`, `"algebra"`, etc...).
-     *
-     * A LaTeX dictionary is needed to translate between LaTeX and MathJSON.
-     *
-     * Each entry in the dictionary indicate how a LaTeX token (or string of
-     * tokens) should be parsed into a MathJSON expression.
-     *
-     * For example an entry can define that the `\pi` LaTeX token should map to the
-     * symbol `"Pi"`, or that the token `-` should map to the function
-     * `["Negate",...]` when in a prefix position and to the function
-     * `["Subtract", ...]` when in an infix position.
-     *
-     * Furthermore, the information in each dictionary entry is used to serialize
-     * the LaTeX string corresponding to a MathJSON expression.
-     *
-     * Use the value returned by this function to the `options` argument of the
-     * constructor.
-     */
-    static getDictionary(domain?: LibraryCategory | 'all'): Readonly<LatexDictionary>;
-    /** Parse a  */
-    parse(latex: LatexString): Expression;
-    serialize(expr: Expression): LatexString;
-}
-/**
- *
- * An instance of `Serializer` is provided to the `serialize` handlers of custom
- * LaTeX dictionary entries.
  *
- * @category Latex Parsing and Serialization
- *
- */
-export interface Serializer {
-    readonly onError: WarningSignalHandler;
-    readonly options: Required<SerializeLatexOptions>;
-    /** "depth" of the expression:
-     * - 0 for the root
-     * - 1 for the arguments of the root
-     * - 2 for the arguments of the arguments of the root
-     * - etc...
-     *
-     * This allows for variation of the LaTeX serialized based
-     * on the depth of the expression, for example using `\Bigl(`
-     * for the top level, and `\bigl(` or `(` for others.
-     */
-    level: number;
-    /** If true, apply transformations to the expression so the output
-     * doesn't necesarily match the raw MathJSON, but is more visually pleasing
-     * and easier to read. If false, output the raw MathJSON. */
-    canonical?: boolean;
-    /** Output a LaTeX string representing the expression */
-    serialize: (expr: Expression | null) => string;
-    /** Output `s` surrounded by delimiters.
-     *
-     * If `delimiters` is not specified, use `()`
-     *
-     */
-    wrapString(s: string, style: DelimiterScale, delimiters?: string): string;
-    /** A string with the arguments of expr fenced appropriately and separated by
-     * commas.
-     */
-    wrapArguments(expr: Expression): string;
-    /** Add a group fence around the expression if it is
-     * an operator of precedence less than or equal to `prec`.
-     */
-    wrap: (expr: Expression | null, prec?: number) => string;
-    /** Add a group fence around the expression if it is
-     * short (not a function)
-     */
-    wrapShort(expr: Expression | null): string;
-    /** 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';
-    serializeFunction(expr: Expression): LatexString;
-    serializeSymbol(expr: Expression): LatexString;
-}
-/** The `serialize` handler of a custom LaTeX dictionary entry can be
- * a function of this type.
+ * The expected format of numbers in the LaTeX string can be specified with
+ * the `ce.parse()` method.
  *
  * @category Latex Parsing and Serialization
- *
  */
-export type SerializeHandler = (serializer: Serializer, expr: Expression) => string;
 /**
  * An instance of `Parser` is provided to the `parse` handlers of custom
  * LaTeX dictionary entries.
@@ -639,7 +527,10 @@ export type SerializeHandler = (serializer: Serializer, expr: Expression) => str
  */
 export interface Parser {
     readonly options: Required<ParseLatexOptions>;
-    readonly computeEngine?: IComputeEngine;
+    getIdentifierType(id: string): SymbolType;
+    pushSymbolTable(): void;
+    popSymbolTable(): void;
+    addSymbol(id: string, type: SymbolType): void;
     /** The index of the current token */
     index: number;
     /** True if the last token has been reached.
@@ -655,7 +546,10 @@ export interface Parser {
     /** 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) */
+     * 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;
@@ -665,11 +559,14 @@ export interface Parser {
     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 */
+     * return false
+     */
     match(token: LatexToken): boolean;
-    /** Return true if the next tokens match the argument, an array of tokens, or null otherwise */
+    /** 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 */
+    /** 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
@@ -806,3 +703,118 @@ export interface Parser {
     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;
+    /**
+     * 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 e.g. in '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.
+     *
+     * 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>;
+    /** "depth" of the expression:
+     * - 0 for the root
+     * - 1 for the arguments of the root
+     * - 2 for the arguments of the arguments 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) => string;
+    serializeFunction(expr: Expression): 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, prec?: number) => LatexString;
+    /** Add a group fence around the expression if it is
+     * short (not a function)
+     */
+    wrapShort(expr: Expression | null): 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;