clarity-pattern-parser 10.0.5 → 10.0.7

package/dist/index.browser.js

@@ -285,7 +285,6 @@
             this._patterns = [];
             this._nodes = [];
             this._errors = [];
-            this._trace = [];
         }
         get isRecording() {
             return this._isRecording;
@@ -314,9 +313,6 @@
         get patterns() {
             return this._patterns;
         }
-        get trace() {
-            return this._trace;
-        }
         recordMatch(pattern, node) {
             if (this._isRecording) {
                 this._patterns.push(pattern);
@@ -371,21 +367,8 @@
         resolveError() {
             this._currentError = null;
         }
-        pushStackTrace(trace) {
-            if (this._isRecording) {
-                this._trace.push(trace);
-            }
-        }
     }
 
-    class CyclicalParseError extends Error {
-        constructor(patternId, patternName, cursorIndex) {
-            super("Cyclical Parse Error");
-            this.patternId = patternId;
-            this.patternName = patternName;
-            this.cursorIndex = cursorIndex;
-        }
-    }
     class Cursor {
         get text() {
             return this._text;
@@ -440,7 +423,6 @@
             this._index = 0;
             this._length = [...text].length;
             this._history = new CursorHistory();
-            this._stackTrace = [];
         }
         hasNext() {
             return this._index + 1 < this._length;
@@ -490,35 +472,6 @@
         stopRecording() {
             this._history.stopRecording();
         }
-        startParseWith(pattern) {
-            const trace = {
-                pattern,
-                cursorIndex: this.index
-            };
-            const hasCycle = this._stackTrace.filter(t => t.pattern.id === pattern.id && this.index === t.cursorIndex).length > 1;
-            if (hasCycle) {
-                throw new CyclicalParseError(pattern.id, pattern.name, this.index);
-            }
-            this._history.pushStackTrace(trace);
-            this._stackTrace.push(trace);
-        }
-        endParse() {
-            this._stackTrace.pop();
-        }
-        audit() {
-            return this._history.trace.map(t => {
-                const onChar = this.getChars(t.cursorIndex, t.cursorIndex);
-                const restChars = this.getChars(t.cursorIndex + 1, t.cursorIndex + 5);
-                const context = `{${t.cursorIndex}}[${onChar}]${restChars}`;
-                return `${this._buildPatternContext(t.pattern)}-->${context}`;
-            });
-        }
-        _buildPatternContext(pattern) {
-            if (pattern.parent != null) {
-                return `${pattern.parent.name}.${pattern.name}`;
-            }
-            return pattern.name;
-        }
     }
 
     let idIndex$9 = 0;
@@ -574,18 +527,15 @@
             };
         }
         parse(cursor) {
-            cursor.startParseWith(this);
             this._firstIndex = cursor.index;
             const passed = this._tryToParse(cursor);
             if (passed) {
                 cursor.resolveError();
                 const node = this._createNode();
                 cursor.recordMatch(this, node);
-                cursor.endParse();
                 return node;
             }
             cursor.recordErrorAt(this._firstIndex, this._endIndex, this);
-            cursor.endParse();
             return null;
         }
         _tryToParse(cursor) {
@@ -714,11 +664,9 @@
             };
         }
         parse(cursor) {
-            cursor.startParseWith(this);
             this._firstIndex = cursor.index;
             this.resetState(cursor);
             this.tryToParse(cursor);
-            cursor.endParse();
             return this._node;
         }
         resetState(cursor) {
@@ -934,6 +882,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() {
@@ -988,30 +963,30 @@
             };
         }
         parse(cursor) {
-            cursor.startParseWith(this);
+            // 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();
-                cursor.endParse();
                 return node;
             }
             cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
-            cursor.endParse();
             return null;
         }
         _tryToParse(cursor) {
+            if (depthCache$1.getDepth(this._id, this._firstIndex) > 2) {
+                cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
+                return null;
+            }
             const results = [];
             for (const pattern of this._children) {
                 cursor.moveTo(this._firstIndex);
                 let result = null;
-                try {
-                    result = pattern.parse(cursor);
-                }
-                catch (_a) {
-                    continue;
-                }
+                result = pattern.parse(cursor);
                 if (this._isGreedy) {
                     results.push(result);
                 }
@@ -1123,7 +1098,6 @@
             }
         }
         parse(cursor) {
-            cursor.startParseWith(this);
             const startIndex = cursor.index;
             const nodes = [];
             const modulo = this._hasDivider ? 2 : 1;
@@ -1162,19 +1136,16 @@
                 const lastIndex = cursor.index;
                 cursor.moveTo(startIndex);
                 cursor.recordErrorAt(startIndex, lastIndex, this);
-                cursor.endParse();
                 return null;
             }
             if (nodes.length === 0 && !cursor.hasError) {
                 cursor.moveTo(startIndex);
-                cursor.endParse();
                 return null;
             }
             const firstIndex = nodes[0].firstIndex;
             const lastIndex = nodes[nodes.length - 1].lastIndex;
             cursor.resolveError();
             cursor.moveTo(lastIndex);
-            cursor.endParse();
             return new Node(this._type, this.name, firstIndex, lastIndex, nodes);
         }
         test(text) {
@@ -1320,7 +1291,6 @@
             };
         }
         parse(cursor) {
-            cursor.startParseWith(this);
             this._firstIndex = cursor.index;
             this._nodes = [];
             const passed = this._tryToParse(cursor);
@@ -1331,15 +1301,12 @@
                     cursor.moveTo(node.lastIndex);
                     cursor.recordMatch(this, node);
                 }
-                cursor.endParse();
                 return node;
             }
             if (this._min > 0) {
-                cursor.endParse();
                 return null;
             }
             cursor.resolveError();
-            cursor.endParse();
             return null;
         }
         _meetsMin() {
@@ -1624,6 +1591,7 @@
         return filteredNodes;
     }
 
+    const depthCache = new DepthCache();
     let idIndex$2 = 0;
     class Sequence {
         get id() {
@@ -1678,22 +1646,26 @@
             };
         }
         parse(cursor) {
-            cursor.startParseWith(this);
+            // 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) {
                     cursor.recordMatch(this, node);
                 }
-                cursor.endParse();
                 return node;
             }
-            cursor.endParse();
             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;
@@ -1932,17 +1904,14 @@
             };
         }
         parse(cursor) {
-            cursor.startParseWith(this);
             const firstIndex = cursor.index;
             const node = this._children[0].parse(cursor);
             if (cursor.hasError) {
                 cursor.resolveError();
                 cursor.moveTo(firstIndex);
-                cursor.endParse();
                 return null;
             }
             else {
-                cursor.endParse();
                 return node;
             }
         }
@@ -2247,7 +2216,6 @@
             };
         }
         parse(cursor) {
-            cursor.startParseWith(this);
             const firstIndex = cursor.index;
             this._children[0].parse(cursor);
             if (cursor.hasError) {
@@ -2259,7 +2227,6 @@
                 cursor.resolveError();
                 cursor.recordErrorAt(firstIndex, firstIndex, this);
             }
-            cursor.endParse();
             return null;
         }
         clone(name = this._name) {