@cortex-js/compute-engine 0.35.6 → 0.50.0

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

@@ -1,97 +1,21 @@
-/* 0.35.6 */
-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;
-};
+/* 0.50.0 */
+import { LatexDictionaryEntry } from '../types';
+export type { CommonEntry, IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry, IndexedMatchfixEntry, IndexedInfixEntry, IndexedPrefixEntry, IndexedPostfixEntry, IndexedEnvironmentEntry, IndexedLatexDictionaryEntry, IndexedLatexDictionary, } from './indexed-types';
+import type { IndexedSymbolEntry, IndexedExpressionEntry, IndexedFunctionEntry, IndexedMatchfixEntry, IndexedInfixEntry, IndexedPostfixEntry, IndexedEnvironmentEntry, IndexedLatexDictionaryEntry, IndexedLatexDictionary } from './indexed-types';
 /** @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;
-/** @internal */
-export type IndexedLatexDictionaryEntry = IndexedExpressionEntry | IndexedFunctionEntry | IndexedSymbolEntry | IndexedMatchfixEntry | IndexedInfixEntry | IndexedPrefixEntry | IndexedPostfixEntry | IndexedEnvironmentEntry;
-/** @internal */
-export type IndexedLatexDictionary = {
-    ids: Map<string, IndexedLatexDictionaryEntry>;
-    lookahead: number;
-    defs: IndexedLatexDictionaryEntry[];
-    matchfixByOpen: Map<string, IndexedMatchfixEntry[]>;
-    infixByTrigger: Map<string, IndexedInfixEntry[]>;
-    prefixByTrigger: Map<string, IndexedPrefixEntry[]>;
-    postfixByTrigger: Map<string, IndexedPostfixEntry[]>;
-    functionByTrigger: Map<string, IndexedFunctionEntry[]>;
-    symbolByTrigger: Map<string, IndexedSymbolEntry[]>;
-    expressionByTrigger: Map<string, IndexedExpressionEntry[]>;
-};
 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/dictionary/indexed-types.d.ts

@@ -0,0 +1,83 @@
+/* 0.50.0 */
+ * Type definitions for the indexed LaTeX dictionary.
+ *
+ * These are separated from definitions.ts to break a circular dependency:
+ * types.ts needs these types for the Serializer interface, while definitions.ts
+ * needs types from types.ts. This file is a leaf module imported by both.
+ */
+import type { Delimiter, EnvironmentParseHandler, ExpressionParseHandler, InfixParseHandler, LatexString, LatexToken, 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;
+};
+export type IndexedExpressionEntry = CommonEntry & {
+    kind: 'expression';
+    precedence: Precedence;
+    parse: ExpressionParseHandler;
+};
+/**
+ * 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;
+    arguments?: 'enclosure' | 'implicit';
+};
+export type IndexedMatchfixEntry = CommonEntry & {
+    kind: 'matchfix';
+    openTrigger: Delimiter | LatexToken[];
+    closeTrigger: Delimiter | LatexToken[];
+    parse: MatchfixParseHandler;
+};
+export type IndexedInfixEntry = CommonEntry & {
+    kind: 'infix';
+    associativity: 'right' | 'left' | 'none' | 'any';
+    precedence: Precedence;
+    parse: InfixParseHandler;
+};
+export type IndexedPrefixEntry = CommonEntry & {
+    kind: 'prefix';
+    precedence: Precedence;
+    parse: ExpressionParseHandler;
+};
+export type IndexedPostfixEntry = CommonEntry & {
+    kind: 'postfix';
+    precedence: Precedence;
+    parse: PostfixParseHandler;
+};
+export type IndexedEnvironmentEntry = CommonEntry & {
+    kind: 'environment';
+    parse: EnvironmentParseHandler;
+};
+/** @internal */
+export type IndexedLatexDictionaryEntry = IndexedExpressionEntry | IndexedFunctionEntry | IndexedSymbolEntry | IndexedMatchfixEntry | IndexedInfixEntry | IndexedPrefixEntry | IndexedPostfixEntry | IndexedEnvironmentEntry;
+/** @internal */
+export type IndexedLatexDictionary = {
+    ids: Map<string, IndexedLatexDictionaryEntry>;
+    lookahead: number;
+    defs: IndexedLatexDictionaryEntry[];
+    matchfixByOpen: Map<string, IndexedMatchfixEntry[]>;
+    infixByTrigger: Map<string, IndexedInfixEntry[]>;
+    prefixByTrigger: Map<string, IndexedPrefixEntry[]>;
+    postfixByTrigger: Map<string, IndexedPostfixEntry[]>;
+    functionByTrigger: Map<string, IndexedFunctionEntry[]>;
+    symbolByTrigger: Map<string, IndexedSymbolEntry[]>;
+    expressionByTrigger: Map<string, IndexedExpressionEntry[]>;
+};

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

@@ -0,0 +1,28 @@
+/* 0.50.0 */
+ * Number parsing extracted from the _Parser class for modularity.
+ *
+ * All functions take a `Parser` interface and a `NumberFormatTokens` config
+ * that holds the pre-tokenized formatting strings from ParseLatexOptions.
+ */
+import type { MathJsonExpression } from '../../math-json/types';
+import type { LatexToken, Parser } from './types';
+/**
+ * Pre-tokenized formatting strings used during number parsing.
+ * Created once in the _Parser constructor from ParseLatexOptions.
+ */
+export interface NumberFormatTokens {
+    decimalSeparatorTokens: LatexToken[];
+    wholeDigitGroupSeparatorTokens: LatexToken[];
+    fractionalDigitGroupSeparatorTokens: LatexToken[];
+    exponentProductTokens: LatexToken[];
+    beginExponentMarkerTokens: LatexToken[];
+    endExponentMarkerTokens: LatexToken[];
+    truncationMarkerTokens: LatexToken[];
+}
+/** Parse repeating decimal notation (parentheses, vinculum, arc, dots). */
+export declare function parseRepeatingDecimal(parser: Parser, fmt: NumberFormatTokens): string;
+/**
+ * Parse a number, with an optional sign, exponent, decimal marker,
+ * repeating decimals, etc.
+ */
+export declare function parseNumber(parser: Parser, fmt: NumberFormatTokens): MathJsonExpression | null;

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

@@ -1,9 +1,9 @@
-/* 0.35.6 */
+/* 0.50.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;
+export declare function parseInvalidSymbol(parser: Parser): MathJsonExpression | null;
 /**
  * Match a symbol.
  *

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.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';
@@ -68,6 +68,7 @@ export declare class _Parser implements Parser {
     private _lastPeek;
     private _peekCounter;
     constructor(tokens: LatexToken[], dictionary: IndexedLatexDictionary, options: Readonly<ParseLatexOptions>);
+    private _numberFormatTokens;
     getSymbolType(id: MathJsonSymbol): BoxedType;
     hasSubscriptEvaluate(id: MathJsonSymbol): boolean;
     get peek(): LatexToken;
@@ -88,7 +89,7 @@ export declare class _Parser implements Parser {
     addBoundary(boundary: LatexToken[]): void;
     removeBoundary(): void;
     matchBoundary(): boolean;
-    boundaryError(msg: string | [string, ...Expression[]]): Expression;
+    boundaryError(msg: string | [string, ...MathJsonExpression[]]): MathJsonExpression;
     /**
      * Performance optimization: determines if we can skip expensive re-parsing
      * for matchfix boundary mismatches.
@@ -175,9 +176,9 @@ export declare class _Parser implements Parser {
      *
      */
     private matchDelimiter;
-    parseGroup(): Expression | null;
-    parseOptionalGroup(): Expression | null;
-    parseToken(): Expression | null;
+    parseGroup(): MathJsonExpression | null;
+    parseOptionalGroup(): MathJsonExpression | null;
+    parseToken(): MathJsonExpression | null;
     /**
      * Parse an expression in a tabular format, where rows are separated by `\\`
      * and columns by `&`.
@@ -185,7 +186,7 @@ export declare class _Parser implements Parser {
      * Return rows of sparse columns: empty rows are indicated with `Nothing`,
      * and empty cells are also indicated with `Nothing`.
      */
-    parseTabular(): null | Expression[][];
+    parseTabular(): null | MathJsonExpression[][];
     /** 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{}
@@ -197,25 +198,8 @@ export declare class _Parser implements Parser {
     /** 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;
+    parseNumber(): MathJsonExpression | null;
     private parsePrefixOperator;
     private parseInfixOperator;
     /**
@@ -228,13 +212,13 @@ export declare class _Parser implements Parser {
      *  (i.e. we interpret `\cos 2x + 1` as `\cos(2x) + 1`)
      *
      */
-    parseArguments(kind?: 'enclosure' | 'implicit', until?: Readonly<Terminator>): ReadonlyArray<Expression> | null;
+    parseArguments(kind?: 'enclosure' | 'implicit', until?: Readonly<Terminator>): ReadonlyArray<MathJsonExpression> | 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;
+    parseEnclosure(): MathJsonExpression | null;
     /**
      * A generic expression is used for dictionary entries that do
      * some complex (non-standard) parsing. This includes trig functions (to
@@ -247,7 +231,7 @@ export declare class _Parser implements Parser {
      * (`\prime`...) and some arguments.
      */
     private parseFunction;
-    parseSymbol(until?: Readonly<Terminator>): Expression | null;
+    parseSymbol(until?: Readonly<Terminator>): MathJsonExpression | null;
     /**
      * In non-strict mode, try to parse a bare function name followed by parentheses.
      * This allows syntax like `sin(x)` instead of requiring `\sin(x)`.
@@ -255,6 +239,12 @@ export declare class _Parser implements Parser {
      * Returns the parsed function call or null if not a bare function.
      */
     private tryParseBareFunction;
+    private static readonly BARE_SYMBOL_MAP;
+    /**
+     * In non-strict mode, try to parse a bare symbol name like a Greek letter
+     * or special constant (e.g., `alpha`, `pi`, `oo`, `ii`).
+     */
+    private tryParseBareSymbol;
     /**
      * Parse a sequence superfix/subfix operator, e.g. `^{*}`
      *
@@ -267,7 +257,7 @@ export declare class _Parser implements Parser {
      *
      */
     private parseSupsub;
-    parsePostfixOperator(lhs: Expression | null, until?: Readonly<Terminator>): Expression | null;
+    parsePostfixOperator(lhs: MathJsonExpression | null, until?: Readonly<Terminator>): MathJsonExpression | 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.
@@ -281,7 +271,7 @@ export declare class _Parser implements Parser {
      * to any entry in the LaTeX dictionary, or ran into it in an unexpected
      * context (postfix operator lacking an argument, for example)
      */
-    parseSyntaxError(): Expression;
+    parseSyntaxError(): MathJsonExpression;
     /**
      * <primary> :=
      *  (<number> | <symbol> | <environment> | <matchfix-expr>)
@@ -309,12 +299,12 @@ export declare class _Parser implements Parser {
      * Stop when an operator of precedence less than `until.minPrec`
      * is encountered
      */
-    parseExpression(until?: Readonly<Terminator>): Expression | null;
+    parseExpression(until?: Readonly<Terminator>): MathJsonExpression | 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;
+    decorate(expr: MathJsonExpression | null, start: number): MathJsonExpression | null;
+    error(code: string | [string, ...MathJsonExpression[]], fromToken: number): MathJsonExpression;
     private isFunctionOperator;
     /**
      * Check if a symbol looks like a predicate in First-Order Logic.
@@ -333,4 +323,4 @@ export declare class _Parser implements Parser {
      */
     getDefs(kind: string): Iterable<IndexedLatexDictionaryEntry>;
 }
-export declare function parse(latex: string, dictionary: IndexedLatexDictionary, options: Readonly<ParseLatexOptions>): Expression | null;
+export declare function parse(latex: string, dictionary: IndexedLatexDictionary, options: Readonly<ParseLatexOptions>): MathJsonExpression | null;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.0 */
 import { NumberSerializationFormat } from './types';
 /**
  * @param expr - A number, can be represented as a string
@@ -6,7 +6,7 @@ import { NumberSerializationFormat } from './types';
  * @return A textual representation of the number, formatted according to the
  * `options`
  */
-export declare function serializeNumber(expr: Expression | null, options: NumberSerializationFormat): string;
+export declare function serializeNumber(expr: MathJsonExpression | null, options: NumberSerializationFormat): string;
 /**
  * `value` is a base-10 number, possibly a floating point number with an
  * exponent, i.e. "0.31415e1"

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

@@ -1,10 +1,10 @@
-/* 0.35.6 */
+/* 0.50.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 getApplyFunctionStyle(_expr: MathJsonExpression, _level: number): DelimiterScale;
+export declare function getGroupStyle(_expr: MathJsonExpression, _level: number): DelimiterScale;
+export declare function getRootStyle(_expr: MathJsonExpression | null, level: number): 'radical' | 'quotient' | 'solidus';
+export declare function getFractionStyle(expr: MathJsonExpression, level: number): 'quotient' | 'block-quotient' | 'inline-quotient' | 'inline-solidus' | 'nice-solidus' | 'reciprocal' | 'factor';
+export declare function getLogicStyle(_expr: MathJsonExpression, _level: number): 'word' | 'boolean' | 'uppercase-word' | 'punctuation';
+export declare function getPowerStyle(_expr: MathJsonExpression, _level: number): 'root' | 'solidus' | 'quotient';
+export declare function getNumericSetStyle(_expr: MathJsonExpression, _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,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.0 */
 import { LatexString, SerializeLatexOptions, DelimiterScale } from './types';
 import type { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './dictionary/definitions';
 export declare class Serializer {
@@ -11,7 +11,7 @@ export declare class Serializer {
      * 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;
+    wrap(expr: MathJsonExpression | null | undefined, prec?: number): string;
     /**
      * If this is a "short" expression, wrap it.
      * Do not wrap symbols, positive numbers or functions.
@@ -19,19 +19,19 @@ export declare class Serializer {
      * This is called by the serializer for power and division (i.e. "(a+1)/b")
      *
      */
-    wrapShort(expr: Expression | null | undefined): string;
+    wrapShort(expr: MathJsonExpression | 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';
+    wrapArguments(expr: MathJsonExpression): string;
+    serializeSymbol(expr: MathJsonExpression, def?: IndexedLatexDictionaryEntry): LatexString;
+    serializeFunction(expr: MathJsonExpression, def?: IndexedLatexDictionaryEntry): LatexString;
+    serialize(expr: MathJsonExpression | null | undefined): LatexString;
+    applyFunctionStyle(expr: MathJsonExpression, level: number): DelimiterScale;
+    groupStyle(expr: MathJsonExpression, level: number): DelimiterScale;
+    rootStyle(expr: MathJsonExpression, level: number): 'radical' | 'quotient' | 'solidus';
+    fractionStyle(expr: MathJsonExpression, level: number): 'quotient' | 'block-quotient' | 'inline-quotient' | 'inline-solidus' | 'nice-solidus' | 'reciprocal' | 'factor';
+    logicStyle(expr: MathJsonExpression, level: number): 'word' | 'boolean' | 'uppercase-word' | 'punctuation';
+    powerStyle(expr: MathJsonExpression, level: number): 'root' | 'solidus' | 'quotient';
+    numericSetStyle(expr: MathJsonExpression, 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;
+export declare function serializeLatex(expr: MathJsonExpression | null, dict: IndexedLatexDictionary, options: Readonly<SerializeLatexOptions>): string;

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

@@ -1,4 +1,4 @@
-/* 0.35.6 */
+/* 0.50.0 */
  * ## Reference
  * TeX source code:
  * {@link  http://tug.org/texlive/devsrc/Build/source/texk/web2c/tex.web | Tex.web}