clarity-pattern-parser 10.3.1 → 10.3.2

package/dist/index.js

@@ -532,6 +532,9 @@ class Literal {
     get children() {
         return [];
     }
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
     constructor(name, value) {
         this.shouldCompactAst = false;
         if (value.length === 0) {
@@ -661,10 +664,13 @@ class Regex {
     get children() {
         return [];
     }
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
     constructor(name, regex) {
         this._node = null;
         this._cursor = null;
-        this._firstIndex = -1;
+        this._firstIndex = 0;
         this._substring = "";
         this._tokens = [];
         this.shouldCompactAst = false;
@@ -817,6 +823,9 @@ class Reference {
     get children() {
         return this._children;
     }
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
     constructor(name) {
         this.shouldCompactAst = false;
         this._id = `reference-${idIndex$7++}`;
@@ -826,6 +835,7 @@ class Reference {
         this._pattern = null;
         this._cachedPattern = null;
         this._children = [];
+        this._firstIndex = 0;
     }
     test(text) {
         const cursor = new Cursor(text);
@@ -842,6 +852,7 @@ class Reference {
         };
     }
     parse(cursor) {
+        this._firstIndex = cursor.index;
         return this.getReferencePatternSafely().parse(cursor);
     }
     getReferencePatternSafely() {
@@ -955,29 +966,6 @@ function clonePatterns(patterns) {
     return patterns.map(p => p.clone());
 }
 
-class DepthCache {
-    constructor() {
-        this._depthMap = {};
-    }
-    getDepth(name, cursorIndex) {
-        if (this._depthMap[name] == null) {
-            this._depthMap[name] = {};
-        }
-        if (this._depthMap[name][cursorIndex] == null) {
-            this._depthMap[name][cursorIndex] = 0;
-        }
-        return this._depthMap[name][cursorIndex];
-    }
-    incrementDepth(name, cursorIndex) {
-        const depth = this.getDepth(name, cursorIndex);
-        this._depthMap[name][cursorIndex] = depth + 1;
-    }
-    decrementDepth(name, cursorIndex) {
-        const depth = this.getDepth(name, cursorIndex);
-        this._depthMap[name][cursorIndex] = depth - 1;
-    }
-}
-
 function isRecursivePattern(pattern) {
     let onPattern = pattern.parent;
     let depth = 0;
@@ -993,10 +981,6 @@ function isRecursivePattern(pattern) {
     return false;
 }
 
-/*
-  The following is created to reduce the overhead of recursion check.
-*/
-const depthCache$2 = new DepthCache();
 let idIndex$6 = 0;
 class Options {
     get id() {
@@ -1017,6 +1001,9 @@ class Options {
     get children() {
         return this._children;
     }
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
     constructor(name, options, isGreedy = false) {
         this.shouldCompactAst = false;
         if (options.length === 0) {
@@ -1052,12 +1039,8 @@ class Options {
         };
     }
     parse(cursor) {
-        // This is a cache to help with speed
-        this._firstIndex = cursor.index;
-        depthCache$2.incrementDepth(this._id, this._firstIndex);
         this._firstIndex = cursor.index;
         const node = this._tryToParse(cursor);
-        depthCache$2.decrementDepth(this._id, this._firstIndex);
         if (node != null) {
             cursor.moveTo(node.lastIndex);
             cursor.resolveError();
@@ -1070,7 +1053,7 @@ class Options {
         return null;
     }
     _tryToParse(cursor) {
-        if (depthCache$2.getDepth(this._id, this._firstIndex) > 2) {
+        if (this._isBeyondRecursiveAllowance()) {
             return null;
         }
         const results = [];
@@ -1090,6 +1073,20 @@ class Options {
         nonNullResults.sort((a, b) => b.endIndex - a.endIndex);
         return nonNullResults[0] || null;
     }
+    _isBeyondRecursiveAllowance() {
+        let depth = 0;
+        let pattern = this;
+        while (pattern != null) {
+            if (pattern.id === this.id && pattern.startedOnIndex === this.startedOnIndex) {
+                depth++;
+            }
+            if (depth > 2) {
+                return true;
+            }
+            pattern = pattern.parent;
+        }
+        return false;
+    }
     getTokens() {
         const tokens = [];
         for (const pattern of this._children) {
@@ -1174,6 +1171,9 @@ class FiniteRepeat {
     get max() {
         return this._max;
     }
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
     constructor(name, pattern, options = {}) {
         this.shouldCompactAst = false;
         this._id = `finite-repeat-${idIndex$5++}`;
@@ -1185,6 +1185,7 @@ class FiniteRepeat {
         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();
             child.parent = this;
@@ -1197,6 +1198,7 @@ class FiniteRepeat {
         }
     }
     parse(cursor) {
+        this._firstIndex = cursor.index;
         const startIndex = cursor.index;
         const nodes = [];
         const modulo = this._hasDivider ? 2 : 1;
@@ -1352,6 +1354,9 @@ class InfiniteRepeat {
     get min() {
         return this._min;
     }
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
     constructor(name, pattern, options = {}) {
         this.shouldCompactAst = false;
         const min = options.min != null ? Math.max(options.min, 1) : 1;
@@ -1627,6 +1632,9 @@ class Repeat {
     get max() {
         return this._options.max;
     }
+    get startedOnIndex() {
+        return this._repeatPattern.startedOnIndex;
+    }
     constructor(name, pattern, options = {}) {
         this._id = `repeat-${idIndex$3++}`;
         this._pattern = pattern;
@@ -1709,7 +1717,6 @@ function filterOutNull(nodes) {
     return filteredNodes;
 }
 
-const depthCache$1 = new DepthCache();
 let idIndex$2 = 0;
 class Sequence {
     get id() {
@@ -1730,6 +1737,9 @@ class Sequence {
     get children() {
         return this._children;
     }
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
     constructor(name, sequence) {
         this.shouldCompactAst = false;
         if (sequence.length === 0) {
@@ -1765,12 +1775,9 @@ class Sequence {
         };
     }
     parse(cursor) {
-        // This is a cache to help with speed
         this._firstIndex = cursor.index;
-        depthCache$1.incrementDepth(this._id, this._firstIndex);
         this._nodes = [];
         const passed = this.tryToParse(cursor);
-        depthCache$1.decrementDepth(this._id, this._firstIndex);
         if (passed) {
             const node = this.createNode(cursor);
             if (node !== null) {
@@ -1784,7 +1791,7 @@ class Sequence {
         return null;
     }
     tryToParse(cursor) {
-        if (depthCache$1.getDepth(this._id, this._firstIndex) > 1) {
+        if (this._isBeyondRecursiveAllowance()) {
             cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
             return false;
         }
@@ -1851,6 +1858,20 @@ class Sequence {
         }
         return nodes[nodes.length - 1];
     }
+    _isBeyondRecursiveAllowance() {
+        let depth = 0;
+        let pattern = this;
+        while (pattern != null) {
+            if (pattern.id === this.id && pattern.startedOnIndex === this.startedOnIndex) {
+                depth++;
+            }
+            if (depth > 1) {
+                return true;
+            }
+            pattern = pattern.parent;
+        }
+        return false;
+    }
     areRemainingPatternsOptional(fromIndex) {
         const startOnIndex = fromIndex + 1;
         const length = this._children.length;
@@ -2010,6 +2031,9 @@ class Optional {
     get children() {
         return this._children;
     }
+    get startedOnIndex() {
+        return this._children[0].startedOnIndex;
+    }
     constructor(name, pattern) {
         this.shouldCompactAst = false;
         this._id = `optional-${idIndex$1++}`;
@@ -2331,6 +2355,9 @@ class Not {
     get children() {
         return this._children;
     }
+    get startedOnIndex() {
+        return this.children[0].startedOnIndex;
+    }
     constructor(name, pattern) {
         this.shouldCompactAst = false;
         this._id = `not-${idIndex++}`;
@@ -2670,6 +2697,9 @@ class Context {
     get children() {
         return this._children;
     }
+    get startedOnIndex() {
+        return this.children[0].startedOnIndex;
+    }
     getPatternWithinContext(name) {
         return this._patterns[name] || null;
     }
@@ -2743,7 +2773,6 @@ class Context {
 }
 
 let indexId = 0;
-const depthCache = new DepthCache();
 function createNode(name, children) {
     return new Node("expression", name, 0, 0, children, "");
 }
@@ -2780,6 +2809,9 @@ class ExpressionPattern {
     get recursivePatterns() {
         return this._recursivePatterns;
     }
+    get startedOnIndex() {
+        return this._firstIndex;
+    }
     constructor(name, patterns) {
         this.shouldCompactAst = false;
         if (patterns.length === 0) {
@@ -2897,11 +2929,8 @@ class ExpressionPattern {
             lastChild.name === this.name;
     }
     parse(cursor) {
-        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();
@@ -2931,7 +2960,7 @@ class ExpressionPattern {
         }
     }
     _tryToParse(cursor) {
-        if (depthCache.getDepth(this._id, this._firstIndex) > 2) {
+        if (this._isBeyondRecursiveAllowance()) {
             cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
             return null;
         }
@@ -3096,6 +3125,20 @@ class ExpressionPattern {
             return root;
         }
     }
+    _isBeyondRecursiveAllowance() {
+        let depth = 0;
+        let pattern = 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) {
         const cursor = new Cursor(text);
         const ast = this.parse(cursor);