@cortex-js/compute-engine 0.31.0 → 0.32.0

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

@@ -1,2 +0,0 @@
-/* 0.31.0 */
-export declare const DEFINITIONS_LINEAR_ALGEBRA: LatexDictionary;

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

@@ -1,2 +0,0 @@
-/* 0.31.0 */
-export declare const DEFINITIONS_LOGIC: LatexDictionary;

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

@@ -1,2 +0,0 @@
-/* 0.31.0 */
-export declare const DEFINITIONS_OTHERS: LatexDictionary;

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

@@ -1,2 +0,0 @@
-/* 0.31.0 */
-export declare const DEFINITIONS_INEQUALITIES: LatexDictionaryEntry[];

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

@@ -1,2 +0,0 @@
-/* 0.31.0 */
-export declare const DEFINITIONS_SETS: LatexDictionary;

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

@@ -1,2 +0,0 @@
-/* 0.31.0 */
-export declare const DEFINITIONS_STATISTICS: LatexDictionary;

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

@@ -1,3 +0,0 @@
-/* 0.31.0 */
-export declare const SYMBOLS: [string, string, number][];
-export declare const DEFINITIONS_SYMBOLS: LatexDictionary;

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

@@ -1,2 +0,0 @@
-/* 0.31.0 */
-export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary;

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

@@ -1,88 +0,0 @@
-/* 0.31.0 */
-import { Delimiter, EnvironmentParseHandler, ExpressionParseHandler, InfixParseHandler, LatexDictionary, LatexDictionaryEntry, LatexString, LatexToken, LibraryCategory, MatchfixParseHandler, PostfixParseHandler, Precedence, SerializeHandler } from '../types';
-export type CommonEntry = {
-    /** Note: a name is required if a serialize handler is provided */
-    name?: string;
-    serialize?: SerializeHandler;
-    /** Note: not all kinds have a `latexTrigger` or `symbolTrigger`.
-     * For example, matchfix operators use `openTrigger`/`closeTrigger`
-     */
-    latexTrigger?: LatexString;
-    symbolTrigger?: string;
-};
-export type IndexedSymbolEntry = CommonEntry & {
-    kind: 'symbol';
-    precedence: Precedence;
-    parse: ExpressionParseHandler;
-};
-/** @internal */
-export declare function isIndexedSymbolEntry(entry: IndexedLatexDictionaryEntry): entry is IndexedSymbolEntry;
-export type IndexedExpressionEntry = CommonEntry & {
-    kind: 'expression';
-    precedence: Precedence;
-    parse: ExpressionParseHandler;
-};
-/** @internal */
-export declare function isIndexedExpressionEntry(entry: IndexedLatexDictionaryEntry): entry is IndexedExpressionEntry;
-/**
- * A function has the following form:
- * - a prefix such as `\mathrm` or `\operatorname`
- * - a trigger string, such as `gcd`
- * - some postfix operators such as `\prime`
- * - an optional list of arguments in an enclosure (parentheses)
- *
- * Functions of this type are indexed in the dictionary by their trigger string.
- */
-export type IndexedFunctionEntry = CommonEntry & {
-    kind: 'function';
-    parse: ExpressionParseHandler;
-};
-/** @internal */
-export declare function isIndexedFunctionEntry(entry: IndexedLatexDictionaryEntry): entry is IndexedFunctionEntry;
-export type IndexedMatchfixEntry = CommonEntry & {
-    kind: 'matchfix';
-    openTrigger: Delimiter | LatexToken[];
-    closeTrigger: Delimiter | LatexToken[];
-    parse: MatchfixParseHandler;
-};
-/** @internal */
-export declare function isIndexedMatchfixEntry(entry: IndexedLatexDictionaryEntry): entry is IndexedMatchfixEntry;
-export type IndexedInfixEntry = CommonEntry & {
-    kind: 'infix';
-    associativity: 'right' | 'left' | 'none' | 'any';
-    precedence: Precedence;
-    parse: InfixParseHandler;
-};
-/** @internal */
-export declare function isIndexedInfixdEntry(entry: IndexedLatexDictionaryEntry): entry is IndexedInfixEntry;
-export type IndexedPrefixEntry = CommonEntry & {
-    kind: 'prefix';
-    precedence: Precedence;
-    parse: ExpressionParseHandler;
-};
-/** @internal */
-export declare function isIndexedPrefixedEntry(entry: IndexedLatexDictionaryEntry): entry is IndexedPostfixEntry;
-export type IndexedPostfixEntry = CommonEntry & {
-    kind: 'postfix';
-    precedence: Precedence;
-    parse: PostfixParseHandler;
-};
-/** @internal */
-export declare function isIndexedPostfixEntry(entry: IndexedLatexDictionaryEntry): entry is IndexedPostfixEntry;
-export type IndexedEnvironmentEntry = CommonEntry & {
-    kind: 'environment';
-    parse: EnvironmentParseHandler;
-};
-/** @internal */
-export declare function isIndexedEnvironmentEntry(entry: IndexedLatexDictionaryEntry): entry is IndexedEnvironmentEntry;
-export type IndexedLatexDictionaryEntry = IndexedExpressionEntry | IndexedFunctionEntry | IndexedSymbolEntry | IndexedMatchfixEntry | IndexedInfixEntry | IndexedPrefixEntry | IndexedPostfixEntry | IndexedEnvironmentEntry;
-export type IndexedLatexDictionary = {
-    ids: Map<string, IndexedLatexDictionaryEntry>;
-    lookahead: number;
-    defs: IndexedLatexDictionaryEntry[];
-};
-export declare function indexLatexDictionary(dic: Readonly<Partial<LatexDictionaryEntry>[]>, onError: (sig: WarningSignal) => void): IndexedLatexDictionary;
-export declare const DEFAULT_LATEX_DICTIONARY: {
-    [category in LibraryCategory]?: LatexDictionary;
-};
-export declare function getLatexDictionary(category?: LibraryCategory | 'all'): readonly Readonly<LatexDictionaryEntry>[];

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

@@ -1,21 +0,0 @@
-/* 0.31.0 */
-import { Parser } from './types';
-/** For error handling, if we have a symbol prefix, assume
- * the symbol is invalid (it would have been captured by
- * `matchSymbol()` otherwise) and return an error expression */
-export declare function parseInvalidSymbol(parser: Parser): Expression | null;
-/**
- * Match a symbol.
- *
- * It can be:
- * - a sequence of emojis: `👍🏻👍🏻👍🏻`
- * - a single-letter: `a`
- * - some LaTeX commands: `\alpha`
- * - a multi-letter id with a prefix: `\operatorname{speed}`
- * - an id with multiple prefixes:
- *  `\mathbin{\mathsf{T}}`
- * - an id with modifiers:
- *    - `\mathrm{\alpha_{12}}` or
- *    - `\mathit{speed\unicode{"2012}of\unicode{"2012}sound}`
- */
-export declare function parseSymbol(parser: Parser): MathJsonSymbol | null;

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

@@ -1,303 +0,0 @@
-/* 0.31.0 */
-import { ParseLatexOptions, LatexToken, Terminator, Parser, SymbolTable } from './types';
-import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry, IndexedInfixEntry, IndexedPostfixEntry, IndexedPrefixEntry, IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry } from './dictionary/definitions';
-import { BoxedType } from '../../common/type/boxed-type';
-import { TypeString } from '../types';
-/**
- * ## THEORY OF OPERATIONS
- *
- * The parser is a recursive descent parser that uses a dictionary of
- * LaTeX commands to parse a LaTeX string into a MathJSON expression.
- *
- * The parser is a stateful object that keeps track of the current position
- * in the token stream, and the boundaries of the current parsing operation.
- *
- * To parse correctly some constructs, the parser needs to know the context
- * in which it is parsing. For example, parsing `k(2+x)` can be interpreted
- * as a function `k` applied to the sum of `2` and `x`, or as the product
- * of `k` and the sum of `2` and `x`. The parser needs to know that `k` is
- * a function to interpret the expression as a function application.
- *
- * The parser uses the current state of the compute engine, and any
- * symbol that may have been declared, to determine the correct
- * interpretation.
- *
- * Some constructs declare variables or functions while parsing. For example,
- * `\sum_{i=1}^n i` declares the variable `i` as the index of the sum.
- *
- * The parser keeps track of the parsing state with a stack of symbol tables.
- *
- * In addition, the handler `getSymbolType()` is called when the parser
- * encounters an unknown symbol. This handler can be used to declare the
- * symbol, or to return `unknown` if the symbol is not known.
- *
- * Some functions affect the state of the parser:
- * - `Declare`, `Assign` modify the symbol table
- * - `Block` create a new symbol table (local scope)
- * - `Function` create a new symbol table with named arguments
- *
- *
- */
-export declare class _Parser implements Parser {
-    readonly options: Readonly<ParseLatexOptions>;
-    _index: number;
-    symbolTable: SymbolTable;
-    pushSymbolTable(): void;
-    popSymbolTable(): void;
-    addSymbol(id: string, type: BoxedType | TypeString): void;
-    get index(): number;
-    set index(val: number);
-    private _tokens;
-    private _positiveInfinityTokens;
-    private _negativeInfinityTokens;
-    private _notANumberTokens;
-    private _decimalSeparatorTokens;
-    private _wholeDigitGroupSeparatorTokens;
-    private _fractionalDigitGroupSeparatorTokens;
-    private _exponentProductTokens;
-    private _beginExponentMarkerTokens;
-    private _endExponentMarkerTokens;
-    private _truncationMarkerTokens;
-    private _imaginaryUnitTokens;
-    private readonly _dictionary;
-    private _boundaries;
-    private _lastPeek;
-    private _peekCounter;
-    constructor(tokens: LatexToken[], dictionary: IndexedLatexDictionary, options: Readonly<ParseLatexOptions>);
-    getSymbolType(id: MathJsonSymbol): BoxedType;
-    get peek(): LatexToken;
-    nextToken(): LatexToken;
-    get atEnd(): boolean;
-    /**
-     * Return true if
-     * - at end of the token stream
-     * - the `t.condition` function returns true
-     * Note: the `minPrec` condition is not checked. It should be checked separately.
-     */
-    atTerminator(t?: Readonly<Terminator>): boolean;
-    /**
-     * True if the current token matches any of the boundaries we are
-     * waiting for.
-     */
-    get atBoundary(): boolean;
-    addBoundary(boundary: LatexToken[]): void;
-    removeBoundary(): void;
-    matchBoundary(): boolean;
-    boundaryError(msg: string | [string, ...Expression[]]): Expression;
-    latex(start: number, end?: number): string;
-    private latexAhead;
-    /**
-     * Return at most `this._dictionary.lookahead` LaTeX tokens.
-     *
-     * 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.
-     *
-     * For example:
-     *
-     * `[empty, '\\sqrt', '\\sqrt{', '\\sqrt{2', '\\sqrt{2}']`
-     *
-     */
-    lookAhead(): [count: number, tokens: string][];
-    /** Return all the definitions that match the tokens ahead
-     *
-     * The return value is an array of pairs `[def, n]` where `def` is the
-     * definition that matches the tokens ahead, and `n` is the number of tokens
-     * that matched.
-     *
-     * Note the 'operator' kind matches both infix, prefix and postfix operators.
-     *
-     */
-    peekDefinitions(kind: 'expression'): [IndexedExpressionEntry, number][];
-    peekDefinitions(kind: 'function'): [IndexedFunctionEntry, number][];
-    peekDefinitions(kind: 'symbol'): [IndexedSymbolEntry, number][];
-    peekDefinitions(kind: 'postfix'): [IndexedPostfixEntry, number][];
-    peekDefinitions(kind: 'infix'): [IndexedInfixEntry, number][];
-    peekDefinitions(kind: 'prefix'): [IndexedPrefixEntry, number][];
-    peekDefinitions(kind: 'operator'): [IndexedInfixEntry | IndexedPrefixEntry | IndexedPostfixEntry, number][];
-    /** Skip strictly `<space>` tokens.
-     * To also skip `{}` see `skipSpace()`.
-     * To skip visual space (e.g. `\,`) see `skipVisualSpace()`.
-     */
-    skipSpaceTokens(): void;
-    /** While parsing in math mode, skip applicable spaces, which includes `{}`.
-     * Do not use to skip spaces while parsing a string. See  `skipSpaceTokens()`
-     * instead.
-     */
-    skipSpace(): boolean;
-    skipVisualSpace(): void;
-    match(token: LatexToken): boolean;
-    matchAll(tokens: LatexToken[]): boolean;
-    matchAny(tokens: LatexToken[]): LatexToken;
-    /**
-     * A Latex number can be a decimal, hex or octal number.
-     * It is used in some Latex commands, such as `\char`
-     *
-     * From TeX:8695 (scan_int):
-     * > An integer number can be preceded by any number of spaces and `+' or
-     * > `-' signs. Then comes either a decimal constant (i.e., radix 10), an
-     * > octal constant (i.e., radix 8, preceded by '), a hexadecimal constant
-     * > (radix 16, preceded by "), an alphabetic constant (preceded by `), or
-     * > an internal variable.
-     */
-    parseLatexNumber(isInteger?: boolean): null | number;
-    parseChar(): string | null;
-    /**
-     *
-     * If the next token matches the open delimiter, set a boundary with
-     * the close token and return true.
-     *
-     * This method handles prefixes like `\left` and `\bigl`.
-     *
-     * It also handles "shorthand" delimiters, i.e. '(' will match both
-     * `(` and `\lparen`. If a shorthand is used for the open delimiter, the
-     * corresponding shorthand will be used for the close delimiter.
-     * See DELIMITER_SHORTHAND.
-     *
-     */
-    private matchDelimiter;
-    parseGroup(): Expression | null;
-    parseOptionalGroup(): Expression | null;
-    parseToken(): 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[][];
-    /** Match a string used as a LaTeX symbol, for example an environment
-     * name.
-     * Not suitable for general purpose text, e.g. argument of a `\text{}
-     * command. See `matchChar()` instead.
-     */
-    private parseStringGroupContent;
-    /** Parse a group as a a string, for example for `\operatorname` or `\begin` */
-    parseStringGroup(optional?: boolean): string | null;
-    /** Parse an environment: `\begin{env}...\end{end}`
-     */
-    private parseEnvironment;
-    /** If the next token matches a `-` sign, return '-', otherwise return '+'
-     *
-     */
-    private parseOptionalSign;
-    /** Parse a sequence of decimal digits. The part indicates which
-     * grouping separator should be expected.
-     */
-    private parseDecimalDigits;
-    /** The 'part' argument is used to dermine what grouping separator
-     *  should be expected.
-     */
-    private parseSignedInteger;
-    private parseExponent;
-    parseRepeatingDecimal(): string;
-    /**
-     * Parse a number, with an optional sign, exponent, decimal marker,
-     * repeating decimals, etc...
-     */
-    parseNumber(): Expression | null;
-    private parsePrefixOperator;
-    private parseInfixOperator;
-    /**
-     * This returns an array of arguments (as in a function application),
-     * or null if there is no match.
-     *
-     * - 'enclosure' : will look for an argument inside an enclosure
-     *   (open/close fence)
-     * - 'implicit': either an expression inside a pair of `()`, or just a product
-     *  (i.e. we interpret `\cos 2x + 1` as `\cos(2x) + 1`)
-     *
-     */
-    parseArguments(kind?: 'enclosure' | 'implicit', until?: Readonly<Terminator>): ReadonlyArray<Expression> | null;
-    /**
-     * An enclosure is an opening matchfix operator, an optional expression,
-     * optionally followed multiple times by a separator and another expression,
-     * and finally a closing matching operator.
-     */
-    parseEnclosure(): Expression | null;
-    /**
-     * A generic expression is used for dictionary entries that do
-     * some complex (non-standard) parsing. This includes trig functions (to
-     * parse implicit arguments), and integrals (to parse the integrand and
-     * limits and the "dx" terminator).
-     */
-    private parseGenericExpression;
-    /**
-     * A function is an symbol followed by postfix operators
-     * (`\prime`...) and some arguments.
-     */
-    private parseFunction;
-    parseSymbol(until?: Readonly<Terminator>): Expression | null;
-    /**
-     * Parse a sequence superfix/subfix operator, e.g. `^{*}`
-     *
-     * Superfix and subfix need special handling:
-     *
-     * - they act mostly like an infix operator, but they are commutative, i.e.
-     * `x_a^b` should be parsed identically to `x^b_a`.
-     *
-     * - furthermore, in LaTeX `x^a^b` parses the same as `x^a{}^b`.
-     *
-     */
-    private parseSupsub;
-    parsePostfixOperator(lhs: Expression | null, until?: Readonly<Terminator>): Expression | null;
-    /**
-     * This method can be invoked when we know we're in an error situation,
-     * for example when there are tokens remaining after we've finished parsing.
-     *
-     * In general, if a context does not apply, we return `null` to give
-     * the chance to some other option to be considered. However, in some cases
-     * we know we've exhausted all possibilities, and in this case this method
-     * will return an error expression as informative as possible.
-     *
-     * We've encountered a LaTeX command or symbol but were not able to match it
-     * to any entry in the LaTeX dictionary, or ran into it in an unexpected
-     * context (postfix operator lacking an argument, for example)
-     */
-    parseSyntaxError(): Expression;
-    /**
-     * <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>
-     *
-     */
-    private parsePrimary;
-    /**
-     *  Parse an expression:
-     *
-     * <expression> ::=
-     *  | <primary>
-     *  | <prefix-op> <primary>
-     *  | <primary> <infix-op> <expression>
-     *
-     * Stop when an operator of precedence less than `until.minPrec`
-     * is encountered
-     */
-    parseExpression(until?: Readonly<Terminator>): Expression | null;
-    /**
-     * Add LaTeX or other requested metadata to the expression
-     */
-    decorate(expr: Expression | null, start: number): Expression | null;
-    error(code: string | [string, ...Expression[]], fromToken: number): Expression;
-    private isFunctionOperator;
-    /** Return all defs of the specified kind.
-     * The defs at the end of the dictionary have priority, since they may
-     * override previous definitions. (For example, there is a core definition
-     * for matchfix[], which maps to a List, and a logic definition which
-     * matches to Boole. The logic definition should take precedence.)
-     */
-    getDefs(kind: string): Iterable<IndexedLatexDictionaryEntry>;
-}
-export declare function parse(latex: string, dictionary: IndexedLatexDictionary, options: Readonly<ParseLatexOptions>): Expression | null;

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

@@ -1,29 +0,0 @@
-/* 0.31.0 */
-import { NumberSerializationFormat } from './types';
-/**
- * @param expr - A number, can be represented as a string
- *  (particularly useful for arbitrary precision numbers) or a number (-12.45)
- * @return A textual representation of the number, formatted according to the
- * `options`
- */
-export declare function serializeNumber(expr: Expression | null, options: NumberSerializationFormat): string;
-/**
- * `value` is a base-10 number, possibly a floating point number with an
- * exponent, i.e. "0.31415e1"
- */
-/**
- * Return a C99 hex-float formated representation of the floating-point `value`.
- *
- * Does not handle integer and non-finite values.
- */
-export declare function serializeHexFloat(value: number): string;
-/**
- * Given a correctly formatted float hex, return the corresponding number.
- *
- * - "0xc.3p0" -> 12.1875
- * - "0x3.0Cp2" -> 12.1875
- * - "0x1.91eb851eb851fp+1" -> 3.14
- * - "0x3.23d70a3d70a3ep0" -> 3.14
- *
- */
-export declare function deserializeHexFloat(value: string): number;

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

@@ -1,10 +0,0 @@
-/* 0.31.0 */
-import { DelimiterScale } from './types';
-export declare function getApplyFunctionStyle(_expr: Expression, _level: number): DelimiterScale;
-export declare function getGroupStyle(_expr: Expression, _level: number): DelimiterScale;
-export declare function getRootStyle(_expr: Expression | null, level: number): 'radical' | 'quotient' | 'solidus';
-export declare function getFractionStyle(expr: Expression, level: number): 'quotient' | 'block-quotient' | 'inline-quotient' | 'inline-solidus' | 'nice-solidus' | 'reciprocal' | 'factor';
-export declare function getLogicStyle(_expr: Expression, _level: number): 'word' | 'boolean' | 'uppercase-word' | 'punctuation';
-export declare function getPowerStyle(_expr: Expression, _level: number): 'root' | 'solidus' | 'quotient';
-export declare function getNumericSetStyle(_expr: Expression, _level: number): 'compact' | 'regular' | 'interval' | 'set-builder';
-export declare function latexTemplate(s: string, lhs: string, rhs: string): string;

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

@@ -1,37 +0,0 @@
-/* 0.31.0 */
-import { LatexString, SerializeLatexOptions, DelimiterScale } from './types';
-import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
-export declare class Serializer {
-    options: Readonly<SerializeLatexOptions>;
-    readonly dictionary: IndexedLatexDictionary;
-    level: number;
-    constructor(dictionary: IndexedLatexDictionary, options: SerializeLatexOptions);
-    /**
-     * Serialize the expression, and if the expression is an operator
-     * of precedence less than or equal to prec, wrap it in some parens.
-     * @todo: don't wrap Abs, Floor, Ceil, Delimiter
-     */
-    wrap(expr: Expression | null | undefined, prec?: number): string;
-    /**
-     * If this is a "short" expression, wrap it.
-     * Do not wrap symbols, positive numbers or functions.
-     *
-     * This is called by the serializer for power and division (i.e. "(a+1)/b")
-     *
-     */
-    wrapShort(expr: Expression | null | undefined): string;
-    wrapString(s: string, style: DelimiterScale, fence?: string): string;
-    wrapArguments(expr: Expression): string;
-    serializeSymbol(expr: Expression, def?: IndexedLatexDictionaryEntry): LatexString;
-    serializeFunction(expr: Expression, def?: IndexedLatexDictionaryEntry): LatexString;
-    serialize(expr: Expression | null | undefined): 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';
-}
-export declare function appendLatex(src: string, s: string): string;
-export declare function serializeLatex(expr: Expression | null, dict: IndexedLatexDictionary, options: Readonly<SerializeLatexOptions>): string;

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

@@ -1,18 +0,0 @@
-/* 0.31.0 */
- * ## Reference
- * TeX source code:
- * {@link  http://tug.org/texlive/devsrc/Build/source/texk/web2c/tex.web | Tex.web}
- *
- */
-export type Token = string;
-/**
- * Create Tokens from a stream of LaTeX
- *
- * @param s - A string of LaTeX. It can include comments (with the `%`
- * marker) and multiple lines.
- */
-export declare function tokenize(s: string, args?: string[]): Token[];
-export declare function countTokens(s: string): number;
-export declare function joinLatex(segments: Iterable<string>): string;
-export declare function supsub(c: '_' | '^', body: string, x: string): string;
-export declare function tokensToString(tokens: Token | Token[] | [Token[] | Token][]): string;