@cortex-js/compute-engine 0.4.2 → 0.4.3

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

@@ -1,130 +0,0 @@
-/* 0.4.2 */
-export declare type DiagnosticMessage = DiagnosticCode | [DiagnosticCode, ...any];
-/**
- * The parser will attempt to continue parsing even when an error is
- * encountered.
- *
- * However, in the rare cases where parsing cannot proceed, this
- * error will be thrown.
- *
- * This would happen if a `#error` directive is encountered.
- */
-export declare class FatalParsingError extends Error {
-    constructor(msg: string);
-}
-export declare type Fixit = [start: number, end: number, value: string];
-export declare type ParsingDiagnostic = {
-    severity: 'warning' | 'error';
-    message: DiagnosticMessage;
-    range: [start: number, end: number, position?: number];
-    fixits?: Fixit[];
-};
-export interface Rules {
-    parse<T = any>(name: string, parser: Parser | string, url?: string): Result<T>;
-    has(name: string): boolean;
-}
-export declare type Combinator<T = any> = [
-    label: string,
-    parser: (parser: Parser) => Result<T>
-];
-/**
- * The `Parser` keeps track of what we are parsing (the source) and what we have
- * parsed so far (the offset).
- */
-export declare class Parser {
-    private rules;
-    readonly url: string;
-    readonly source: string;
-    protected _offset: number;
-    length: number;
-    private _trace;
-    constructor(rules: Rules, source: string, url: string);
-    get(offset: number): number;
-    atEnd(): boolean;
-    atLinebreak(): boolean;
-    atString(s: string): boolean;
-    slice(start: number, end?: number): string;
-    get offset(): number;
-    trace(rule: string | Combinator | ((parser: Parser) => Result)): string[];
-    skipTo(offset: number): Parser;
-    fatalError(msg: string): void;
-    hasRule(rule: string): boolean;
-    parse<T>(rule: string | Combinator<T> | ((parser: Parser) => Result<T>), fromOffset?: number): Result<T>;
-    parseWhitespace(): Result<boolean>;
-    ignore(): Result;
-    failure(): Result;
-}
-/**
- * The result of applying a parsing rule:
- * - `Ignore`: the rule matched and the result can be ignored
- * - `Failure`: the rule did not match at all. Maybe try something else?
- * - `Success`: the rule matched and generated a value that can be passed on.
- * - `Error`: the rule matched, then something went wrong. Probably a
- * syntax error. It still produced a value so the parsing can attempt to
- * recover and continue (Panic Mode).
- */
-export declare class Result<IR = any> {
-    readonly _parser: Parser;
-    _value: undefined | null | IR;
-    _diagnostics?: ParsingDiagnostic[];
-    _range: [start: number, end: number];
-    constructor(parser: Parser);
-    copyDiagnostics(from: Result<any>): void;
-    get parser(): Parser;
-    get diagnostics(): ParsingDiagnostic[];
-    get isFailure(): boolean;
-    get isEmpty(): boolean;
-    get isSuccess(): boolean;
-    get isError(): boolean;
-    get start(): number;
-    get end(): number;
-    set end(val: number);
-    set range(val: [start: number, end: number]);
-    get value(): IR | undefined | null;
-    set value(val: IR | undefined | null);
-    /**
-     * Use when a portion of the source has been successfully parsed.
-     */
-    success(val: IR): Result<IR>;
-    /**
-     * A `failure` indicates a failed attempt to parse, with no presumption
-     * of success, for example when exploring multiple alternatives.
-     *
-     * `state` indicate where to restart parsing from.
-     *
-     * The `error` includes the origin (offset) of the failure. It could be after
-     * the `state`.
-     *
-     */
-    failure(): Result;
-    /**
-     * An `ignore` result indicates success in parsing, but with a result that
-     * can be ignored.
-     *
-     * This is useful for whitespace, keywords, braces and other similar syntactic
-     * constructs.
-     *
-     * `next` is the offset from which parsing can continue.
-     * `start` is the offset in the source where the element was first ignored.
-     *
-     */
-    ignore(): Result;
-    ignoreUntil(offset: number): Result;
-    /**
-     * An `error` is used when an unexpected failure was encountered.
-     * It typically indicates a syntax error.
-     *
-     * Nonetheless, an attempt is made to recover.
-     *
-     * The range indicate the portion of the source covered by this result.
-     * The optional `pos` indicate where the error occurred. It's the `end`
-     * by default.
-     *
-     */
-    error(value: IR, msg: DiagnosticMessage | ((Parser: any) => DiagnosticMessage), fixits?: Fixit[]): Result<IR>;
-    errorAt(value: IR | null, msg: DiagnosticMessage | ((Parser: any) => DiagnosticMessage), pos: number, fixits?: Fixit[]): Result<IR>;
-    errorFrom(result: Result, value: IR): Result<IR>;
-    warning(msg: DiagnosticMessage, fixits?: Fixit[]): Result;
-}
-export declare function skipUntil(parser: Parser, value: number): number;
-export declare function skipUntilString(parser: Parser, pattern: string): number;

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

@@ -1,29 +0,0 @@
-/* 0.4.2 */
-/** Parse an escape sequence such as `\n` or `\u0041`*/
-export declare function parseEscapeSequence(parser: Parser): Result<string>;
-/** A key string is a sequence of non-White_Space, non-Syntax characters */
-export declare function parseKeyString(parser: Parser): Result<string>;
-/** An extended string is surrounded by `###"..."###` or `#"..."#` and
- * contains no escape sequence. Convenient for strings that contain lots
- * of characters that would otherwise need to be escaped: quotation marks,
- * backslash, etc...
- *
- */
-export declare function parseExtendedString(parser: Parser): Result<string>;
-/** At the `\` of a `\(...)` expression */
-export declare function parseInterpolation<IR>(parser: Parser, expression?: string | ((parser: Parser) => Result<IR>)): Result<IR>;
-/** A single line string is surrounded by quotation mark and may include escape sequences.
- *
- * @param expression - a function that parses an expression inside a `\()` escape sequence
- *
- */
-export declare function parseSingleLineString<T>(parser: Parser, expression?: string | ((parser: Parser) => Result<T>)): Result<(string | T)[]>;
-/**
- * A multiline line string begins and end with a triple quotation mark """
- * It can span multiple lines and contain escape sequences.
- *
- * @param expression - a function that parses an expresion inside a `\()`
- * escape sequence
- *
- */
-export declare function parseMultilineString<T>(parser: Parser, expression: string): Result<(string | T)[]>;

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

@@ -1,17 +0,0 @@
-/* 0.4.2 */
-export declare function skipInlineSpaces(parser: Parser): void;
-/**
- * Skip all characters until a linebreak
- */
-export declare function skipUntilLinebreak(parser: Parser): void;
-/**
- * If we are on a linebreak, skip it
- */
-export declare function skipLinebreak(parser: Parser): void;
-/**
- * Whitespace includes space, tab, mathematical space, and comments.
- */
-export declare function parseWhitespace(parser: Parser): Result<boolean>;
-export declare function parseLineComment(parser: Parser): Result<boolean>;
-export declare function parseBlockComment(parser: Parser): Result<boolean>;
-export declare function parseShebang(parser: Parser): Result<boolean>;

package/dist/types/public.d.ts

@@ -1,163 +0,0 @@
-/* 0.4.2 */
-export declare type SignalCode = RuntimeSignalCode | ('syntax-error' | 'invalid-name' | 'expected-predicate' | 'expected-symbol' | 'cyclic-definition' | 'invalid-supersets' | 'expected-supersets' | 'unknown-domain' | 'duplicate-wikidata' | 'invalid-dictionary-entry');
-export declare type SignalMessage = SignalCode | [SignalCode, ...any[]];
-export declare type SignalOrigin = {
-    url?: string;
-    source?: string;
-    offset?: number;
-    line?: number;
-    column?: number;
-    around?: string;
-};
-export declare type Signal = {
-    severity?: 'warning' | 'error';
-    message: SignalMessage;
-    head?: string;
-    origin?: SignalOrigin;
-};
-export declare type ErrorSignal = Signal & {
-    severity: 'error';
-};
-export declare class CortexError extends Error {
-    constructor(errorSignal: Signal);
-    toString(): string;
-}
-export declare type WarningSignal = Signal & {
-    severity: 'warning';
-};
-export declare type ErrorSignalHandler = (error: ErrorSignal) => void;
-export declare type WarningSignalHandler = (warnings: WarningSignal[]) => void;
-export declare type ErrorListener<T> = (err: {
-    code: T;
-    arg?: string;
-    latex?: string;
-    before?: string;
-    after?: string;
-}) => void;
-/**
- * * `unknown-symbol`: a symbol was encountered which does not have a
- * definition.
- *
- * * `unknown-operator`: a presumed operator was encountered which does not
- * have a definition.
- *
- * * `unknown-function`: a Latex command was encountered which does not
- * have a definition.
- *
- * * `unexpected-command`: a Latex command was encountered when only a string
- * was expected
- *
- * * `unexpected-superscript`: a superscript was encountered in an unexpected
- * context, or no `powerFunction` was defined. By default, superscript can
- * be applied to numbers, symbols or expressions, but not to operators (e.g.
- * `2+^34`) or to punctuation.
- *
- * * `unexpected-subscript`: a subscript was encountered in an unexpected
- * context or no 'subscriptFunction` was defined. By default, subscripts
- * are not expected on numbers, operators or symbols. Some commands (e.g. `\sum`)
- * do expected a subscript.
- *
- * * `unexpected-sequence`: some adjacent elements were encountered (for
- * example `xy`), but no `invisibleOperator` is defined, therefore the elements
- * can't be combined. The default `invisibleOperator` is `multiply`, but you
- * can also use `list`.
- *
- * * `expected-argument`: a Latex command that requires one or more argument
- * was encountered without the required arguments.
- *
- * * `expected-operand`: an operator was encountered without its required
- * operands.
- *
- * * `non-associative-operator`: an operator which is not associative was
- * encountered in an associative context, for example: `a < b < c` (assuming
- * `<` is defined as non-associative)
- *
- * * `postfix-operator-requires-one-operand`: a postfix operator which requires
- * a single argument was encountered with no arguments or more than one argument
- *
- * * `prefix-operator-requires-one-operand`: a prefix operator which requires
- * a single argument was encountered with no arguments or more than one argument
- *
- * * `base-out-of-range`:  The base is expected to be between 2 and 36.
- *
- */
-export declare type ErrorCode = 'expected-argument' | 'unexpected-argument' | 'expected-operator' | 'expected-operand' | 'invalid-name' | 'invalid-dictionary-entry' | 'unknown-symbol' | 'unknown-operator' | 'unknown-function' | 'unknown-command' | 'unexpected-command' | 'unbalanced-symbols' | 'unexpected-superscript' | 'unexpected-subscript' | 'unexpected-sequence' | 'non-associative-operator' | 'function-has-too-many-arguments' | 'function-has-too-few-arguments' | 'operator-requires-one-operand' | 'infix-operator-requires-two-operands' | 'prefix-operator-requires-one-operand' | 'postfix-operator-requires-one-operand' | 'associative-function-has-too-few-arguments' | 'commutative-function-has-too-few-arguments' | 'threadable-function-has-too-few-arguments' | 'hold-first-function-has-too-few-arguments' | 'hold-rest-function-has-too-few-arguments' | 'base-out-of-range' | 'syntax-error';
-export declare type Attributes = {
-    /** A human readable string to annotate an expression, since JSON does not
-     * allow comments in its encoding */
-    comment?: string;
-    /** A Markdown-encoded string providing documentation about this expression.
-     */
-    documentation?: string;
-    /** A human readable string to indicate a syntax error or
-     * other problem when parsing or evaluating an expression.
-     */
-    error?: string;
-    /** A visual representation in LaTeX of the expression.
-     *
-     * This can be useful to preserve non-semantic details, for example
-     * parentheses in an expression or styling attributes
-     */
-    latex?: string;
-    /**
-     * A short string indicating an entry in a wikibase.
-     *
-     * For example
-     * `"Q167"` is the [wikidata entry](https://www.wikidata.org/wiki/Q167)
-     *  for the Pi constant.
-     */
-    wikidata?: string;
-    /** A base URL for the `wikidata` key.
-     *
-     * A full URL can be produced by concatenating this key with the `wikidata`
-     * key. This key applies to this node and all its children.
-     *
-     * The default value is "https://www.wikidata.org/wiki/"
-     */
-    wikibase?: string;
-    /** A short string indicating an entry in an OpenMath Content Dictionary.
-     *
-     * For example: `arith1/#abs`.
-     *
-     */
-    openmathSymbol?: string;
-    /** A base URL for an OpenMath content dictionary. This key applies to this
-     * node and all its children.
-     *
-     * The default value is "http://www.openmath.org/cd".
-     */
-    openmathCd?: string;
-    /**  A url to the source of this expression.
-     */
-    sourceUrl?: string;
-    /** The source from which this expression was generated.
-     *
-     * It could be a Latex expression, or some other source language
-     */
-    sourceContent?: string;
-    /**
-     * A character offset in `sourceContent` or `sourceUrl` from which this
-     * expression was generated
-     */
-    sourceOffsets?: [start: number, end: number];
-};
-export declare type MathJsonBasicNumber = 'NaN' | '-Infinity' | '+Infinity' | string;
-export declare type MathJsonRealNumber = {
-    num: MathJsonBasicNumber;
-} & Attributes;
-export declare type MathJsonSymbol = {
-    sym: string;
-} & Attributes;
-export declare type MathJsonString = {
-    str: string;
-} & Attributes;
-export declare type MathJsonFunction<T extends number = number> = {
-    fn: Expression<T>[];
-} & Attributes;
-export declare type MathJsonDictionary<T extends number = number> = {
-    dict: {
-        [key: string]: Expression<T>;
-    };
-} & Attributes;
-export declare type Expression<T extends number = number> = T | MathJsonRealNumber | MathJsonString | MathJsonSymbol | string | MathJsonFunction<T> | MathJsonDictionary<T> | Expression<T>[];
-export declare type DictionaryCategory = 'algebra' | 'arithmetic' | 'calculus' | 'collections' | 'complex' | 'combinatorics' | 'core' | 'dimensions' | 'domains' | 'inequalities' | 'intervals' | 'linear-algebra' | 'logic' | 'numeric' | 'other' | 'physics' | 'polynomials' | 'relations' | 'rounding' | 'sets' | 'statistics' | 'symbols' | 'transcendentals' | 'trigonometry' | 'units';