clarity-pattern-parser 11.3.10 → 11.3.12

package/dist/Cursor.d.ts

@@ -1,37 +0,0 @@
-import Pattern from "./patterns/Pattern";
-import Node from "./ast/Node";
-import CursorHistory from "./CursorHistory";
-import ParseError from "./patterns/ParseError";
-export default class Cursor {
-    text: string;
-    index: number;
-    length: number;
-    history: CursorHistory;
-    isInErrorState: boolean;
-    constructor(text: string);
-    assertValidity(): void;
-    startRecording(): void;
-    stopRecording(): void;
-    get parseError(): ParseError | null;
-    get lastMatch(): import("./CursorHistory").Match;
-    throwError(parseError: ParseError): void;
-    addMatch(pattern: Pattern, astNode: Node): void;
-    resolveError(): void;
-    hasUnresolvedError(): boolean;
-    isNullOrEmpty(value: string | null): boolean;
-    hasNext(): boolean;
-    hasPrevious(): boolean;
-    next(): void;
-    previous(): void;
-    mark(): number;
-    moveToMark(mark: number): void;
-    moveToBeginning(): void;
-    moveToEnd(): void;
-    getChar(): string;
-    getIndex(): number;
-    setIndex(index: number): void;
-    isAtBeginning(): boolean;
-    isAtEnd(): boolean;
-    lastIndex(): number;
-    didSuccessfullyParse(): boolean;
-}

package/dist/CursorHistory.d.ts

@@ -1,27 +0,0 @@
-import Pattern from "./patterns/Pattern";
-import Node from "./ast/Node";
-import ParseError from "./patterns/ParseError";
-export interface Match {
-    pattern: Pattern | null;
-    astNode: Node | null;
-}
-export default class CursorHistory {
-    isRecording: boolean;
-    furthestMatch: Match;
-    furthestError: ParseError | null;
-    patterns: Pattern[];
-    astNodes: Node[];
-    errors: ParseError[];
-    constructor();
-    addMatch(pattern: Pattern, astNode: Node): void;
-    addError(error: ParseError): void;
-    startRecording(): void;
-    stopRecording(): void;
-    clear(): void;
-    getFurthestError(): ParseError | null;
-    getFurthestMatch(): Match;
-    getLastMatch(): Match;
-    getLastError(): ParseError;
-    getAllParseStacks(): Node[][];
-    getLastParseStack(): Node[];
-}

package/dist/TextSuggester.d.ts

@@ -1,48 +0,0 @@
-import Node from "./ast/Node";
-import Pattern from "./patterns/Pattern";
-export interface Token {
-    startIndex: number;
-    values: string[];
-}
-export interface SuggestionError {
-    startIndex: number;
-    endIndex: number;
-    text: string;
-}
-export interface SuggestionMatch {
-    startIndex: number;
-    endIndex: number;
-    text: string;
-}
-export interface SuggestionResult {
-    pattern: Pattern | null;
-    astNode: Node | null;
-    match: SuggestionMatch | null;
-    error: SuggestionError | null;
-    options: Token;
-    isComplete: boolean;
-    parseStack: Node[];
-}
-export default class TextSuggester {
-    private cursor;
-    private result;
-    private text;
-    private match;
-    private error;
-    private patternMatch;
-    private matchedText;
-    private rootPattern;
-    private tokens;
-    private options;
-    private parseStack;
-    suggest(text: string, pattern: Pattern): SuggestionResult;
-    private reset;
-    private parse;
-    private saveParseStack;
-    private saveMatchedText;
-    private saveMatch;
-    private saveError;
-    private saveNextToken;
-    private saveOptions;
-    static suggest(text: string, pattern: Pattern): SuggestionResult;
-}

package/dist/ast/Visitor.d.ts

@@ -1,31 +0,0 @@
-import { Node } from "./Node";
-export declare class Visitor {
-    root: Node | null;
-    selectedNodes: Node[];
-    constructor(root?: Node | null, selectedNodes?: Node[]);
-    flatten(): this;
-    remove(): this;
-    private recursiveRemove;
-    wrap(callback: (node: Node) => Node): this;
-    unwrap(): this;
-    prepend(callback: (node: Node) => Node): this;
-    append(callback: (node: Node) => Node): this;
-    transform(callback: (node: Node) => Node): this;
-    private recursiveTransform;
-    selectAll(): Visitor;
-    selectNode(node: Node): Visitor;
-    deselectNode(node: Node): Visitor;
-    select(callback: (node: Node) => boolean): Visitor;
-    forEach(callback: (node: Node) => void): this;
-    filter(callback: (node: Node) => boolean): Visitor;
-    map(callback: (node: Node) => Node): Visitor;
-    selectRoot(): Visitor;
-    first(): Visitor;
-    last(): Visitor;
-    get(index: number): Visitor;
-    clear(): this;
-    setRoot(root: Node | null): this;
-    static select(root: Node, callback?: (node: Node) => boolean): Visitor;
-    static walkUp(node: Node, callback: (node: Node, ancestors: Node[]) => void, ancestors?: Node[]): typeof Visitor;
-    static walkDown(node: Node, callback: (node: Node, ancestors: Node[]) => void, ancestors?: Node[]): typeof Visitor;
-}

package/dist/grammar/patterns/andLiteral.d.ts

@@ -1,4 +0,0 @@
-import { Repeat } from "../../patterns/Repeat";
-import { And } from "../../patterns/And";
-export declare const pattern: And;
-export declare const andLiteral: Repeat;

package/dist/grammar/patterns/inlinePattern.d.ts

@@ -1 +0,0 @@
-export declare const inlinePattern: any;

package/dist/grammar/patterns/orLiteral.d.ts

@@ -1,2 +0,0 @@
-import { Repeat } from "../../patterns/Repeat";
-export declare const orLiteral: Repeat;

package/dist/patterns/And.d.ts

@@ -1,41 +0,0 @@
-import { Cursor } from "./Cursor";
-import { Pattern } from "./Pattern";
-import { Node } from "../ast/Node";
-export declare class And implements Pattern {
-    private _id;
-    private _type;
-    private _name;
-    private _parent;
-    private _children;
-    private _isOptional;
-    private _nodes;
-    private _firstIndex;
-    get id(): string;
-    get type(): string;
-    get name(): string;
-    get parent(): Pattern | null;
-    set parent(pattern: Pattern | null);
-    get children(): Pattern[];
-    get isOptional(): boolean;
-    constructor(name: string, sequence: Pattern[], isOptional?: boolean);
-    private _assignChildrenToParent;
-    test(text: string): boolean;
-    exec(text: string, record?: boolean): {
-        ast: Node | null;
-        cursor: Cursor;
-    };
-    parse(cursor: Cursor): Node | null;
-    private tryToParse;
-    private getLastValidNode;
-    private areRemainingPatternsOptional;
-    private createNode;
-    getTokens(): string[];
-    getTokensAfter(childReference: Pattern): string[];
-    getNextTokens(): string[];
-    getPatterns(): Pattern[];
-    getPatternsAfter(childReference: Pattern): Pattern[];
-    getNextPatterns(): Pattern[];
-    find(predicate: (p: Pattern) => boolean): Pattern | null;
-    clone(name?: string, isOptional?: boolean): Pattern;
-    isEqual(pattern: And): boolean;
-}

package/dist/patterns/DepthCache.d.ts

@@ -1,6 +0,0 @@
-export declare class DepthCache {
-    private _depthMap;
-    getDepth(name: string, cursorIndex: number): number;
-    incrementDepth(name: string, cursorIndex: number): void;
-    decrementDepth(name: string, cursorIndex: number): void;
-}

package/dist/patterns/ExpressionPattern.d.ts

@@ -1,66 +0,0 @@
-import { Node } from "../ast/Node";
-import { Cursor } from "./Cursor";
-import { ParseResult } from "./ParseResult";
-import { Pattern } from "./Pattern";
-export declare class ExpressionPattern implements Pattern {
-    private _id;
-    private _type;
-    private _name;
-    private _parent;
-    private _firstIndex;
-    private _originalPatterns;
-    private _patterns;
-    private _atomPatterns;
-    private _prefixPatterns;
-    private _prefixNames;
-    private _postfixPatterns;
-    private _postfixNames;
-    private _binaryPatterns;
-    private _binaryNames;
-    private _associationMap;
-    private _precedenceMap;
-    private _shouldStopParsing;
-    private _precedenceTree;
-    get id(): string;
-    get type(): string;
-    get name(): string;
-    get parent(): Pattern | null;
-    set parent(pattern: Pattern | null);
-    get children(): Pattern[];
-    get prefixPatterns(): readonly Pattern[];
-    get atomPatterns(): readonly Pattern[];
-    get postfixPatterns(): readonly Pattern[];
-    get binaryPatterns(): readonly Pattern[];
-    get startedOnIndex(): number;
-    constructor(name: string, patterns: Pattern[]);
-    private _organizePatterns;
-    private _extractName;
-    private _isPrefix;
-    private _extractPrefix;
-    private _isAtom;
-    private _isPostfix;
-    private _extractPostfix;
-    private _isBinary;
-    private _extractBinary;
-    private _unwrapAssociationIfNecessary;
-    private _referenceCount;
-    private _isRecursiveReference;
-    parse(cursor: Cursor): Node | null;
-    private _tryToParse;
-    private _tryToMatchPrefix;
-    private _tryToMatchAtom;
-    private _tryToMatchPostfix;
-    private _tryToMatchBinary;
-    private _isBeyondRecursiveAllowance;
-    test(text: string, record?: boolean): boolean;
-    exec(text: string, record?: boolean): ParseResult;
-    getTokens(): string[];
-    getTokensAfter(childReference: Pattern): string[];
-    getNextTokens(): string[];
-    getPatterns(): Pattern[];
-    getPatternsAfter(childReference: Pattern): Pattern[];
-    getNextPatterns(): Pattern[];
-    find(predicate: (p: Pattern) => boolean): Pattern | null;
-    clone(name?: string): Pattern;
-    isEqual(pattern: ExpressionPattern): boolean;
-}

package/dist/patterns/LookAhead.d.ts

@@ -1,8 +0,0 @@
-import Cursor from "../Cursor";
-import Pattern from "./Pattern";
-export default class LookAhead extends Pattern {
-    constructor(pattern: Pattern);
-    parse(cursor: Cursor): null;
-    clone(): LookAhead;
-    getTokens(): never[];
-}

package/dist/patterns/Or.d.ts

@@ -1,36 +0,0 @@
-import { Node } from "../ast/Node";
-import { Cursor } from "./Cursor";
-import { Pattern } from "./Pattern";
-import { ParseResult } from "./ParseResult";
-export declare class Or implements Pattern {
-    private _id;
-    private _type;
-    private _name;
-    private _parent;
-    private _children;
-    private _isOptional;
-    private _isGreedy;
-    private _firstIndex;
-    get id(): string;
-    get type(): string;
-    get name(): string;
-    get parent(): Pattern | null;
-    set parent(pattern: Pattern | null);
-    get children(): Pattern[];
-    get isOptional(): boolean;
-    constructor(name: string, options: Pattern[], isOptional?: boolean, isGreedy?: boolean);
-    private _assignChildrenToParent;
-    test(text: string): boolean;
-    exec(text: string, record?: boolean): ParseResult;
-    parse(cursor: Cursor): Node | null;
-    private _tryToParse;
-    getTokens(): string[];
-    getTokensAfter(_childReference: Pattern): string[];
-    getNextTokens(): string[];
-    getPatterns(): Pattern[];
-    getPatternsAfter(_childReference: Pattern): Pattern[];
-    getNextPatterns(): Pattern[];
-    find(predicate: (p: Pattern) => boolean): Pattern | null;
-    clone(name?: string, isOptional?: boolean): Pattern;
-    isEqual(pattern: Or): boolean;
-}

package/dist/patterns/Recursive.d.ts

@@ -1,12 +0,0 @@
-import Pattern from "./Pattern";
-import Cursor from "../Cursor";
-export default class Recursive extends Pattern {
-    isRecursing: boolean;
-    pattern: Pattern | null;
-    constructor(name: string, isOptional?: boolean);
-    getPattern(): Pattern | null;
-    private climb;
-    parse(cursor: Cursor): import("..").Node | null;
-    clone(name?: string, isOptional?: boolean): Recursive;
-    getTokens(): string[];
-}

package/dist/patterns/RightAssociatedPattern.d.ts

@@ -1,31 +0,0 @@
-import { Node } from "../ast/Node";
-import { Cursor } from "./Cursor";
-import { ParseResult } from "./ParseResult";
-import { Pattern } from "./Pattern";
-export declare class RightAssociatedPattern implements Pattern {
-    private _id;
-    private _type;
-    private _name;
-    private _parent;
-    private _children;
-    get id(): string;
-    get type(): string;
-    get name(): string;
-    get parent(): Pattern | null;
-    set parent(pattern: Pattern | null);
-    get children(): Pattern[];
-    get startedOnIndex(): number;
-    constructor(pattern: Pattern);
-    parse(cursor: Cursor): Node | null;
-    exec(text: string, record?: boolean | undefined): ParseResult;
-    test(text: string, record?: boolean | undefined): boolean;
-    clone(_name?: string | undefined): Pattern;
-    getTokens(): string[];
-    getTokensAfter(_childReference: Pattern): string[];
-    getNextTokens(): string[];
-    getPatterns(): Pattern[];
-    getPatternsAfter(_childReference: Pattern): Pattern[];
-    getNextPatterns(): Pattern[];
-    find(predicate: (pattern: Pattern) => boolean): Pattern | null;
-    isEqual(pattern: Pattern): boolean;
-}

package/dist/patterns/arePatternsEqual.d.ts

@@ -1,2 +0,0 @@
-import { Pattern } from "./Pattern";
-export declare function arePatternsEqual(a?: Pattern | null, b?: Pattern | null): boolean;

package/dist/patterns/getNextPattern.d.ts

@@ -1,2 +0,0 @@
-import { Pattern } from "./Pattern";
-export declare function getNextPattern(pattern: Pattern): Pattern | null;