clarity-pattern-parser 8.4.14 → 9.0.0

package/dist/patterns/CursorHistory.d.ts

@@ -1,6 +1,10 @@
 import { Node } from "../ast/Node";
 import { ParseError } from "./ParseError";
 import { Pattern } from "./Pattern";
+export interface Trace {
+    pattern: Pattern;
+    cursorIndex: number;
+}
 export interface Match {
     pattern: Pattern | null;
     node: Node | null;
@@ -14,6 +18,7 @@ export declare class CursorHistory {
     private _patterns;
     private _nodes;
     private _errors;
+    private _trace;
     get isRecording(): boolean;
     get rootMatch(): Match;
     get leafMatch(): Match;
@@ -23,9 +28,11 @@ export declare class CursorHistory {
     get error(): ParseError | null;
     get nodes(): Node[];
     get patterns(): Pattern[];
+    get trace(): Trace[];
     recordMatch(pattern: Pattern, node: Node): void;
     recordErrorAt(firstIndex: number, lastIndex: number, pattern: Pattern): void;
     startRecording(): void;
     stopRecording(): void;
     resolveError(): void;
+    pushStackTrace(trace: Trace): void;
 }

package/dist/patterns/FiniteRepeat.d.ts

@@ -8,6 +8,7 @@ export interface FiniteRepeatOptions {
     trimDivider?: boolean;
 }
 export declare class FiniteRepeat implements Pattern {
+    private _id;
     private _type;
     private _name;
     private _parent;
@@ -16,6 +17,7 @@ export declare class FiniteRepeat implements Pattern {
     private _min;
     private _max;
     private _trimDivider;
+    get id(): string;
     get type(): string;
     get name(): string;
     get parent(): Pattern | null;
@@ -27,7 +29,7 @@ export declare class FiniteRepeat implements Pattern {
     constructor(name: string, pattern: Pattern, repeatAmount: number, options?: FiniteRepeatOptions);
     parse(cursor: Cursor): Node | null;
     test(text: string): boolean;
-    exec(text: string): ParseResult;
+    exec(text: string, record?: boolean): ParseResult;
     clone(name?: string, isOptional?: boolean): Pattern;
     getTokens(): string[];
     getTokensAfter(childReference: Pattern): string[];
@@ -36,4 +38,5 @@ export declare class FiniteRepeat implements Pattern {
     getPatternsAfter(childReference: Pattern): Pattern[];
     getNextPatterns(): Pattern[];
     find(predicate: (p: Pattern) => boolean): Pattern | null;
+    isEqual(pattern: FiniteRepeat): boolean;
 }

package/dist/patterns/InfiniteRepeat.d.ts

@@ -1,12 +1,14 @@
 import { Node } from "../ast/Node";
 import { Cursor } from "./Cursor";
 import { Pattern } from "./Pattern";
+import { ParseResult } from "./ParseResult";
 export interface InfiniteRepeatOptions {
     divider?: Pattern;
     min?: number;
     trimDivider?: boolean;
 }
 export declare class InfiniteRepeat implements Pattern {
+    private _id;
     private _type;
     private _name;
     private _parent;
@@ -17,6 +19,7 @@ export declare class InfiniteRepeat implements Pattern {
     private _firstIndex;
     private _min;
     private _trimDivider;
+    get id(): string;
     get type(): string;
     get name(): string;
     get parent(): Pattern | null;
@@ -27,10 +30,7 @@ export declare class InfiniteRepeat implements Pattern {
     constructor(name: string, pattern: Pattern, options?: InfiniteRepeatOptions);
     private _assignChildrenToParent;
     test(text: string): boolean;
-    exec(text: string): {
-        ast: Node | null;
-        cursor: Cursor;
-    };
+    exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
     private _meetsMin;
     private _tryToParse;
@@ -44,4 +44,5 @@ export declare class InfiniteRepeat implements Pattern {
     getNextPatterns(): Pattern[];
     find(predicate: (p: Pattern) => boolean): Pattern | null;
     clone(name?: string, isOptional?: boolean): Pattern;
+    isEqual(pattern: InfiniteRepeat): boolean;
 }

package/dist/patterns/Literal.d.ts

@@ -1,16 +1,19 @@
 import { Node } from "../ast/Node";
 import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
 import { Pattern } from "./Pattern";
 export declare class Literal implements Pattern {
+    private _id;
     private _type;
     private _name;
     private _parent;
     private _isOptional;
-    private _literal;
+    private _text;
     private _runes;
     private _firstIndex;
     private _lastIndex;
     private _endIndex;
+    get id(): string;
     get type(): string;
     get name(): string;
     get parent(): Pattern | null;
@@ -19,10 +22,7 @@ export declare class Literal implements Pattern {
     get isOptional(): boolean;
     constructor(name: string, value: string, isOptional?: boolean);
     test(text: string): boolean;
-    exec(text: string): {
-        ast: Node | null;
-        cursor: Cursor;
-    };
+    exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
     private _tryToParse;
     private _createNode;
@@ -34,4 +34,5 @@ export declare class Literal implements Pattern {
     getPatternsAfter(): Pattern[];
     getNextPatterns(): Pattern[];
     find(_predicate: (p: Pattern) => boolean): Pattern | null;
+    isEqual(pattern: Literal): boolean;
 }

package/dist/patterns/Not.d.ts

@@ -1,11 +1,14 @@
 import { Node } from "../ast/Node";
 import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
 import { Pattern } from "./Pattern";
 export declare class Not 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;
@@ -14,10 +17,7 @@ export declare class Not implements Pattern {
     get isOptional(): boolean;
     constructor(name: string, pattern: Pattern);
     test(text: string): boolean;
-    exec(text: string): {
-        ast: Node | null;
-        cursor: Cursor;
-    };
+    exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
     clone(name?: string): Pattern;
     getTokens(): string[];
@@ -27,4 +27,5 @@ export declare class Not implements Pattern {
     getPatternsAfter(_childReference: Pattern): Pattern[];
     getNextPatterns(): Pattern[];
     find(predicate: (p: Pattern) => boolean): Pattern | null;
+    isEqual(pattern: Not): boolean;
 }

package/dist/patterns/Or.d.ts

@@ -1,7 +1,9 @@
 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;
@@ -9,6 +11,7 @@ export declare class Or implements Pattern {
     private _isOptional;
     private _isGreedy;
     private _firstIndex;
+    get id(): string;
     get type(): string;
     get name(): string;
     get parent(): Pattern | null;
@@ -18,10 +21,7 @@ export declare class Or implements Pattern {
     constructor(name: string, options: Pattern[], isOptional?: boolean, isGreedy?: boolean);
     private _assignChildrenToParent;
     test(text: string): boolean;
-    exec(text: string): {
-        ast: Node | null;
-        cursor: Cursor;
-    };
+    exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
     private _tryToParse;
     getTokens(): string[];
@@ -32,4 +32,5 @@ export declare class Or implements Pattern {
     getNextPatterns(): Pattern[];
     find(predicate: (p: Pattern) => boolean): Pattern | null;
     clone(name?: string, isOptional?: boolean): Pattern;
+    isEqual(pattern: Or): boolean;
 }

package/dist/patterns/Pattern.d.ts

@@ -2,14 +2,15 @@ import { Cursor } from "./Cursor";
 import { Node } from "../ast/Node";
 import { ParseResult } from "./ParseResult";
 export interface Pattern {
+    id: string;
     type: string;
     name: string;
     parent: Pattern | null;
     children: Pattern[];
     isOptional: boolean;
     parse(cursor: Cursor): Node | null;
-    exec(text: string): ParseResult;
-    test(text: string): boolean;
+    exec(text: string, record?: boolean): ParseResult;
+    test(text: string, record?: boolean): boolean;
     clone(name?: string, isOptional?: boolean): Pattern;
     getTokens(): string[];
     getTokensAfter(childReference: Pattern): string[];
@@ -18,4 +19,5 @@ export interface Pattern {
     getPatternsAfter(childReference: Pattern): Pattern[];
     getNextPatterns(): Pattern[];
     find(predicate: (p: Pattern) => boolean): Pattern | null;
+    isEqual(pattern: Pattern): boolean;
 }

package/dist/patterns/Reference.d.ts

@@ -1,13 +1,16 @@
 import { Node } from "../ast/Node";
 import { Cursor } from "./Cursor";
 import { Pattern } from "./Pattern";
+import { ParseResult } from "./ParseResult";
 export declare class Reference implements Pattern {
+    private _id;
     private _type;
     private _name;
     private _parent;
     private _isOptional;
     private _pattern;
     private _children;
+    get id(): string;
     get type(): string;
     get name(): string;
     get parent(): Pattern | null;
@@ -16,10 +19,7 @@ export declare class Reference implements Pattern {
     get isOptional(): boolean;
     constructor(name: string, isOptional?: boolean);
     test(text: string): boolean;
-    exec(text: string): {
-        ast: Node | null;
-        cursor: Cursor;
-    };
+    exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
     private _getPatternSafely;
     private _findPattern;
@@ -32,4 +32,5 @@ export declare class Reference implements Pattern {
     getNextPatterns(): Pattern[];
     find(_predicate: (p: Pattern) => boolean): Pattern | null;
     clone(name?: string, isOptional?: boolean): Pattern;
+    isEqual(pattern: Reference): boolean;
 }

package/dist/patterns/Regex.d.ts

@@ -1,7 +1,9 @@
 import { Node } from "../ast/Node";
 import { Pattern } from "./Pattern";
 import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
 export declare class Regex implements Pattern {
+    private _id;
     private _type;
     private _name;
     private _isOptional;
@@ -13,6 +15,7 @@ export declare class Regex implements Pattern {
     private _firstIndex;
     private _substring;
     private _tokens;
+    get id(): string;
     get type(): string;
     get name(): string;
     get parent(): Pattern | null;
@@ -22,10 +25,7 @@ export declare class Regex implements Pattern {
     constructor(name: string, regex: string, isOptional?: boolean);
     private assertArguments;
     test(text: string): boolean;
-    exec(text: string): {
-        ast: Node | null;
-        cursor: Cursor;
-    };
+    exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
     private resetState;
     private tryToParse;
@@ -40,4 +40,5 @@ export declare class Regex implements Pattern {
     getNextPatterns(): Pattern[];
     find(_predicate: (p: Pattern) => boolean): Pattern | null;
     setTokens(tokens: string[]): void;
+    isEqual(pattern: Regex): boolean;
 }

package/dist/patterns/Repeat.d.ts

@@ -9,11 +9,13 @@ export interface RepeatOptions {
     trimDivider?: boolean;
 }
 export declare class Repeat implements Pattern {
+    private _id;
     private _repeatPattern;
     private _parent;
     private _pattern;
     private _options;
     private _children;
+    get id(): string;
     get type(): string;
     get name(): string;
     get parent(): Pattern | null;
@@ -32,4 +34,5 @@ export declare class Repeat implements Pattern {
     getPatternsAfter(_childReference: Pattern): Pattern[];
     getNextPatterns(): Pattern[];
     find(predicate: (p: Pattern) => boolean): Pattern | null;
+    isEqual(pattern: Repeat): boolean;
 }

package/dist/patterns/arePatternsEqual.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "8.4.14",
+  "version": "9.0.0",
   "description": "Parsing Library for Typescript and Javascript.",
   "main": "./dist/index.js",
   "module": "./dist/index.esm.js",