clarity-pattern-parser 10.1.13 → 10.1.15

package/dist/index.browser.js

@@ -931,33 +931,9 @@
         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;
-        }
-    }
-
     /*
       The following is created to reduce the overhead of recursion check.
     */
-    const depthCache$1 = new DepthCache();
     let idIndex$6 = 0;
     class Options {
         get id() {
@@ -1014,10 +990,7 @@
         parse(cursor) {
             // This is a cache to help with speed
             this._firstIndex = cursor.index;
-            depthCache$1.incrementDepth(this._id, this._firstIndex);
-            this._firstIndex = cursor.index;
             const node = this._tryToParse(cursor);
-            depthCache$1.decrementDepth(this._id, this._firstIndex);
             if (node != null) {
                 cursor.moveTo(node.lastIndex);
                 cursor.resolveError();
@@ -1027,14 +1000,9 @@
             return null;
         }
         _tryToParse(cursor) {
-            const shouldReverseOrder = this._shouldReverseOrder();
-            let children = this._children;
-            if (shouldReverseOrder) {
-                children = this._children.slice().reverse();
-            }
-            if (depthCache$1.getDepth(this._id, this._firstIndex) > 2) {
-                cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
-                return null;
+            let children = this.children;
+            if (this._isBeyondRecursiveDepth()) {
+                children = children.slice().reverse();
             }
             const results = [];
             for (const pattern of children) {
@@ -1053,16 +1021,19 @@
             nonNullResults.sort((a, b) => b.endIndex - a.endIndex);
             return nonNullResults[0] || null;
         }
-        _shouldReverseOrder() {
-            let count = 0;
-            let pattern = this._parent;
+        _isBeyondRecursiveDepth() {
+            let depth = 0;
+            let pattern = this;
             while (pattern != null) {
                 if (pattern.id === this.id) {
-                    count++;
+                    depth++;
+                }
+                if (depth >= this.children.length) {
+                    return true;
                 }
                 pattern = pattern.parent;
             }
-            return count % 2 === 1;
+            return false;
         }
         getTokens() {
             const tokens = [];
@@ -1656,7 +1627,6 @@
         return filteredNodes;
     }
 
-    const depthCache = new DepthCache();
     let idIndex$2 = 0;
     class Sequence {
         get id() {
@@ -1713,10 +1683,8 @@
         parse(cursor) {
             // This is a cache to help with speed
             this._firstIndex = cursor.index;
-            depthCache.incrementDepth(this._id, this._firstIndex);
             this._nodes = [];
             const passed = this.tryToParse(cursor);
-            depthCache.decrementDepth(this._id, this._firstIndex);
             if (passed) {
                 const node = this.createNode(cursor);
                 if (node !== null) {
@@ -1727,7 +1695,7 @@
             return null;
         }
         tryToParse(cursor) {
-            if (depthCache.getDepth(this._id, this._firstIndex) > 1) {
+            if (this._isBeyondRecursiveDepth()) {
                 cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
                 return false;
             }
@@ -1787,6 +1755,20 @@
             }
             return passed;
         }
+        _isBeyondRecursiveDepth() {
+            let depth = 0;
+            let pattern = this;
+            while (pattern != null) {
+                if (pattern.id === this.id && this._firstIndex === pattern._firstIndex) {
+                    depth++;
+                }
+                if (depth > 1) {
+                    return true;
+                }
+                pattern = pattern.parent;
+            }
+            return false;
+        }
         getLastValidNode() {
             const nodes = filterOutNull(this._nodes);
             if (nodes.length === 0) {