clarity-pattern-parser 9.0.0 → 9.2.0

package/dist/patterns/FiniteRepeat.d.ts

@@ -5,6 +5,7 @@ import { Pattern } from "./Pattern";
 export interface FiniteRepeatOptions {
     divider?: Pattern;
     min?: number;
+    max?: number;
     trimDivider?: boolean;
 }
 export declare class FiniteRepeat implements Pattern {
@@ -23,14 +24,13 @@ export declare class FiniteRepeat implements Pattern {
     get parent(): Pattern | null;
     set parent(value: Pattern | null);
     get children(): Pattern[];
-    get isOptional(): boolean;
     get min(): number;
     get max(): number;
-    constructor(name: string, pattern: Pattern, repeatAmount: number, options?: FiniteRepeatOptions);
+    constructor(name: string, pattern: Pattern, options?: FiniteRepeatOptions);
     parse(cursor: Cursor): Node | null;
     test(text: string): boolean;
     exec(text: string, record?: boolean): ParseResult;
-    clone(name?: string, isOptional?: boolean): Pattern;
+    clone(name?: string): Pattern;
     getTokens(): string[];
     getTokensAfter(childReference: Pattern): string[];
     getNextTokens(): string[];

package/dist/patterns/InfiniteRepeat.d.ts

@@ -25,7 +25,6 @@ export declare class InfiniteRepeat implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
-    get isOptional(): boolean;
     get min(): number;
     constructor(name: string, pattern: Pattern, options?: InfiniteRepeatOptions);
     private _assignChildrenToParent;
@@ -43,6 +42,6 @@ export declare class InfiniteRepeat implements Pattern {
     getPatternsAfter(childReference: Pattern): Pattern[];
     getNextPatterns(): Pattern[];
     find(predicate: (p: Pattern) => boolean): Pattern | null;
-    clone(name?: string, isOptional?: boolean): Pattern;
+    clone(name?: string): Pattern;
     isEqual(pattern: InfiniteRepeat): boolean;
 }

package/dist/patterns/Literal.d.ts

@@ -7,7 +7,6 @@ export declare class Literal implements Pattern {
     private _type;
     private _name;
     private _parent;
-    private _isOptional;
     private _text;
     private _runes;
     private _firstIndex;
@@ -16,17 +15,17 @@ export declare class Literal implements Pattern {
     get id(): string;
     get type(): string;
     get name(): string;
+    get value(): string;
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
-    get isOptional(): boolean;
-    constructor(name: string, value: string, isOptional?: boolean);
+    constructor(name: string, value: string);
     test(text: string): boolean;
     exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
     private _tryToParse;
     private _createNode;
-    clone(name?: string, isOptional?: boolean): Pattern;
+    clone(name?: string): Pattern;
     getTokens(): string[];
     getTokensAfter(_lastMatched: Pattern): string[];
     getNextTokens(): string[];

package/dist/patterns/Optional.d.ts

@@ -0,0 +1,30 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { ParseResult } from "./ParseResult";
+import { Pattern } from "./Pattern";
+export declare class Optional 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[];
+    constructor(name: string, pattern: Pattern);
+    test(text: string): boolean;
+    exec(text: string, record?: boolean): ParseResult;
+    parse(cursor: Cursor): Node | null;
+    clone(name?: string): Pattern;
+    getTokens(): string[];
+    getTokensAfter(_childReference: Pattern): string[];
+    getNextTokens(): string[];
+    getPatterns(): Pattern[];
+    getPatternsAfter(_childReference: Pattern): Pattern[];
+    getNextPatterns(): Pattern[];
+    find(predicate: (p: Pattern) => boolean): Pattern | null;
+    isEqual(pattern: Optional): boolean;
+}

package/dist/patterns/Options.d.ts

@@ -0,0 +1,34 @@
+import { Node } from "../ast/Node";
+import { Cursor } from "./Cursor";
+import { Pattern } from "./Pattern";
+import { ParseResult } from "./ParseResult";
+export declare class Options implements Pattern {
+    private _id;
+    private _type;
+    private _name;
+    private _parent;
+    private _children;
+    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[];
+    constructor(name: string, options: Pattern[], 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): Pattern;
+    isEqual(pattern: Options): boolean;
+}

package/dist/patterns/Pattern.d.ts

@@ -7,11 +7,10 @@ export interface Pattern {
     name: string;
     parent: Pattern | null;
     children: Pattern[];
-    isOptional: boolean;
     parse(cursor: Cursor): Node | null;
     exec(text: string, record?: boolean): ParseResult;
     test(text: string, record?: boolean): boolean;
-    clone(name?: string, isOptional?: boolean): Pattern;
+    clone(name?: string): Pattern;
     getTokens(): string[];
     getTokensAfter(childReference: Pattern): string[];
     getNextTokens(): string[];

package/dist/patterns/Reference.d.ts

@@ -7,7 +7,6 @@ export declare class Reference implements Pattern {
     private _type;
     private _name;
     private _parent;
-    private _isOptional;
     private _pattern;
     private _children;
     get id(): string;
@@ -16,8 +15,7 @@ export declare class Reference implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
-    get isOptional(): boolean;
-    constructor(name: string, isOptional?: boolean);
+    constructor(name: string);
     test(text: string): boolean;
     exec(text: string, record?: boolean): ParseResult;
     parse(cursor: Cursor): Node | null;
@@ -31,6 +29,6 @@ export declare class Reference implements Pattern {
     getPatternsAfter(_childReference: Pattern): Pattern[];
     getNextPatterns(): Pattern[];
     find(_predicate: (p: Pattern) => boolean): Pattern | null;
-    clone(name?: string, isOptional?: boolean): Pattern;
+    clone(name?: string): Pattern;
     isEqual(pattern: Reference): boolean;
 }

package/dist/patterns/Regex.d.ts

@@ -6,7 +6,6 @@ export declare class Regex implements Pattern {
     private _id;
     private _type;
     private _name;
-    private _isOptional;
     private _parent;
     private _originalRegexString;
     private _regex;
@@ -18,11 +17,11 @@ export declare class Regex implements Pattern {
     get id(): string;
     get type(): string;
     get name(): string;
+    get value(): string;
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
-    get isOptional(): boolean;
-    constructor(name: string, regex: string, isOptional?: boolean);
+    constructor(name: string, regex: string);
     private assertArguments;
     test(text: string): boolean;
     exec(text: string, record?: boolean): ParseResult;
@@ -31,7 +30,7 @@ export declare class Regex implements Pattern {
     private tryToParse;
     private processResult;
     private processError;
-    clone(name?: string, isOptional?: boolean): Regex;
+    clone(name?: string): Regex;
     getTokens(): string[];
     getTokensAfter(_childReference: Pattern): string[];
     getNextTokens(): string[];

package/dist/patterns/Repeat.d.ts

@@ -21,12 +21,13 @@ export declare class Repeat implements Pattern {
     get parent(): Pattern | null;
     set parent(value: Pattern | null);
     get children(): Pattern[];
-    get isOptional(): boolean;
+    get min(): any;
+    get max(): any;
     constructor(name: string, pattern: Pattern, options?: RepeatOptions);
     parse(cursor: Cursor): Node | null;
     exec(text: string): ParseResult;
     test(text: string): boolean;
-    clone(name?: string, isOptional?: boolean): Repeat;
+    clone(name?: string): Repeat;
     getTokens(): string[];
     getTokensAfter(_childReference: Pattern): string[];
     getNextTokens(): string[];

package/dist/patterns/Sequence.d.ts

@@ -0,0 +1,39 @@
+import { Cursor } from "./Cursor";
+import { Pattern } from "./Pattern";
+import { Node } from "../ast/Node";
+export declare class Sequence implements Pattern {
+    private _id;
+    private _type;
+    private _name;
+    private _parent;
+    private _children;
+    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[];
+    constructor(name: string, sequence: Pattern[]);
+    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): Pattern;
+    isEqual(pattern: Sequence): boolean;
+}

package/dist/patterns/clonePatterns.d.ts

@@ -1,2 +1,2 @@
 import { Pattern } from "./Pattern";
-export declare function clonePatterns(patterns: Pattern[], isOptional?: boolean): Pattern[];
+export declare function clonePatterns(patterns: Pattern[]): Pattern[];

package/package.json

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

package/src/patterns/Literal.ts

@@ -28,6 +28,10 @@ export class Literal implements Pattern {
     return this._name;
   }
 
+  get value(): string {
+    return this._text;
+  }
+
   get parent(): Pattern | null {
     return this._parent;
   }

package/src/patterns/Regex.ts

@@ -30,6 +30,10 @@ export class Regex implements Pattern {
     return this._name;
   }
 
+  get value(): string{
+    return this._originalRegexString;
+  }
+
   get parent(): Pattern | null {
     return this._parent;
   }

package/src/patterns/Repeat.ts

@@ -52,6 +52,14 @@ export class Repeat implements Pattern {
         return this._children;
     }
 
+    get min() {
+        return (this.children[0] as any).min;
+    }
+
+    get max() {
+        return (this.children[0] as any).max || Infinity;
+    }
+
     constructor(name: string, pattern: Pattern, options: RepeatOptions = {}) {
         this._id = `repeat-${idIndex++}`;
         this._pattern = pattern;