clarity-pattern-parser 10.0.6 → 10.0.8

package/dist/index.js

@@ -782,6 +782,7 @@ class Reference {
         this._name = name;
         this._parent = null;
         this._pattern = null;
+        this._cachedPattern = null;
         this._children = [];
     }
     test(text) {
@@ -803,7 +804,13 @@ class Reference {
     }
     _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.`);
             }
@@ -869,6 +876,10 @@ class Reference {
     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) {
@@ -880,6 +891,33 @@ 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;
+    }
+}
+
+/*
+  The following is created to reduce the overhead of recursion check.
+*/
+const depthCache$1 = new DepthCache();
 let idIndex$6 = 0;
 class Options {
     get id() {
@@ -934,8 +972,12 @@ class Options {
         };
     }
     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();
@@ -945,8 +987,8 @@ class Options {
         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 = [];
@@ -966,25 +1008,6 @@ class Options {
         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) {
@@ -1577,6 +1600,7 @@ function filterOutNull(nodes) {
     return filteredNodes;
 }
 
+const depthCache = new DepthCache();
 let idIndex$2 = 0;
 class Sequence {
     get id() {
@@ -1631,13 +1655,12 @@ class Sequence {
         };
     }
     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) {
@@ -1648,6 +1671,10 @@ class Sequence {
         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;
@@ -1704,25 +1731,6 @@ class Sequence {
         }
         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) {