clarity-pattern-parser 10.0.6 → 10.0.8

package/dist/index.browser.js

@@ -784,6 +784,7 @@
             this._name = name;
             this._parent = null;
             this._pattern = null;
+            this._cachedPattern = null;
             this._children = [];
         }
         test(text) {
@@ -805,7 +806,13 @@
         }
         _getPatternSafely() {
             if (this._pattern === null) {
-                const pattern = this._findPattern();
+                let pattern = null;
+                if (this._cachedPattern == null) {
+                    pattern = this._findPattern();
+                }
+                else {
+                    pattern = this._cachedPattern;
+                }
                 if (pattern === null) {
                     throw new Error(`Couldn't find '${this._name}' pattern within tree.`);
                 }
@@ -871,6 +878,10 @@
         clone(name = this._name) {
             const clone = new Reference(name);
             clone._id = this._id;
+            // Optimize future clones, by caching the pattern we already found.
+            if (this._pattern != null) {
+                clone._cachedPattern = this._pattern;
+            }
             return clone;
         }
         isEqual(pattern) {
@@ -882,6 +893,33 @@
         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() {
@@ -936,8 +974,12 @@
             };
         }
         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();
@@ -947,8 +989,8 @@
             return null;
         }
         _tryToParse(cursor) {
-            if (this._isBeyondRecursiveLimit()) {
-                cursor.recordErrorAt(cursor.index, cursor.index, this);
+            if (depthCache$1.getDepth(this._id, this._firstIndex) > 2) {
+                cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
                 return null;
             }
             const results = [];
@@ -968,25 +1010,6 @@
             nonNullResults.sort((a, b) => b.endIndex - a.endIndex);
             return nonNullResults[0] || null;
         }
-        _isBeyondRecursiveLimit() {
-            let pattern = this;
-            const matches = [];
-            while (pattern.parent != null) {
-                if (pattern.type !== "options") {
-                    pattern = pattern.parent;
-                    continue;
-                }
-                const optionsPattern = pattern;
-                if (pattern.id === this.id && optionsPattern._firstIndex === this._firstIndex) {
-                    matches.push(pattern);
-                    if (matches.length > 2) {
-                        return true;
-                    }
-                }
-                pattern = pattern.parent;
-            }
-            return false;
-        }
         getTokens() {
             const tokens = [];
             for (const child of this._children) {
@@ -1579,6 +1602,7 @@
         return filteredNodes;
     }
 
+    const depthCache = new DepthCache();
     let idIndex$2 = 0;
     class Sequence {
         get id() {
@@ -1633,13 +1657,12 @@
             };
         }
         parse(cursor) {
+            // This is a cache to help with speed
             this._firstIndex = cursor.index;
+            depthCache.incrementDepth(this._id, this._firstIndex);
             this._nodes = [];
-            if (this._isBeyondRecursiveLimit()) {
-                cursor.recordErrorAt(cursor.index, cursor.index, this);
-                return null;
-            }
             const passed = this.tryToParse(cursor);
+            depthCache.decrementDepth(this._id, this._firstIndex);
             if (passed) {
                 const node = this.createNode(cursor);
                 if (node !== null) {
@@ -1650,6 +1673,10 @@
             return null;
         }
         tryToParse(cursor) {
+            if (depthCache.getDepth(this._id, this._firstIndex) > 1) {
+                cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
+                return false;
+            }
             let passed = false;
             for (let i = 0; i < this._children.length; i++) {
                 const runningCursorIndex = cursor.index;
@@ -1706,25 +1733,6 @@
             }
             return passed;
         }
-        _isBeyondRecursiveLimit() {
-            let pattern = this;
-            const matches = [];
-            while (pattern.parent != null) {
-                if (pattern.type !== "sequence") {
-                    pattern = pattern.parent;
-                    continue;
-                }
-                const sequencePattern = pattern;
-                if (pattern.id === this.id && sequencePattern._firstIndex === this._firstIndex) {
-                    matches.push(pattern);
-                    if (matches.length > 1) {
-                        return true;
-                    }
-                }
-                pattern = pattern.parent;
-            }
-            return false;
-        }
         getLastValidNode() {
             const nodes = filterOutNull(this._nodes);
             if (nodes.length === 0) {