@cortex-js/compute-engine 0.4.2 → 0.4.3

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

@@ -1,456 +0,0 @@
-/* 0.4.2 */
-export declare type LatexToken = string | '<{>' | '<}>' | '<space>' | '<$>' | '<$$>';
-export declare type LatexString = string;
-/**
- * Custom parser function.
- *
- * It is triggered by a latex fragment (the `latex` argument). When invoked,
- * the scanner points right after that latex fragment. The scanner should be
- * moved, by calling `scanner.next()` 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`.
- *
- * The function should return a tuple:
- *
- * - Its first element is an unprocessed left-hand side, if any. If the
- * left-hand-side has been consumed (for example if this was a valid infix
- * operator), the first element of the tuple should be `null`.
- *
- * - Its second element is the resulting expression.
- *
- */
-export declare type ParserFunction<T extends number = number> = (lhs: Expression<T> | null, scanner: Scanner<T>, minPrec: number) => [lhs: Expression<T> | null, result: Expression<T> | null];
-/**
- * Maps a string of Latex tokens to a function or symbol and vice-versa.
- *
- */
-export declare type LatexDictionaryEntry<T extends number = number> = {
-    /**
-     * Map a function or symbol name to this record.
-     *
-     * Each record should have at least a `name` or a `trigger`
-     */
-    name?: string;
-    /**
-     * Map one or more latex tokens to this record.
-     *
-     * As a shortcut, if the trigger is a LatexToken, it is assumed to be a symbol.
-     *
-     * There can be multiple entries (for example '+' is both an infix and a
-     * prefix)
-     */
-    trigger?: LatexToken | {
-        symbol?: LatexToken | LatexToken[];
-        matchfix?: LatexToken | LatexToken[];
-        /**
-         * Infix position, with an operand before and an operand after: `a ⊛ b`.
-         *
-         * Example: `+`, `\times`
-         */
-        infix?: LatexToken | LatexToken[];
-        /**
-         * Prefix position, with an operand after: `⊛ a`
-         *
-         * Example: `-`, `\not`
-         */
-        prefix?: LatexToken | LatexToken[];
-        /**
-         * Postfix position, with an operand before: `a⊛`
-         */
-        postfix?: LatexToken | LatexToken[];
-        /**
-         * Superfix position (in a superscript), with the base of the
-         * superscript as the operand: `a^{⊛}`
-         */
-        superfix?: LatexToken | LatexToken[];
-        /**
-         * Subfix position (in a subscript), with the base of the
-         * subscript as the operand: `a_{⊛}`
-         */
-        subfix?: LatexToken | LatexToken[];
-        /**
-         * The name of an environment, as used in `\begin{matrix}` where
-         * `"matrix"` is the name of the environment.
-         *
-         */
-        environment?: string;
-    };
-    /**
-     * A function that returns an expression, or an expression
-     */
-    parse?: Expression<T> | ParserFunction<T>;
-    /**
-     * The Latex to serialize.
-     */
-    serialize?: SerializerFunction<T> | LatexString;
-    /**
-     * If `trigger` is `'infix'``
-     * - **`both`**: 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
-     */
-    associativity?: 'right' | 'left' | 'non' | 'both';
-    /** If `trigger` is `'infix'`` */
-    precedence?: number;
-    /**
-     * If `trigger` is `'symbol'``.
-     * Indicate if this symbol can be followed by arguments.
-     * The presence of arguments will indicate that the arguments should be
-     * applied to the symbol. Otherwise, the invisible operator is applied
-     * to the symbol and the arguments.
-     *
-     * If `arguments` is `"group"`:
-     *
-     * "f(x)" -> `["f", "x"]`
-     * "f x" -> `["multiply", "f", "x"]`
-     *
-     * If `arguments` is `""`:
-     *
-     * "f(x)" -> `["multiply", "f", ["group", "x"]]`
-     * "f x" -> `["multiply", "f", "x"]`
-     *
-     * If `arguments` is `"group/primary"` and the symbol is followed either
-     * by a group or by a primary (prefix + symbol + subsupfix + postfix).
-     * Used for trig functions. i.e. `\sin x` vs `\sin(x)`:
-     *
-     * "f(x)" -> `["f", "x"]`
-     * "f x" -> `["f", "x"]`
-     *
-     */
-    arguments?: 'group' | 'implicit' | '';
-    /**
-     * If `trigger` is `'symbol'``.
-     *
-     * If a Latex command (i.e. the trigger starts with `\`, e.g. `\sqrt`)
-     * indicates the number of optional arguments expected (indicate with
-     * square brackets).
-     *
-     * For example, for the `\sqrt` command, 1: `\sqrt[3]{x}`
-     *
-     */
-    optionalLatexArg?: number;
-    /**
-     * If `trigger` is `'symbol'``.
-     *
-     * If a Latex command (i.e. the trigger starts with `\`, e.g. `\frac`)
-     * indicates the number of required arguments expected (indicated with
-     * curly braces).
-     *
-     * For example, for the `\frac` command, 2: `\frac{1}{n}`
-     *
-     */
-    requiredLatexArg?: number;
-    /**
-     * If `trigger` is `'matchfix'``.
-     */
-    separator?: LatexString;
-    closeFence?: LatexToken | LatexToken[];
-};
-export declare type LatexDictionary<T extends number = number> = LatexDictionaryEntry<T>[];
-export declare type ParseLatexOptions = {
-    /**
-     * If a symbol follows a number, consider them separated by this
-     * invisible operator.
-     *
-     * Default: `"Multiply"`
-     */
-    invisibleOperator?: string;
-    /**
-     * If true, ignore space characters.
-     *
-     */
-    skipSpace?: boolean;
-    /**
-     * When an unknown latex command is encountered, attempt to parse
-     * any arguments it may have.
-     *
-     * For example, `\foo{x+1}` would produce `['\foo', ['Add', 'x', 1]]` if
-     * this property is true, `['LatexSymbols', '\foo', '<{>', 'x', '+', 1, '<{>']`
-     * otherwise.
-     */
-    parseArgumentsOfUnknownLatexCommands?: boolean;
-    /**
-     * When a number is encountered, parse it.
-     *
-     * Otherwise, return each token making up the number (minus sign, digits,
-     * decimal separator, etc...)
-     */
-    parseNumbers?: boolean;
-    /**
-     * If this setting is not empty, when a number is immediately followed by a
-     * fraction, assume that the fraction should be added to the number, that
-     * is that there is an invisible plus operator between the two.
-     *
-     * For example with `2\frac{3}{4}`:
-     * - when `invisiblePlusOperator` is `"add"` : `["add", 2, ["divide", 3, 4]]`
-     * - when `invisiblePlusOperator` is `""`: `["multiply", 2, ["divide", 3, 4]]`
-     */
-    invisiblePlusOperator?: string;
-    /**
-     * When a token is encountered at a position where a symbol could be
-     * parsed, if the token matches `promoteUnknownSymbols` it will be
-     * accepted as a symbol (an `unknown-symbol` error will still be triggered
-     * so that the caller can be notified). Otherwise, the symbol is rejected.
-     */
-    promoteUnknownSymbols?: RegExp;
-    /**
-     * When one of these commands is encountered, it is skipped.
-     *
-     * Useful for purely presentational commands such as `\displaystyle`
-     */
-    ignoreCommands?: LatexToken[];
-    /**
-     * When one these commands is encountered, its argument is parsed,
-     * as if the command was not present.
-     *
-     * Useful for some presentational commands such as `\left`, `\bigl`, etc...
-     */
-    idempotentCommands?: LatexToken[];
-    /**
-     * When a token is encountered at a position that could match
-     * a function call, and it is followed by an apply function operator
-     * (typically, parentheses), consider them to a be a function if the
-     * string of tokens match this regular expression.
-     *
-     * While this is a convenient shortcut, it is recommended to more explicitly
-     * define custom functions by providing an entry for them in a function
-     * dictionary (providing additional information about their arguments, etc...)
-     * and in a Latex translation dictionary (indicating what Latex markup
-     * corresponds to the function).
-     *
-     * Example:
-     *
-     * By default, `f(x)` is parsed as `["Multiply", "f", "x"]`.
-     *
-     * After...
-     *
-     * ```
-     *      promoteUnknownFunctions = /^[fg]$/
-     * ```
-     *
-     * ... `f(x)` is parsed as `["f", "x"]`
-     *
-     *
-     */
-    promoteUnknownFunctions?: RegExp;
-    /**
-     * If true, the expression will be decorated with the Latex
-     * fragments corresponding to each elements of the expression
-     */
-    preserveLatex?: boolean;
-};
-export declare type SerializeLatexOptions = {
-    /**
-     * Latex string used to render an invisible multiply, e.g. in '2x'.
-     * Leave it empty to join the adjacent terms, or 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, 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}`, or use `+` to insert a `+` 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;
-};
-export declare type NumberFormattingOptions = {
-    precision?: number;
-    positiveInfinity?: string;
-    negativeInfinity?: string;
-    notANumber?: string;
-    /**
-     * 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'.
-     *
-     * Default: `"."`
-     */
-    decimalMarker?: string;
-    /**
-     * A string representing the separator between groups of digits,
-     * used to improve readability of numbers with lots of digits.
-     *
-     * Default: `","`
-     */
-    groupSeparator?: string;
-    exponentProduct?: string;
-    beginExponentMarker?: string;
-    endExponentMarker?: string;
-    notation?: 'engineering' | 'auto' | 'scientific';
-    truncationMarker?: string;
-    beginRepeatingDigits?: string;
-    endRepeatingDigits?: string;
-    imaginaryNumber?: string;
-};
-/**
- * To customize the parsing and serializing of Latex syntax, create a `LatexSyntax`
- * instance.
- */
-export declare class LatexSyntax<T extends number = number> {
-    /**
-     *
-     * @param 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?: ErrorListener<ErrorCode>;
-        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?: DictionaryCategory | 'all'): Readonly<LatexDictionary<any>>;
-    parse(latex: LatexString): Expression<T>;
-    serialize(expr: Expression<T>): LatexString;
-}
-export interface Serializer<T extends number = number> {
-    readonly onError: ErrorListener<ErrorCode>;
-    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;
-    /** Output a Latex string representing the expression */
-    serialize: (expr: Expression<T> | null) => string;
-    wrapString(s: string, style: 'paren' | 'leftright' | 'big' | 'none'): string;
-    /** Add a group fence around the expression if it is
-     * an operator of precedence less than or equal to `prec`.
-     */
-    wrap: (expr: Expression<T> | null, prec?: number) => string;
-    /** Add a group fence around the expression if it is
-     * short (not a function)
-     */
-    wrapShort(expr: Expression<T> | null): string;
-}
-export declare type SerializerFunction<T extends number = number> = (serializer: Serializer<T>, expr: T | Expression<T>) => string;
-export interface Scanner<T extends number = number> {
-    readonly onError: ErrorListener<ErrorCode>;
-    readonly options: Required<ParseLatexOptions>;
-    index: number;
-    readonly atEnd: boolean;
-    /** Return the next token, without advancing the index */
-    readonly peek: LatexToken;
-    /** Return an array of string corresponding to tokens ahead.
-     * The index is unchanged.
-     */
-    lookAhead(): string[];
-    /** Return the next token and advance the index */
-    next(): LatexToken;
-    /** Return a latex string before the index */
-    latexBefore(): string;
-    /** Return a latex string after the index */
-    latexAfter(): string;
-    /** If there are any space, advance the index until a non-space is encountered */
-    skipSpace(): boolean;
-    /** If the next token matches the target advance and return true. Otherwise
-     * return false */
-    match(target: LatexToken): boolean;
-    matchAny(targets: LatexToken[]): LatexToken;
-    matchWhile(targets: LatexToken[]): LatexToken[];
-    /** If the next token matches a `+` or `-` sign, return it and advance the index.
-     * Otherwise return `''` and do not advance */
-    matchSign(): string;
-    matchDecimalDigits(): string;
-    matchSignedInteger(): string;
-    matchExponent(): string;
-    matchNumber(): string;
-    matchTabular(): null | Expression<T>;
-    applyOperator(op: string, lhs: Expression<T> | null, rhs: Expression<T> | null): NonNullable<[Expression<T> | null, Expression<T> | null]>;
-    applyInvisibleOperator(lhs: Expression<T> | null, rhs: Expression<T> | null): Expression<T> | null;
-    /** If the next tokens correspond to an optional argument,
-     * enclosed with `[` and `]` return the content of the argument
-     * as an expression and advance the index past the closing `]`.
-     * Otherwise, return null
-     */
-    matchOptionalLatexArgument(): Expression<T> | null;
-    matchRequiredLatexArgument(): Expression<T> | null;
-    matchArguments(kind: '' | 'group' | 'implicit'): Expression<T>[] | null;
-    matchSupsub(lhs: Expression<T> | null): Expression<T> | null;
-    /**
-     * <primary> :=
-     * (<number> | <symbol> | <latex-command> | <function-call> | <matchfix-expr>)
-     * (<subsup> | <postfix-operator>)*
-     *
-     * <matchfix-expr> :=
-     *  <matchfix-op-open> <expression> <matchfix-op-close>
-     *
-     * <function-call> ::=
-     *  | <function><matchfix-op-group-open><expression>[',' <expression>]<matchfix-op-group-close>
-     *
-     * If not a primary, return `null` and do not advance the index.
-     */
-    matchPrimary(minPrec?: number): Expression<T> | null;
-    /**
-     *  Parse an expression:
-     *
-     * <expression> ::=
-     *  | <prefix-op> <expression>
-     *  | <primary>
-     *  | <primary> <infix-op> <expression>
-     *
-     * Stop when an operator of precedence less than `minPrec` is encountered
-     *
-     * `minPrec` is 0 by default.
-     */
-    matchExpression(minPrec?: number): Expression<T> | null;
-    matchBalancedExpression(open: LatexToken, close: LatexToken, onError?: ErrorListener<ErrorCode>): Expression<T> | null;
-}
-/**
- * Parse a Latex string and return a corresponding MathJSON expression.
- *
- * @param onError - Called when a non-fatal error is encountered while parsing.
- * The parsing will attempt to recover and continue.
- *
- */
-export declare function parse<T extends number = number>(latex: LatexString, options?: NumberFormattingOptions & ParseLatexOptions & {
-    onError?: ErrorListener<ErrorCode>;
-}): Expression<T>;
-/**
- * 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/serializer.d.ts

@@ -1,26 +0,0 @@
-/* 0.4.2 */
-import { NumberFormattingOptions, LatexString, SerializeLatexOptions } from './public';
-import { IndexedLatexDictionary, IndexedLatexDictionaryEntry } from './definitions';
-export declare class Serializer<T extends number = number> implements Serializer<T> {
-    readonly dictionary: IndexedLatexDictionary<T>;
-    readonly onError: ErrorListener<ErrorCode>;
-    readonly options: Required<NumberFormattingOptions> & Required<SerializeLatexOptions>;
-    level: number;
-    constructor(options: Required<NumberFormattingOptions> & Required<SerializeLatexOptions>, dictionary: IndexedLatexDictionary<T>, onError: ErrorListener<ErrorCode>);
-    /**
-     * Serialize the expression, and if the expression is an operator
-     * of precedence less than or equal to prec, wrap it in some paren.
-     * @todo: don't wrap abs
-     */
-    wrap(expr: Expression<T> | null, prec?: number): string;
-    /** If this is a "short" expression (atomic), wrap it.
-     *
-     */
-    wrapShort(expr: Expression<T> | null): string;
-    wrapString(s: string, style: 'paren' | 'leftright' | 'big' | 'none'): string;
-    serializeSymbol(expr: Expression<T>, def?: IndexedLatexDictionaryEntry<T>): string;
-    serializeDictionary(dict: {
-        [key: string]: Expression<T>;
-    }): string;
-    serialize(expr: T | Expression<T> | null): LatexString;
-}

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

@@ -1,10 +0,0 @@
-/* 0.4.2 */
-export declare const DEFAULT_LATEX_NUMBER_OPTIONS: Required<NumberFormattingOptions>;
-export declare const DEFAULT_PARSE_LATEX_OPTIONS: Required<ParseLatexOptions>;
-export declare const DEFAULT_SERIALIZE_LATEX_OPTIONS: Required<SerializeLatexOptions>;
-export declare function appendLatex(src: string, s: string): string;
-/**
- * Replace '#1', '#2' in the latex template stings with the corresponding
- * values from `replacement`, in a Latex syntax safe manner (i.e. inserting spaces when needed)
- */
-export declare function replaceLatex(template: string, replacement: string[]): string;

package/dist/types/point-free-parser/characters.d.ts

@@ -1,25 +0,0 @@
-/* 0.4.2 */
-export declare const REVERSED_ESCAPED_CHARS: Map<number, number>;
-export declare const HEX_DIGITS: Map<number, number>;
-export declare const DIGITS: Map<number, number>;
-export declare const SUPERSCRIPT_UNICODE: Map<number, string>;
-export declare const SUBSCRIPT_UNICODE: Map<number, string>;
-export declare const VULGAR_FRACTIONS_UNICODE: Map<number, string>;
-export declare const FANCY_UNICODE: Map<number, string>;
-export declare const REVERSE_FANCY_UNICODE: Map<string, number[]>;
-export declare function isLinebreak(c: number): boolean;
-/** Most restrictive whitespace only TAB or SPACE */
-export declare function isInlineSpace(c: number): boolean;
-export declare function isPatternWhitespace(c: number): boolean;
-/** Everything in pattern white space, plus some other
- * characters considered whitespace */
-export declare function isWhitespace(c: number): boolean;
-export declare function isSyntax(c: number): boolean;
-/** A 'break' character is an whitespace, operator, punctuation, bracket, etc..
- * It indicates the end of an identifier (or number).
- */
-export declare function isBreak(c: number): boolean;
-export declare function isIdentifierContinueProhibited(c: number): boolean;
-export declare function isIdentifierStartProhibited(c: number): boolean;
-export declare function isInvisible(c: number): boolean;
-export declare function codePointLength(code: number): number;

package/dist/types/point-free-parser/combinators.d.ts

@@ -1,46 +0,0 @@
-/* 0.4.2 */
-/**
- * An element bracketed by open and close delimiters.
- *
- */
-export declare function between<IR>(open: string, something: string | Combinator<IR>, close: string): Combinator<IR>;
-export declare function manySeparatedBetween<IR>(open: string, something: string | Combinator<IR>, separator: string, close: string, f: (values: Result<IR>[]) => IR): Combinator<IR>;
-/**
- * 0 or more elements, separated and bracketed with open and close delimiters
- * */
-export declare function someSeparatedBetween<IR>(open: string, something: string | Combinator<IR>, separator: string, close: string, f: (values: (IR | undefined | null)[]) => IR): Combinator<IR>;
-/**
- * Combinator for a table of operators.
- * Each operator has a precedence, and can be either a prefix,
- * suffix, left-associating infix, or right-association infix.
- *
- * Prefix and suffix have no whitespace between the operator and its term.
- *
- * Infix have either whitespace on both sides *or* no whitespace.
- *
- * This requirement is necessary to parse multi-line statements without
- * requiring statement separators.
- *
- */
-export declare type OpRecord<U> = [
-    data: U,
-    op: string,
-    prec: number,
-    assoc?: 'prefix' | 'suffix' | 'left' | 'right'
-];
-export declare type OpsTable<U> = OpRecord<U>[];
-/**
- * Return the ops sorted by length of the symbol so that,
- * e.g. '<<-' is before '<-'
- */
-/**
- * A sequence of prefix, infix and suffix operators with `term`
- * operands.
- *
- * The `f` mapping function is called according to the specified
- * precedence info in the `OpsTable`
- */
-export declare function operatorSequence<IR, U>(ops: OpsTable<U>, term: string | Combinator<IR>, f: (op: U, lhs?: IR, rhs?: IR) => IR): Combinator<IR>;
-/**
- * Parse a prefix operator
- */

package/dist/types/point-free-parser/core-combinators.d.ts

@@ -1,78 +0,0 @@
-/* 0.4.2 */
-export declare function normalize<IR>(c: string | Combinator | ((parser: Parser) => Result<IR>)): string | ((parser: Parser) => Result<IR>);
-export declare function description(c: string | Combinator): string;
-export declare function parseCodepoint(parser: Parser, value: number): Result<string>;
-export declare function codepoint(value: number): Combinator<string>;
-/**
- * Apply a function to one or more results.
- *
- * Similar to an _action_ with YACC/Bison.
- *
- * Compute the semantic value of the whole construct from the semantic
- * values of its parts.
- */
-/**
- *
- * Combine one or more results into a single result using the `f()` function.
- *
- * Keep all the diagnostics (if any of the results has an error, the overall
- * result is an error).
- * If there are no results, the result is empty (not a failure).
- */
-export declare function combine<T>(parser: Parser, f: (...results: Result[]) => T, results: Result[], errors?: Result[], msg?: DiagnosticMessage | ((Parser: any) => DiagnosticMessage)): Result<T>;
-export declare function parseString(parser: Parser, value: string): Result<string>;
-/** Combinator for a sequence of one or more characters */
-export declare function literal(value: string): Combinator<string>;
-/** Combinator that accepts a "fancy" Unicode alternative for
- * "value".
- *
- * Value can consist of more than one character, for example "!=".
- * It will match the corresponding "≠" fancy version. The fancy
- * versions include the characters listed in FANCY_UNICODE. The
- * fancy version is assumed to be a single Unicode character.
- *
- * Note that superscript numbers and subscript numbers are not
- * included since they need to be handled contextually.
- */
-export declare function fancyLiteral(value: string): Combinator<string>;
-export declare function regex(regex: RegExp): Combinator<string>;
-/**
- * Generator for an ordered, non-empty, sequence of elements separated
- * by whitespace.
- *
- * If the first one fails, the sequence fails (softly).
- * After the first one, if a generator fails, the sequence returns an
- * error.
- */
-export declare function sequence<IR>(cs: (string | Combinator)[], f: (...results: Result[]) => IR): Combinator<IR>;
-/**
- * Explore multiple alternatives.
- * Select the one that advances the most.
- */
-export declare function best<IR>(cs: Combinator[]): Combinator<IR>;
-/**
- * Explore multiple alternatives.
- * Select the first one that matches.
- *
- */
-export declare function either<IR = any>(cs: (string | Combinator)[], f?: (result: Result) => IR): Combinator;
-/**
- *  1 or more `something`
- */
-export declare function many<IR>(something: Combinator<IR>, f: (...results: Result<IR>[]) => IR): Combinator<IR>;
-/**
- * 0 or more `something`.
- *
- * The parser of this combinator will never fail (since ø is an acceptable match).
- * If there are 0 something, the parser will return an Ignore result.
- */
-export declare function some<IR>(something: string | Combinator<IR>, f: (...results: Result<IR>[]) => IR): Combinator<IR>;
-/**
- *  Succeeds even if `something` fails
- */
-export declare function maybe<T>(something: Combinator<T> | string): Combinator<T>;
-/**
- * Return an error if `something` is a failure
- */
-export declare function must<T>(something: string | Combinator<T>, inMsg?: DiagnosticMessage | ((Parser: any) => DiagnosticMessage)): Combinator<T>;
-export declare function eof(): Combinator<boolean>;

package/dist/types/point-free-parser/grammar.d.ts

@@ -1,12 +0,0 @@
-/* 0.4.2 */
-export declare class Grammar<IR> implements Rules {
-    private rules;
-    private ruleDescription;
-    constructor();
-    /** Define a new rule or a rule description */
-    rule<T = IR>(name: string, def: ((Parser: any) => Result<T>) | string | Combinator<T>): void;
-    toString(): string;
-    parse<T = IR>(rule: string, parser: string | Parser, url?: string): Result<T>;
-    has(rule: string): boolean;
-    get(rule: string): (Parser: any) => Result<IR>;
-}

package/dist/types/point-free-parser/identifier-parsers.d.ts

@@ -1,7 +0,0 @@
-/* 0.4.2 */
-export declare function parseIdentifier(parser: Parser): Result<string>;
-/** A verbatim identifier is enclosed in backticks and can
- * include characters that are otherwise invalid (such as `+`).
- * It can also include escape sequences.
- */
-export declare function parseVerbatimIdentifier(parser: Parser): Result<string>;

package/dist/types/point-free-parser/numeric-parsers.d.ts

@@ -1,8 +0,0 @@
-/* 0.4.2 */
-export declare function parseExponent(parser: Parser, prefix: 'e' | 'p'): Result<number>;
-export declare function applyExponent(parser: Parser, start: number, value: number): Result<number>;
-export declare function parseBinaryNumber(parser: Parser): Result<number>;
-export declare function parseHexadecimalNumber(parser: Parser): Result<number>;
-export declare function parseFloatingPointNumber(parser: Parser): Result<number>;
-export declare function parseNumber(parser: Parser): Result<number>;
-export declare function parseSignedNumber(parser: Parser): Result<number>;