clarity-pattern-parser 10.3.1 → 10.3.3

package/dist/patterns/Context.d.ts

@@ -17,6 +17,7 @@ export declare class Context implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
+    get startedOnIndex(): number;
     getPatternWithinContext(name: string): Pattern | null;
     getPatternsWithinContext(): {
         [x: string]: Pattern;

package/dist/patterns/ExpressionPattern.d.ts

@@ -10,7 +10,9 @@ export declare class ExpressionPattern implements Pattern {
     private _firstIndex;
     private _originalPatterns;
     private _patterns;
-    private _unaryPatterns;
+    private _atomPatterns;
+    private _unaryPrefixPatterns;
+    private _unaryPrefixNames;
     private _binaryPatterns;
     private _recursivePatterns;
     private _recursiveNames;
@@ -29,12 +31,16 @@ export declare class ExpressionPattern implements Pattern {
     get unaryPatterns(): readonly Pattern[];
     get binaryPatterns(): readonly Pattern[];
     get recursivePatterns(): readonly Pattern[];
+    get startedOnIndex(): number;
     constructor(name: string, patterns: Pattern[]);
     private _organizePatterns;
     private _isBinary;
     private _isBinaryPattern;
     private _extractDelimiter;
     private _extractName;
+    private _isUnary;
+    private _isUnaryPattern;
+    private _extractUnaryPrefixPattern;
     private _isRecursive;
     private _isRecursivePattern;
     private _extractRecursiveTail;
@@ -42,6 +48,7 @@ export declare class ExpressionPattern implements Pattern {
     parse(cursor: Cursor): Node | null;
     private _compactResult;
     private _tryToParse;
+    private _isBeyondRecursiveAllowance;
     test(text: string): boolean;
     exec(text: string, record?: boolean): ParseResult;
     getTokens(): string[];

package/dist/patterns/FiniteRepeat.d.ts

@@ -18,6 +18,7 @@ export declare class FiniteRepeat implements Pattern {
     private _min;
     private _max;
     private _trimDivider;
+    private _firstIndex;
     shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
@@ -27,6 +28,7 @@ export declare class FiniteRepeat implements Pattern {
     get children(): Pattern[];
     get min(): number;
     get max(): number;
+    get startedOnIndex(): number;
     constructor(name: string, pattern: Pattern, options?: FiniteRepeatOptions);
     parse(cursor: Cursor): Node | null;
     test(text: string): boolean;

package/dist/patterns/InfiniteRepeat.d.ts

@@ -27,6 +27,7 @@ export declare class InfiniteRepeat implements Pattern {
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
     get min(): number;
+    get startedOnIndex(): number;
     constructor(name: string, pattern: Pattern, options?: InfiniteRepeatOptions);
     private _assignChildrenToParent;
     test(text: string): boolean;

package/dist/patterns/Literal.d.ts

@@ -20,6 +20,7 @@ export declare class Literal implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
+    get startedOnIndex(): number;
     constructor(name: string, value: string);
     test(text: string, record?: boolean): boolean;
     exec(text: string, record?: boolean): ParseResult;

package/dist/patterns/Not.d.ts

@@ -15,6 +15,7 @@ export declare class Not implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
+    get startedOnIndex(): number;
     constructor(name: string, pattern: Pattern);
     test(text: string): boolean;
     exec(text: string, record?: boolean): ParseResult;

package/dist/patterns/Optional.d.ts

@@ -15,6 +15,7 @@ export declare class Optional implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
+    get startedOnIndex(): number;
     constructor(name: string, pattern: Pattern);
     test(text: string): boolean;
     exec(text: string, record?: boolean): ParseResult;

package/dist/patterns/Options.d.ts

@@ -17,12 +17,14 @@ export declare class Options implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
+    get startedOnIndex(): number;
     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;
+    private _isBeyondRecursiveAllowance;
     getTokens(): string[];
     getTokensAfter(_childReference: Pattern): string[];
     getNextTokens(): string[];

package/dist/patterns/Pattern.d.ts

@@ -6,6 +6,7 @@ export interface Pattern {
     type: string;
     name: string;
     shouldCompactAst: boolean;
+    startedOnIndex: number;
     parent: Pattern | null;
     children: Pattern[];
     parse(cursor: Cursor): Node | null;

package/dist/patterns/Reference.d.ts

@@ -10,6 +10,7 @@ export declare class Reference implements Pattern {
     private _cachedPattern;
     private _pattern;
     private _children;
+    private _firstIndex;
     shouldCompactAst: boolean;
     get id(): string;
     get type(): string;
@@ -17,6 +18,7 @@ export declare class Reference implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
+    get startedOnIndex(): number;
     constructor(name: string);
     test(text: string): boolean;
     exec(text: string, record?: boolean): ParseResult;

package/dist/patterns/Regex.d.ts

@@ -22,6 +22,7 @@ export declare class Regex implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
+    get startedOnIndex(): number;
     constructor(name: string, regex: string);
     private assertArguments;
     test(text: string): boolean;

package/dist/patterns/Repeat.d.ts

@@ -26,6 +26,7 @@ export declare class Repeat implements Pattern {
     get children(): Pattern[];
     get min(): number;
     get max(): number;
+    get startedOnIndex(): number;
     constructor(name: string, pattern: Pattern, options?: RepeatOptions);
     parse(cursor: Cursor): Node | null;
     exec(text: string): ParseResult;

package/dist/patterns/Sequence.d.ts

@@ -16,6 +16,7 @@ export declare class Sequence implements Pattern {
     get parent(): Pattern | null;
     set parent(pattern: Pattern | null);
     get children(): Pattern[];
+    get startedOnIndex(): number;
     constructor(name: string, sequence: Pattern[]);
     private _assignChildrenToParent;
     test(text: string): boolean;
@@ -26,6 +27,7 @@ export declare class Sequence implements Pattern {
     parse(cursor: Cursor): Node | null;
     private tryToParse;
     private getLastValidNode;
+    private _isBeyondRecursiveAllowance;
     private areRemainingPatternsOptional;
     private createNode;
     getTokens(): string[];

package/package.json

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

package/src/patterns/Context.ts

@@ -40,6 +40,10 @@ export class Context implements Pattern {
         return this._children;
     }
 
+    get startedOnIndex(){
+        return this.children[0].startedOnIndex;
+    }
+
     getPatternWithinContext(name: string): Pattern | null {
         return this._patterns[name] || null;
     }

package/src/patterns/ExpressionPattern.ts

@@ -1,13 +1,11 @@
 import { Node } from "../ast/Node";
 import { Cursor } from "./Cursor";
-import { DepthCache } from "./DepthCache";
 import { ParseResult } from "./ParseResult";
 import { Pattern } from "./Pattern";
 import { findPattern } from "./findPattern";
 import { Sequence } from "./Sequence";
 
 let indexId = 0;
-const depthCache = new DepthCache();
 
 function createNode(name: string, children: Node[]) {
     return new Node("expression", name, 0, 0, children, "");
@@ -26,7 +24,9 @@ export class ExpressionPattern implements Pattern {
     private _firstIndex: number;
     private _originalPatterns: Pattern[];
     private _patterns: Pattern[];
-    private _unaryPatterns: Pattern[];
+    private _atomPatterns: Pattern[];
+    private _unaryPrefixPatterns: Pattern[];
+    private _unaryPrefixNames: string[];
     private _binaryPatterns: Pattern[];
     private _recursivePatterns: Pattern[];
     private _recursiveNames: string[];
@@ -63,7 +63,7 @@ export class ExpressionPattern implements Pattern {
     }
 
     get unaryPatterns(): readonly Pattern[] {
-        return this._unaryPatterns;
+        return this._atomPatterns;
     }
 
     get binaryPatterns(): readonly Pattern[] {
@@ -74,6 +74,10 @@ export class ExpressionPattern implements Pattern {
         return this._recursivePatterns;
     }
 
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
+
     constructor(name: string, patterns: Pattern[]) {
         if (patterns.length === 0) {
             throw new Error("Need at least one pattern with an 'expression' pattern.");
@@ -84,7 +88,9 @@ export class ExpressionPattern implements Pattern {
         this._name = name;
         this._parent = null;
         this._firstIndex = -1;
-        this._unaryPatterns = [];
+        this._atomPatterns = [];
+        this._unaryPrefixPatterns = [];
+        this._unaryPrefixNames = [];
         this._binaryPatterns = [];
         this._recursivePatterns = [];
         this._recursiveNames = [];
@@ -96,7 +102,7 @@ export class ExpressionPattern implements Pattern {
         this._shouldCompactPatternsMap = {};
         this._patterns = this._organizePatterns(patterns);
 
-        if (this._unaryPatterns.length === 0) {
+        if (this._atomPatterns.length === 0) {
             throw new Error("Need at least one operand pattern with an 'expression' pattern.");
         }
     }
@@ -106,7 +112,13 @@ export class ExpressionPattern implements Pattern {
         patterns.forEach((pattern) => {
             this._shouldCompactPatternsMap[pattern.name] = pattern.shouldCompactAst;
 
-            if (this._isBinary(pattern)) {
+            if (this._isUnary(pattern)) {
+                const unaryPrefix = this._extractUnaryPrefixPattern(pattern).clone();
+                this._unaryPrefixPatterns.push(pattern);
+                this._unaryPrefixNames.push(pattern.name);
+
+                finalPatterns.push(unaryPrefix);
+            } else if (this._isBinary(pattern)) {
                 const binaryName = this._extractName(pattern);
                 const clone = this._extractDelimiter(pattern).clone();
                 clone.parent = this;
@@ -136,7 +148,7 @@ export class ExpressionPattern implements Pattern {
                 const clone = pattern.clone();
                 clone.parent = this;
 
-                this._unaryPatterns.push(clone);
+                this._atomPatterns.push(clone);
                 finalPatterns.push(clone);
             }
         });
@@ -176,6 +188,31 @@ export class ExpressionPattern implements Pattern {
         return pattern.name;
     }
 
+    private _isUnary(pattern: Pattern) {
+        if (pattern.type === "right-associated" && this._isUnaryPattern(pattern.children[0])) {
+            return true;
+        }
+
+        return this._isUnaryPattern(pattern);
+    }
+
+    private _isUnaryPattern(pattern: Pattern) {
+        return pattern.type === "sequence" &&
+            pattern.children[0].type !== "reference" &&
+            pattern.children[0].name !== this.name &&
+            pattern.children[1].type === "reference" &&
+            pattern.children[1].name === this.name &&
+            pattern.children.length === 2;
+    }
+
+    private _extractUnaryPrefixPattern(pattern: Pattern) {
+        if (pattern.type === "right-associated") {
+            return pattern.children[0].children[0];
+        }
+
+        return pattern.children[0];
+    }
+
     private _isRecursive(pattern: Pattern) {
         if (pattern.type === "right-associated" && this._isRecursivePattern(pattern.children[0])) {
             return true;
@@ -188,7 +225,7 @@ export class ExpressionPattern implements Pattern {
         return pattern.type === "sequence" &&
             pattern.children[0].type === "reference" &&
             pattern.children[0].name === this.name &&
-            pattern.children.length > 1;
+            pattern.children.length > 2;
     }
 
     private _extractRecursiveTail(pattern: Pattern) {
@@ -211,14 +248,9 @@ export class ExpressionPattern implements Pattern {
     }
 
     parse(cursor: Cursor): Node | null {
-        this._firstIndex = cursor.index;
-        depthCache.incrementDepth(this._id, this._firstIndex);
-
         this._firstIndex = cursor.index;
         const node = this._tryToParse(cursor);
 
-        depthCache.decrementDepth(this._id, this._firstIndex);
-
         if (node != null) {
             cursor.moveTo(node.lastIndex);
             cursor.resolveError();
@@ -253,13 +285,12 @@ export class ExpressionPattern implements Pattern {
     }
 
     private _tryToParse(cursor: Cursor): Node | null {
-        if (depthCache.getDepth(this._id, this._firstIndex) > 2) {
+        if (this._isBeyondRecursiveAllowance()) {
             cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
             return null;
         }
 
-
-        let lastUnaryNode: Node | null = null;
+        let lastAtomNode: Node | null = null;
         let lastBinaryNode: Node | null = null;
         let onIndex = cursor.index;
 
@@ -267,31 +298,57 @@ export class ExpressionPattern implements Pattern {
             cursor.resolveError();
             onIndex = cursor.index;
 
-            for (let i = 0; i < this._unaryPatterns.length; i++) {
+            let prefix: Node | null = null;
+            let prefixName = "";
+            for (let i = 0; i < this._unaryPrefixPatterns.length; i++) {
                 cursor.moveTo(onIndex);
+                const pattern = this._unaryPrefixPatterns[i];
+                const node = pattern.parse(cursor);
+
+                if (node != null) {
+                    prefix = node;
+                    prefixName = this._unaryPrefixNames[i];
 
-                const pattern = this._unaryPatterns[i];
+                    if (cursor.hasNext()) {
+                        cursor.next();
+                    } else {
+                        break outer;
+                    }
+
+                    break;
+                } else {
+                    cursor.resolveError();
+                }
+            }
+
+            onIndex = cursor.index;
+            for (let i = 0; i < this._atomPatterns.length; i++) {
+                cursor.moveTo(onIndex);
+                const pattern = this._atomPatterns[i];
                 const node = pattern.parse(cursor);
 
                 if (node != null) {
-                    lastUnaryNode = node;
+                    lastAtomNode = node;
 
                     break;
                 } else {
-                    lastUnaryNode = null;
+                    lastAtomNode = null;
                     cursor.resolveError();
                 }
             }
 
-            if (lastUnaryNode == null) {
+            if (lastAtomNode == null) {
                 break;
             }
 
             if (cursor.hasNext()) {
                 cursor.next();
             } else {
-                if (lastBinaryNode != null && lastUnaryNode != null) {
-                    lastBinaryNode.appendChild(lastUnaryNode);
+                if (lastBinaryNode != null && lastAtomNode != null) {
+                    if (prefix != null) {
+                        lastAtomNode = createNode(prefixName, [prefix, lastAtomNode]);
+                    }
+                    lastBinaryNode.appendChild(lastAtomNode);
                 }
                 break;
             }
@@ -306,26 +363,33 @@ export class ExpressionPattern implements Pattern {
                     const name = this._recursiveNames[i];
 
                     if (this._endsInRecursion[i]) {
-                        if (lastBinaryNode != null && lastUnaryNode != null) {
-                            lastBinaryNode.appendChild(lastUnaryNode);
+                        if (lastBinaryNode != null && lastAtomNode != null) {
+                            if (prefix != null) {
+                                lastAtomNode = createNode(prefixName, [prefix, lastAtomNode]);
+                            }
+                            lastBinaryNode.appendChild(lastAtomNode);
                         }
 
-                        const frontExpression = lastBinaryNode == null ? lastUnaryNode as Node : lastBinaryNode.findRoot();
+                        const frontExpression = lastBinaryNode == null ? lastAtomNode as Node : lastBinaryNode.findRoot();
                         const recursiveNode = createNode(name, [frontExpression, ...node.children]);
 
                         recursiveNode.normalize(this._firstIndex);
 
                         return recursiveNode;
                     } else {
-                        const recursiveNode = createNode(name, [lastUnaryNode, ...node.children]);
-                        recursiveNode.normalize(lastUnaryNode.startIndex);
-                        lastUnaryNode = recursiveNode;
+                        if (prefix != null) {
+                            lastAtomNode = createNode(prefixName, [prefix, lastAtomNode]);
+                        }
+
+                        const recursiveNode = createNode(name, [lastAtomNode, ...node.children]);
+                        recursiveNode.normalize(lastAtomNode.startIndex);
+                        lastAtomNode = recursiveNode;
 
                         if (cursor.hasNext()) {
                             cursor.next();
                         } else {
-                            if (lastBinaryNode != null) {
-                                lastBinaryNode.appendChild(lastUnaryNode);
+                            if (lastBinaryNode != null && lastAtomNode != null) {
+                                lastBinaryNode.appendChild(lastAtomNode);
                             }
                             break outer;
                         }
@@ -351,24 +415,24 @@ export class ExpressionPattern implements Pattern {
                 if (delimiterNode == null) {
                     if (i === this._binaryPatterns.length - 1) {
                         if (lastBinaryNode == null) {
-                            return lastUnaryNode;
-                        } else if (lastUnaryNode != null) {
-                            lastBinaryNode.appendChild(lastUnaryNode);
+                            return lastAtomNode;
+                        } else if (lastAtomNode != null) {
+                            lastBinaryNode.appendChild(lastAtomNode);
                         }
                     }
                     continue;
                 }
 
-                if (lastBinaryNode == null && lastUnaryNode != null && delimiterNode != null) {
-                    const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                if (lastBinaryNode == null && lastAtomNode != null && delimiterNode != null) {
+                    const node = createNode(name, [lastAtomNode, delimiterNode]);
                     lastBinaryNode = node;
-                } else if (lastBinaryNode != null && lastUnaryNode != null && delimiterNode != null) {
+                } else if (lastBinaryNode != null && lastAtomNode != null && delimiterNode != null) {
                     const precedence = this._precedenceMap[name];
                     const lastPrecendece = lastBinaryNode == null ? 0 : this._precedenceMap[lastBinaryNode.name] == null ? -1 : this._precedenceMap[lastBinaryNode.name];
                     const association = this._binaryAssociation[i];
 
                     if (precedence === lastPrecendece && association === Association.right) {
-                        const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                        const node = createNode(name, [lastAtomNode, delimiterNode]);
                         lastBinaryNode.appendChild(node);
 
                         lastBinaryNode = node;
@@ -376,7 +440,7 @@ export class ExpressionPattern implements Pattern {
                         const node = createNode(name, []);
 
                         lastBinaryNode.replaceWith(node);
-                        lastBinaryNode.appendChild(lastUnaryNode);
+                        lastBinaryNode.appendChild(lastAtomNode);
 
                         node.append(lastBinaryNode, delimiterNode);
                         lastBinaryNode = node;
@@ -394,7 +458,7 @@ export class ExpressionPattern implements Pattern {
                             ancestor = ancestor.parent;
                         }
 
-                        lastBinaryNode.appendChild(lastUnaryNode);
+                        lastBinaryNode.appendChild(lastAtomNode);
 
                         if (root != null) {
                             const node = createNode(name, []);
@@ -403,12 +467,12 @@ export class ExpressionPattern implements Pattern {
 
                             lastBinaryNode = node;
                         } else {
-                            const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                            const node = createNode(name, [lastAtomNode, delimiterNode]);
                             lastBinaryNode = node;
                         }
 
                     } else {
-                        const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                        const node = createNode(name, [lastAtomNode, delimiterNode]);
                         lastBinaryNode.appendChild(node);
 
                         lastBinaryNode = node;
@@ -431,14 +495,14 @@ export class ExpressionPattern implements Pattern {
         }
 
         if (lastBinaryNode == null) {
-            return lastUnaryNode;
+            return lastAtomNode;
         } else {
             const root = lastBinaryNode.findAncestor(n => n.parent == null) as Node || lastBinaryNode;
             if (lastBinaryNode.children.length < 3) {
                 lastBinaryNode.remove();
 
                 if (lastBinaryNode === root) {
-                    return lastUnaryNode;
+                    return lastAtomNode;
                 }
             }
 
@@ -447,6 +511,24 @@ export class ExpressionPattern implements Pattern {
         }
     }
 
+    private _isBeyondRecursiveAllowance() {
+        let depth = 0;
+        let pattern: Pattern | null = this;
+
+        while (pattern != null) {
+            if (pattern.id === this.id && pattern.startedOnIndex === this.startedOnIndex) {
+                depth++;
+            }
+
+            if (depth > 2) {
+                return true;
+            }
+            pattern = pattern.parent;
+        }
+
+        return false;
+    }
+
     test(text: string) {
         const cursor = new Cursor(text);
         const ast = this.parse(cursor);
@@ -483,7 +565,7 @@ export class ExpressionPattern implements Pattern {
         }
 
         if (this.binaryPatterns.indexOf(childReference)) {
-            const unaryTokens = this._unaryPatterns.map(p => p.getTokens()).flat();
+            const unaryTokens = this._atomPatterns.map(p => p.getTokens()).flat();
 
             if (this._parent != null) {
                 const nextTokens = this._parent.getTokensAfter(this);
@@ -521,7 +603,7 @@ export class ExpressionPattern implements Pattern {
         }
 
         if (this.binaryPatterns.indexOf(childReference)) {
-            const unaryPatterns = this._unaryPatterns.map(p => p.getPatterns()).flat();
+            const unaryPatterns = this._atomPatterns.map(p => p.getPatterns()).flat();
 
             if (this._parent != null) {
                 const nextPatterns = this._parent.getPatternsAfter(this);

package/src/patterns/FiniteRepeat.ts

@@ -23,6 +23,7 @@ export class FiniteRepeat implements Pattern {
     private _min: number;
     private _max: number;
     private _trimDivider: boolean;
+    private _firstIndex: number;
 
     shouldCompactAst = false;
 
@@ -58,6 +59,10 @@ export class FiniteRepeat implements Pattern {
         return this._max;
     }
 
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
+
     constructor(name: string, pattern: Pattern, options: FiniteRepeatOptions = {}) {
         this._id = `finite-repeat-${idIndex++}`;
         this._type = "finite-repeat";
@@ -68,6 +73,7 @@ export class FiniteRepeat implements Pattern {
         this._min = options.min != null ? Math.max(options.min, 1) : 1;
         this._max = Math.max(this.min, options.max || this.min);
         this._trimDivider = options.trimDivider == null ? false : options.trimDivider;
+        this._firstIndex = 0;
 
         for (let i = 0; i < this._max; i++) {
             const child = pattern.clone();
@@ -85,6 +91,8 @@ export class FiniteRepeat implements Pattern {
     }
 
     parse(cursor: Cursor): Node | null {
+        this._firstIndex = cursor.index;
+
         const startIndex = cursor.index;
         const nodes: Node[] = [];
         const modulo = this._hasDivider ? 2 : 1;

package/src/patterns/InfiniteRepeat.ts

@@ -56,6 +56,10 @@ export class InfiniteRepeat implements Pattern {
     return this._min;
   }
 
+  get startedOnIndex(){
+    return this._firstIndex;
+  }
+
   constructor(name: string, pattern: Pattern, options: InfiniteRepeatOptions = {}) {
     const min = options.min != null ? Math.max(options.min, 1) : 1;
     const divider = options.divider;

package/src/patterns/Literal.ts

@@ -46,6 +46,10 @@ export class Literal implements Pattern {
     return [];
   }
 
+  get startedOnIndex() {
+    return this._firstIndex;
+  }
+
   constructor(name: string, value: string) {
     if (value.length === 0) {
       throw new Error("Value Cannot be empty.");

package/src/patterns/Not.ts

@@ -38,6 +38,10 @@ export class Not implements Pattern {
     return this._children;
   }
 
+  get startedOnIndex() {
+    return this.children[0].startedOnIndex;
+  }
+
   constructor(name: string, pattern: Pattern) {
     this._id = `not-${idIndex++}`;
     this._type = "not";

package/src/patterns/Optional.ts

@@ -38,6 +38,10 @@ export class Optional implements Pattern {
     return this._children;
   }
 
+  get startedOnIndex() {
+    return this._children[0].startedOnIndex;
+  }
+
   constructor(name: string, pattern: Pattern) {
     this._id = `optional-${idIndex++}`;
     this._type = "optional";