clarity-pattern-parser 10.0.5 → 10.0.7

package/dist/index.esm.js

@@ -279,7 +279,6 @@ class CursorHistory {
         this._patterns = [];
         this._nodes = [];
         this._errors = [];
-        this._trace = [];
     }
     get isRecording() {
         return this._isRecording;
@@ -308,9 +307,6 @@ class CursorHistory {
     get patterns() {
         return this._patterns;
     }
-    get trace() {
-        return this._trace;
-    }
     recordMatch(pattern, node) {
         if (this._isRecording) {
             this._patterns.push(pattern);
@@ -365,21 +361,8 @@ class CursorHistory {
     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;
@@ -434,7 +417,6 @@ class Cursor {
         this._index = 0;
         this._length = [...text].length;
         this._history = new CursorHistory();
-        this._stackTrace = [];
     }
     hasNext() {
         return this._index + 1 < this._length;
@@ -484,35 +466,6 @@ class Cursor {
     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;
@@ -568,18 +521,15 @@ class Literal {
         };
     }
     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) {
@@ -708,11 +658,9 @@ class Regex {
         };
     }
     parse(cursor) {
-        cursor.startParseWith(this);
         this._firstIndex = cursor.index;
         this.resetState(cursor);
         this.tryToParse(cursor);
-        cursor.endParse();
         return this._node;
     }
     resetState(cursor) {
@@ -928,6 +876,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() {
@@ -982,30 +957,30 @@ class Options {
         };
     }
     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);
             }
@@ -1117,7 +1092,6 @@ class FiniteRepeat {
         }
     }
     parse(cursor) {
-        cursor.startParseWith(this);
         const startIndex = cursor.index;
         const nodes = [];
         const modulo = this._hasDivider ? 2 : 1;
@@ -1156,19 +1130,16 @@ class FiniteRepeat {
             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) {
@@ -1314,7 +1285,6 @@ class InfiniteRepeat {
         };
     }
     parse(cursor) {
-        cursor.startParseWith(this);
         this._firstIndex = cursor.index;
         this._nodes = [];
         const passed = this._tryToParse(cursor);
@@ -1325,15 +1295,12 @@ class InfiniteRepeat {
                 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() {
@@ -1618,6 +1585,7 @@ function filterOutNull(nodes) {
     return filteredNodes;
 }
 
+const depthCache = new DepthCache();
 let idIndex$2 = 0;
 class Sequence {
     get id() {
@@ -1672,22 +1640,26 @@ class Sequence {
         };
     }
     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;
@@ -1926,17 +1898,14 @@ class Optional {
         };
     }
     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;
         }
     }
@@ -2241,7 +2210,6 @@ class Not {
         };
     }
     parse(cursor) {
-        cursor.startParseWith(this);
         const firstIndex = cursor.index;
         this._children[0].parse(cursor);
         if (cursor.hasError) {
@@ -2253,7 +2221,6 @@ class Not {
             cursor.resolveError();
             cursor.recordErrorAt(firstIndex, firstIndex, this);
         }
-        cursor.endParse();
         return null;
     }
     clone(name = this._name) {