@cortex-js/compute-engine 0.4.2 → 0.5.0

package/dist/types/cortex/formatter.d.ts

@@ -1,165 +0,0 @@
-/* 0.4.2 */
-    indentChar: string;
-    indentCharWidth: number;
-    indentWidth: number;
-    margin: number;
-    softMargin: number;
-    aroundInfixOperator: string;
-    aroundRelationalOperator: string;
-    afterSeparator: string;
-    cost: FormattingCosts;
-};
-export declare type FormattingCosts = {
-    softMargin: number;
-    margin: number;
-    linebreak: number;
-    commentLinebreak: number;
-    flowLinebreak: number;
-    callLinebreak: number;
-    argLinebreak: number;
-};
-export declare abstract class FormattingBlock {
-    protected fmt: Formatter;
-    /** Return a printable string representing this block */
-    abstract serialize(offset: number): string;
-    /** When starting at `offset`, what is the cost of this block */
-    abstract cost(offset: number): number;
-    /** When starting at `offset`, what is the column after this block */
-    abstract nextCol(offset: number): number;
-    /** Output debug representation of the block */
-    abstract debug(): string;
-    constructor(fmt: Formatter);
-}
-export declare class EmptyBlock extends FormattingBlock {
-    constructor(fmt: Formatter);
-    debug(): string;
-    serialize(_offset: number): string;
-    nextCol(offset: number): number;
-    cost(_offset: number): number;
-}
-/**
- *
- *      |                 |        |
- *
- *      |    [--------]*  |        |
- *
- *      |    [------------|---]*   |
- *
- *      |    [------------|--------|---]*
- *
- *      |                 |        |
- *      0                          margin
- *                        soft-margin
- *
- */
-export declare class TextBlock extends FormattingBlock {
-    s: string;
-    constructor(fmt: Formatter, s: string);
-    debug(): string;
-    serialize(_offset: number): string;
-    nextCol(offset: number): number;
-    cost(offset: number): number;
-}
-/**
- * A block that places its elements in a single line
- *
- * 0    offset
- * |
- * |    [--------][-----------][------][----------]*
- * |
- */
-export declare class LineBlock extends FormattingBlock {
-    private blocks;
-    constructor(fmt: Formatter, ...blocks: FormattingBlock[]);
-    debug(): string;
-    serialize(offset: number): string;
-    nextCol(offset: number): number;
-    cost(offset: number): number;
-}
-/**
- * A block that arranges its elements vertically, separated by line breaks.
- *
- *      0    offset
- *      |
- *      |    [---1----]
- *      |    [-----2------]
- *      |    [--3--]
- *      |    [----4----]
- *      |    *
- *      |
- */
-export declare class StackBlock extends FormattingBlock {
-    private blocks;
-    constructor(fmt: Formatter, ...blocks: FormattingBlock[]);
-    debug(): string;
-    serialize(offset: number): string;
-    nextCol(offset: number): number;
-    cost(offset: number): number;
-}
-/**
- * A block that arranges its elements like a justified paragraph
- *
- *      |                            |
- *      |    [---1----][----2------] |
- *      |    [--3---][----4-----]    |
- *      |    [--5--][--6---][--7--]  |
- *      |    [---8----]*             |
- *      |                            |
- *
- */
-export declare class WrapBlock extends FormattingBlock {
-    private blocks;
-    constructor(fmt: Formatter, ...blocks: FormattingBlock[]);
-    debug(): string;
-    solution(offset: number): FormattingBlock;
-    serialize(offset: number): string;
-    nextCol(offset: number): number;
-    cost(offset: number): number;
-}
-export declare class ChoiceBlock extends FormattingBlock {
-    private blocks;
-    constructor(fmt: Formatter, ...blocks: FormattingBlock[]);
-    debug(): string;
-    choice(offset: number): FormattingBlock;
-    serialize(offset: number): string;
-    nextCol(offset: number): number;
-    cost(offset: number): number;
-}
-export declare class Formatter {
-    private options;
-    constructor(options?: Partial<FormattingOptions>);
-    get cost(): FormattingCosts;
-    get margin(): number;
-    get softMargin(): number;
-    indentChars(n?: number): string;
-    indentLength(n?: number): number;
-    linebreak(a?: string, b?: string): string;
-    countLinebreaks(s: string): number;
-    normalizedBlocks(blocks: (string | FormattingBlock)[]): FormattingBlock[];
-    /** A binary or ternary operator: +, -, etc... */
-    infixOperator(op: string): TextBlock;
-    /** A relational operator: =, <=, etc.. */
-    relationalOperator(op: string): TextBlock;
-    separator(op: string): TextBlock;
-    fence(f: string): TextBlock;
-    /** A single line of unbroken text */
-    text(s?: string): EmptyBlock | TextBlock;
-    /** Horizontal juxtaposition of a list of blocks */
-    line(...inBlocks: (string | FormattingBlock)[]): FormattingBlock;
-    /** A list of block stacked on top of one another */
-    stack(...inBlocks: (string | FormattingBlock)[]): FormattingBlock;
-    /** Packs its constituent layouts horizontally, inserting line breaks
-     * between them so as to minimize the total cost of output, in a manner
-     * analogous to the composition of words in paragraph.
-     *
-     * Output after line breaks begins at the starting column of the entire
-     * block.
-     * */
-    wrap(...inBlocks: (string | FormattingBlock)[]): FormattingBlock;
-    /** Indent a block by `indent` units. The value of a unit is specified in the options */
-    indent(block: FormattingBlock, indent?: number): FormattingBlock;
-    choice(...inBlocks: (string | FormattingBlock)[]): FormattingBlock;
-    fencedBlock(open: string, block: FormattingBlock, close: string): FormattingBlock;
-    fencedList(open: string, sep: string | FormattingBlock, close: string, blocks: FormattingBlock[]): FormattingBlock;
-    list(sep: string | FormattingBlock, blocks: FormattingBlock[]): FormattingBlock;
-}

package/dist/types/cortex/parse-cortex.d.ts

@@ -1,5 +0,0 @@
-/* 0.4.2 */
-import { ParsingDiagnostic } from '../point-free-parser/parsers';
-/** Analyze the reported errors and combine them when possible */
-export declare function analyzeErrors(errors: ParsingDiagnostic[]): ParsingDiagnostic[];
-export declare function parseCortex(source: string, url?: string): [Expression, ParsingDiagnostic[]];

package/dist/types/cortex/reserved-words.d.ts

@@ -1 +0,0 @@
-/* 0.4.2 */

package/dist/types/cortex/serialize-cortex.d.ts

@@ -1,14 +0,0 @@
-/* 0.4.2 */
-import { Expression } from '../public';
-import { FormattingOptions } from './formatter';
-export declare const NUMBER_FORMATTING_OPTIONS: Required<NumberFormattingOptions>;
-/**
- * Serialize a MathJSON expression to Cortex.
- *
- * @param options.fancySymbols - If true, some operators are replaced
- * with an equivalent Unicode character, for example: `*` -> `×`.
- *
- */
-export declare function serializeCortex(expr: Expression, options?: FormattingOptions & {
-    fancySymbols?: boolean;
-}): string;

package/dist/types/cortex.d.ts

@@ -1,8 +0,0 @@
-/* 0.4.2 */
-export { LatexSyntax, parse, serialize } from './latex-syntax/latex-syntax';
-export { ExpressionMap } from './compute-engine/expression-map';
-export { ComputeEngine, format, evaluate, } from './compute-engine/compute-engine';
-export { match, substitute, count } from './compute-engine/patterns';
-export { parseCortex } from './cortex/parse-cortex';
-export { serializeCortex } from './cortex/serialize-cortex';
-export declare const version = "0.4.2";

package/dist/types/latex-syntax/definitions-algebra.d.ts

@@ -1,2 +0,0 @@
-/* 0.4.2 */
-export declare const DEFINITIONS_ALGEBRA: LatexDictionary<any>;

package/dist/types/latex-syntax/definitions-arithmetic.d.ts

@@ -1,3 +0,0 @@
-/* 0.4.2 */
-import { Numeric } from '../compute-engine/public';
-export declare const DEFINITIONS_ARITHMETIC: LatexDictionary<Numeric>;

package/dist/types/latex-syntax/definitions-calculus.d.ts

@@ -1,2 +0,0 @@
-/* 0.4.2 */
-export declare const DEFINITIONS_CALCULUS: LatexDictionary<any>;

package/dist/types/latex-syntax/definitions-core.d.ts

@@ -1,3 +0,0 @@
-/* 0.4.2 */
-import { Numeric } from '../compute-engine/public';
-export declare const DEFINITIONS_CORE: LatexDictionary<Numeric>;

package/dist/types/latex-syntax/definitions-inequalities.d.ts

@@ -1,2 +0,0 @@
-/* 0.4.2 */
-export declare const DEFINITIONS_INEQUALITIES: LatexDictionary<number>;

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

@@ -1,3 +0,0 @@
-/* 0.4.2 */
-import { Numeric } from '../compute-engine/public';
-export declare const DEFINITIONS_OTHERS: LatexDictionary<Numeric>;

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

@@ -1,2 +0,0 @@
-/* 0.4.2 */
-export declare const DEFINITIONS_SETS: LatexDictionary<any>;

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

@@ -1,3 +0,0 @@
-/* 0.4.2 */
-import { LatexDictionary } from './public';
-export declare const DEFINITIONS_SYMBOLS: LatexDictionary<Numeric>;

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

@@ -1,3 +0,0 @@
-/* 0.4.2 */
-import { Numeric } from '../compute-engine/public';
-export declare const DEFINITIONS_TRIGONOMETRY: LatexDictionary<Numeric>;

package/dist/types/latex-syntax/definitions.d.ts

@@ -1,40 +0,0 @@
-/* 0.4.2 */
-import { LatexDictionary, LatexString, LatexToken, ParserFunction, SerializerFunction, LatexDictionaryEntry } from './public';
-import { Numeric } from '../compute-engine/public';
-export declare type IndexedLatexDictionaryEntry<T extends number = number> = {
-    name: string;
-    trigger?: {
-        symbol?: LatexToken | LatexToken[];
-        matchfix?: LatexToken | LatexToken[];
-        infix?: LatexToken | LatexToken[];
-        prefix?: LatexToken | LatexToken[];
-        postfix?: LatexToken | LatexToken[];
-        superfix?: LatexToken | LatexToken[];
-        subfix?: LatexToken | LatexToken[];
-    };
-    parse: Expression<T> | ParserFunction<T>;
-    serialize: SerializerFunction<T> | LatexString;
-    associativity: 'right' | 'left' | 'non' | 'both';
-    precedence: number;
-    arguments: 'group' | 'implicit' | '';
-    optionalLatexArg: number;
-    requiredLatexArg: number;
-    separator: LatexString;
-    closeFence: LatexString;
-};
-export declare type IndexedLatexDictionary<T extends number = number> = {
-    lookahead: number;
-    name: Map<string, IndexedLatexDictionaryEntry<T>>;
-    prefix: (Map<LatexString, IndexedLatexDictionaryEntry<T>> | null)[];
-    infix: (Map<LatexString, IndexedLatexDictionaryEntry<T>> | null)[];
-    postfix: (Map<LatexString, IndexedLatexDictionaryEntry<T>> | null)[];
-    matchfix: (Map<LatexString, IndexedLatexDictionaryEntry<T>> | null)[];
-    superfix: (Map<LatexString, IndexedLatexDictionaryEntry<T>> | null)[];
-    subfix: (Map<LatexString, IndexedLatexDictionaryEntry<T>> | null)[];
-    symbol: (Map<LatexString, IndexedLatexDictionaryEntry<T>> | null)[];
-    environment: Map<string, IndexedLatexDictionaryEntry<T>>;
-};
-export declare function indexLatexDictionary<T extends number = number>(dic: readonly LatexDictionaryEntry<T>[], onError: ErrorListener<ErrorCode>): IndexedLatexDictionary<T>;
-export declare const DEFAULT_LATEX_DICTIONARY: {
-    [category in DictionaryCategory]?: LatexDictionary<Numeric>;
-};

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

@@ -1,27 +0,0 @@
-/* 0.4.2 */
-import { DictionaryCategory, Expression, ErrorCode, ErrorListener } from '../public';
-import { Numeric } from '../compute-engine/public';
-export declare class LatexSyntax<T extends number = number> {
-    onError: ErrorListener<ErrorCode>;
-    options: Required<NumberFormattingOptions> & Required<ParseLatexOptions> & Required<SerializeLatexOptions>;
-    private dictionary;
-    constructor(options?: NumberFormattingOptions & ParseLatexOptions & SerializeLatexOptions & {
-        dictionary?: readonly LatexDictionaryEntry<T>[];
-        onError?: ErrorListener<ErrorCode>;
-    });
-    static getDictionary(domain?: DictionaryCategory | 'all'): Readonly<LatexDictionary<any>>;
-    parse(latex: LatexString): Expression;
-    serialize(expr: Expression<T>): LatexString;
-}
-export declare function parse<T extends number = Numeric>(latex: LatexString, options?: NumberFormattingOptions & ParseLatexOptions & {
-    dictionary?: Readonly<LatexDictionary<T>>;
-    onError?: ErrorListener<ErrorCode>;
-}): Expression;
-/**
- * Serialize a MathJSON expression as a Latex string.
- *
- */
-export declare function serialize<T extends number = number>(expr: Expression<T>, options?: NumberFormattingOptions & SerializeLatexOptions & {
-    dictionary?: Readonly<LatexDictionary<T>>;
-    onError?: ErrorListener<ErrorCode>;
-}): LatexString;

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

@@ -1,138 +0,0 @@
-/* 0.4.2 */
-import { ParseLatexOptions, LatexDictionaryEntry, LatexToken, NumberFormattingOptions } from './public';
-import { IndexedLatexDictionary } from './definitions';
-export declare class Scanner<T extends number = number> implements Scanner<T> {
-    index: number;
-    readonly tokens: LatexToken[];
-    readonly onError: ErrorListener<ErrorCode>;
-    readonly dictionary: IndexedLatexDictionary<T>;
-    readonly options: Required<NumberFormattingOptions> & Required<ParseLatexOptions>;
-    private invisibleOperatorPrecedence;
-    constructor(tokens: LatexToken[], options: Required<NumberFormattingOptions> & Required<ParseLatexOptions>, dictionary: IndexedLatexDictionary<T>, onError: ErrorListener<ErrorCode>);
-    clone(start: number, end: number): Scanner<T>;
-    balancedClone(open: LatexToken | LatexToken[], close: LatexToken | LatexToken[], silentError?: boolean): Scanner<T> | null;
-    get atEnd(): boolean;
-    get peek(): LatexToken;
-    latex(start: number, end?: number): string;
-    latexAhead(n: number): string;
-    latexBefore(): string;
-    latexAfter(): string;
-    /**
-     * Return at most `maxLookahead` 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[];
-    peekDefinition(kind: 'symbol' | 'infix' | 'matchfix' | 'prefix' | 'postfix' | 'superfix' | 'subfix' | 'operator'): [LatexDictionaryEntry<T> | null, number];
-    next(): LatexToken;
-    skipSpace(): boolean;
-    match(target: LatexToken): boolean;
-    matchAll(target: LatexToken | LatexToken[]): boolean;
-    matchAny(targets: LatexToken[]): LatexToken;
-    matchWhile(targets: LatexToken[]): LatexToken[];
-    matchSign(): string;
-    matchDecimalDigits(): string;
-    matchSignedInteger(): string;
-    matchExponent(): string;
-    matchNumber(): string;
-    matchOperator(kind: 'infix' | 'prefix' | 'postfix', lhs?: Expression<T> | null, minPrec?: number): Expression<T> | null;
-    matchArguments(kind: undefined | '' | 'group' | 'implicit'): Expression<T>[] | null;
-    matchMatchfixOperator(): Expression<T> | null;
-    matchDefinition(kind: 'symbol' | 'infix' | 'matchfix' | 'prefix' | 'postfix' | 'superfix' | 'subfix' | 'operator'): [LatexDictionaryEntry<T> | null, Expression<T> | 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<T> | null;
-    matchOptionalLatexArgument(): Expression<T> | null;
-    /**
-     * Match a required latex argument:
-     * - either enclosed in `{}`
-     * - or a single token.
-     *
-     * Return null if an argument was not found
-     * Return '' if an empty argument `{}` was found
-     */
-    matchRequiredLatexArgument(): Expression<T> | null;
-    /**
-     *  Match a superfix/subfix operator, e.g. `^{*}`
-     */
-    matchSupsub(lhs: Expression<T> | null): Expression<T> | null;
-    matchPostfix(lhs: Expression<T> | null): Expression<T> | null;
-    matchString(): 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(): null | Expression<T>;
-    matchEnvironment(): Expression<T> | null;
-    /**
-     * Apply the operator `op` to the left-hand-side and right-hand-side
-     * expression. Applies the associativity rule specified by the definition,
-     * i.e. 'op(a, op(b, c))` -> `op(a, b, c)`, etc...
-     *
-     * `op` is the name of the operator which should have a corresponding
-     * definition.
-     *
-     * If `op` is an infix operator, it should have both a lhs and rhs.
-     * If `op` is a postfix operator, it should only have a lhs.
-     * If `op` is a prefix operator, the lhs is returned as the first element
-     * of the return tuple.
-     *
-     * @return a tuple: [lhs, rhs]
-     */
-    applyOperator(op: string, lhs: Expression<T> | null, rhs: Expression<T> | null): NonNullable<[Expression<T> | null, Expression<T> | null]>;
-    /**
-     * Apply an invisible operator between two expressions.
-     *
-     * If no `invisibleOperator` was specified, use the `latex` operator.
-     *
-     * If the lhs is a number and the rhs is a fraction of integers,
-     * assume an 'invisible plus', that is '2 3/4' -> ['add', 2, [divide, 3, 4]]
-     * unless `invisiblePlusOperator` is empty
-     *
-     */
-    applyInvisibleOperator(lhs: Expression<T> | null, rhs: Expression<T> | null): Expression<T> | null;
-    matchUnknownLatexCommand(): Expression<T> | 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(_minPrec?: number): Expression<T> | null;
-    matchBalancedExpression(open: LatexToken | LatexToken[], close: LatexToken | LatexToken[], onError?: ErrorListener<ErrorCode>): Expression<T> | 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(minPrec?: number): Expression<T> | null;
-    /**
-     * Add latex or other requested metadata to the expression
-     */
-    decorate(expr: Expression<T> | null, start: number): Expression<T> | null;
-}