@cortex-js/compute-engine 0.4.0 → 0.4.3

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

@@ -0,0 +1,57 @@
+/* 0.4.3 */
+import { WarningSignal } from '../../../common/signals';
+export declare type CommonEntry = {
+    name?: string;
+    serialize: SerializeHandler | LatexString;
+};
+export declare type SymbolEntry = CommonEntry & {
+    kind: 'symbol';
+    precedence: number;
+    arguments: 'group' | 'implicit' | '';
+    optionalLatexArg: number;
+    requiredLatexArg: number;
+    parse: SymbolParseHandler;
+};
+export declare type MatchfixEntry = CommonEntry & {
+    kind: 'matchfix';
+    openDelimiter: Delimiter | LatexToken[];
+    closeDelimiter: Delimiter | LatexToken[];
+    parse: MatchfixParseHandler;
+};
+export declare type InfixEntry = CommonEntry & {
+    kind: 'infix';
+    associativity: 'right' | 'left' | 'non' | 'both';
+    precedence: number;
+    parse: InfixParseHandler;
+};
+export declare type PrefixEntry = CommonEntry & {
+    kind: 'prefix';
+    precedence: number;
+    parse: PrefixParseHandler;
+};
+export declare type PostfixEntry = CommonEntry & {
+    kind: 'postfix';
+    precedence: number;
+    parse: PostfixParseHandler;
+};
+export declare type EnvironmentEntry = CommonEntry & {
+    kind: 'environment';
+    optionalLatexArg: number;
+    requiredLatexArg: number;
+    parse: EnvironmentParseHandler;
+};
+export declare type IndexedLatexDictionaryEntry = SymbolEntry | MatchfixEntry | InfixEntry | PrefixEntry | PostfixEntry | EnvironmentEntry;
+export declare type IndexedLatexDictionary = {
+    lookahead: number;
+    name: Map<string, IndexedLatexDictionaryEntry>;
+    symbol: (Map<LatexString, SymbolEntry[]> | null)[];
+    prefix: (Map<LatexString, PrefixEntry[]> | null)[];
+    infix: (Map<LatexString, InfixEntry[]> | null)[];
+    postfix: (Map<LatexString, PostfixEntry[]> | null)[];
+    matchfix: MatchfixEntry[];
+    environment: Map<string, EnvironmentEntry>;
+};
+export declare function indexLatexDictionary(dic: readonly LatexDictionaryEntry[], onError: (sig: WarningSignal) => void): IndexedLatexDictionary;
+export declare const DEFAULT_LATEX_DICTIONARY: {
+    [category in DictionaryCategory]?: LatexDictionary;
+};

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

@@ -0,0 +1,23 @@
+/* 0.4.3 */
+import { Serializer } from './serializer';
+import { Expression } from '../../math-json/math-json-format';
+import { WarningSignalHandler } from '../../common/signals';
+import { IComputeEngine } from '../public';
+export declare const DEFAULT_SERIALIZE_LATEX_OPTIONS: Required<SerializeLatexOptions>;
+export declare class LatexSyntax {
+    onError: WarningSignalHandler;
+    options: Required<NumberFormattingOptions> & Required<ParseLatexOptions> & Required<SerializeLatexOptions>;
+    readonly computeEngine: IComputeEngine;
+    private dictionary;
+    private _serializer?;
+    constructor(options: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions> & {
+        computeEngine: IComputeEngine;
+        dictionary?: readonly LatexDictionaryEntry[];
+        onError?: WarningSignalHandler;
+    });
+    updateOptions(opt: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions> & Partial<SerializeLatexOptions>): void;
+    static getDictionary(domain?: DictionaryCategory | 'all'): Readonly<LatexDictionary>;
+    parse(latex: LatexString): Expression;
+    serialize(expr: Expression): LatexString;
+    get serializer(): Serializer;
+}

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

@@ -0,0 +1,198 @@
+/* 0.4.3 */
+import { ParseLatexOptions, LatexToken, NumberFormattingOptions, Delimiter, Terminator, Parser } from './public';
+import { IndexedLatexDictionary, InfixEntry, PostfixEntry, PrefixEntry, SymbolEntry } from './dictionary/definitions';
+import { WarningSignalHandler } from '../../common/signals';
+import { IComputeEngine } from '../public';
+export declare const DEFAULT_LATEX_NUMBER_OPTIONS: Required<NumberFormattingOptions>;
+export declare const DEFAULT_PARSE_LATEX_OPTIONS: Required<ParseLatexOptions>;
+export declare class _Parser implements Parser {
+    readonly onError: WarningSignalHandler;
+    readonly options: Required<NumberFormattingOptions> & Required<ParseLatexOptions>;
+    readonly engine: IComputeEngine;
+    readonly _dictionary: IndexedLatexDictionary;
+    index: number;
+    _lastPeek: string;
+    _peekCounter: number;
+    readonly _tokens: LatexToken[];
+    constructor(tokens: LatexToken[], options: Required<NumberFormattingOptions> & Required<ParseLatexOptions>, dictionary: IndexedLatexDictionary, computeEngine: IComputeEngine, onError: WarningSignalHandler);
+    updateOptions(opt: Partial<NumberFormattingOptions> & Partial<ParseLatexOptions>): void;
+    clone(start: number, end: number): Parser;
+    get atEnd(): boolean;
+    get peek(): LatexToken;
+    /**
+     * Return true if
+     * - at end of the token stream
+     * - the upcoming tokens match `t.tokens`
+     * - the `t.condition` function returns true
+     * Note: the `minPrec` condition is not checked. It should be checked separately.
+     */
+    atTerminator(t?: Terminator): boolean;
+    latex(start: number, end?: number): string;
+    latexAhead(n: number): string;
+    latexBefore(): string;
+    latexAfter(): string;
+    /**
+     * Return at most `lookahead` strings made from the tokens
+     * ahead.
+     *
+     * The index in the returned array correspond to the number of tokens.
+     * Note that since a token can be longer than one char ('\\pi', but also
+     * some astral plane unicode characters), the length of the string
+     * does not match that index. However, knowing the index is important
+     * to know by how many tokens to advance.
+     *
+     */
+    lookAhead(): string[];
+    /** Return all the definitions that potentially match the tokens ahead */
+    peekDefinitions(kind: 'symbol'): [SymbolEntry, number][] | null;
+    peekDefinitions(kind: 'postfix'): [PostfixEntry, number][] | null;
+    peekDefinitions(kind: 'postfix'): [PostfixEntry, number][] | null;
+    peekDefinitions(kind: 'operator'): [InfixEntry | PrefixEntry | PostfixEntry, number][] | null;
+    peekDefinitions(kind: 'infix'): [InfixEntry, number][] | null;
+    peekDefinitions(kind: 'prefix'): [PrefixEntry, number][] | null;
+    next(): LatexToken;
+    skipSpace(): boolean;
+    matchChar(): string | null;
+    matchColor(_background?: boolean): string | null;
+    matchLatexDimension(): string | null;
+    match(token: LatexToken): boolean;
+    matchAll(tokens: LatexToken | LatexToken[]): boolean;
+    matchAny(tokens: LatexToken[]): LatexToken;
+    matchWhile(tokens: LatexToken[]): LatexToken[];
+    matchSign(): string;
+    matchDecimalDigits(): string;
+    matchSignedInteger(): string;
+    matchExponent(): string;
+    matchNumber(): string;
+    /**
+     * 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.
+     */
+    matchLatexNumber(isInteger?: boolean): null | number;
+    matchPrefixOperator(until?: Terminator): Expression | null;
+    matchInfixOperator(lhs: Expression, until?: Terminator): Expression | null;
+    /**
+     * 'group' : will look for an argument inside a pair of `()`
+     * 'implicit': either an expression inside a pair of `()`, or just a primary
+     *  (i.e. we interpret `\cos x + 1` as `\cos(x) + 1`)
+     */
+    matchArguments(kind: undefined | '' | 'group' | 'implicit'): Expression[] | null;
+    /** If matches the normalized open delimiter, returns the
+     * expected closing delimiter.
+     *
+     * For example, if `delimiter` is `(`, it would match `\left\lparen` and
+     * return `['\right', '\rparen']`, which can be matched with `matchAll()`
+     *
+     * If you need to match several tokens, use `matchAll()`
+     */
+    matchOpenDelimiter(openDelim: Delimiter, closeDelim: Delimiter): LatexToken[] | null;
+    matchMiddleDelimiter(delimiter: '|' | ':' | LatexToken): boolean;
+    /**
+     * An enclosure is an opening matchfix operator, an expression, optionally
+     * followed multiple times by a separator and another expression,
+     * and finally a closing matching operator.
+     */
+    matchEnclosure(): Expression | null;
+    /**
+     * A symbol can be:
+     * - a constant: `\pi`
+     * - a variable: `x`
+     * - a function with explicit arguments `f(x)`
+     * - a function with implicit arguments: `\cos x`
+     * - a command: `\frac{2}{3}`
+     */
+    matchSymbol(): Expression | null;
+    matchOptionalLatexArgument(): Expression | null;
+    /**
+     * Match a required LaTeX argument:
+     * - either enclosed in `{}`
+     * - or a single token.
+     *
+     * Return null if an argument was not found
+     * Return 'Nothing' if an empty argument `{}` was found
+     */
+    matchRequiredLatexArgument(): Expression | null;
+    /**
+     *  Match 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, consecutive `^` or `_` are treated as concatenated,
+     * that is `x^a^b` parses the same as `x^{ab}`.
+     *
+     */
+    matchSupsub(lhs: Expression | null): Expression | null;
+    matchPostfix(lhs: Expression | null): Expression | null;
+    matchString(until: {
+        tokens: LatexToken[];
+    } & Partial<Terminator>): string;
+    matchEnvironmentName(command: '\\begin' | '\\end', envName: string): boolean;
+    /**
+     * Match an expression in a tabular format,
+     * where row are separated by `\\` and columns by `&`
+     *
+     * Return rows of sparse columns as a list: empty rows are indicated with NOTHING,
+     * and empty cells are also indicated with NOTHING.
+     */
+    matchTabular(endName: string): null | Expression;
+    matchEnvironment(): Expression | null;
+    /**
+     * Apply an invisible operator between two expressions.
+     *
+     * If the `lhs` is an literal integer and the `rhs` is a literal rational
+     * -> 'invisible plus'
+     *
+     * That is '2 3/4' -> ['Add', 2, ['Rational', 3, 4]]
+     *
+     * If `lhs` is a number and `rhs` is a number but not a literal -> 'invisible multiply'.
+     * - 2x
+     * - 2(x+1)
+     * - x(x+1)
+     * - f(x)g(y)
+     * - 2 sin(x)
+     * - 2 f(x)
+     * - x f(x)
+     * - (x-1)(x+1)
+     * - (x+1)2 -> no
+     * - x2 -> no
+     * => lhs is a number, rhs is a number, but not a literal
+     */
+    applyInvisibleOperator(terminator: Terminator, rawLhs: Expression | null): Expression | null;
+    matchUnknownLatexCommand(): Expression | null;
+    /**
+     * <primary> :=
+     * (<number> | <symbol> | <environment> | <matchfix-expr>) <subsup>* <postfix-operator>*
+     *
+     * <symbol> ::= (<symbol-id> | (<latex-command><latex-arguments>)) <arguments>
+     *
+     * <matchfix-expr> :=
+     *  <matchfix-op-open> <expression> [<matchfix-op-separator> <expression>] <matchfix-op-close>
+     *
+     */
+    matchPrimary(): Expression | null;
+    /**
+     *  Parse an expression:
+     *
+     * <expression> ::=
+     *  | <primary>
+     *  | <prefix-op> <primary>
+     *  | <primary> <infix-op> <expression>
+     *
+     * Stop when an operator of precedence less than `minPrec` is encountered
+     */
+    matchExpression(until?: Partial<Terminator>): Expression | null;
+    /**
+     * Add latex or other requested metadata to the expression
+     */
+    decorate(expr: Expression | null, start: number): Expression | null;
+}