clarity-pattern-parser 10.1.16 → 10.1.20

package/dist/index.browser.js

@@ -931,9 +931,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() {
@@ -967,34 +991,6 @@
             this._children = children;
             this._firstIndex = 0;
             this._isGreedy = isGreedy;
-            this._recursiveDepth = this._calculateRecursiveDepth();
-        }
-        _calculateRecursiveDepth() {
-            let depth = 0;
-            this._children.forEach((child) => {
-                let hasReference = false;
-                let descendant = child.children[0];
-                while (descendant != null) {
-                    if (descendant.type === "reference" && descendant.name === this.name) {
-                        hasReference = true;
-                        break;
-                    }
-                    if (descendant.type === "context") {
-                        const pattern = descendant.getPatternWithinContext(this.name);
-                        if (pattern != null) {
-                            break;
-                        }
-                    }
-                    descendant = descendant.children[0];
-                }
-                if (hasReference) {
-                    depth++;
-                }
-            });
-            if (depth === 0) {
-                depth = this.children.length;
-            }
-            return depth;
         }
         _assignChildrenToParent(children) {
             for (const child of children) {
@@ -1018,7 +1014,10 @@
         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();
@@ -1028,12 +1027,12 @@
             return null;
         }
         _tryToParse(cursor) {
-            let children = this.children;
-            if (this._isBeyondRecursiveDepth()) {
-                children = children.slice().reverse();
+            if (depthCache$1.getDepth(this._id, this._firstIndex) > 2) {
+                cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
+                return null;
             }
             const results = [];
-            for (const pattern of children) {
+            for (const pattern of this._children) {
                 cursor.moveTo(this._firstIndex);
                 let result = null;
                 result = pattern.parse(cursor);
@@ -1049,20 +1048,6 @@
             nonNullResults.sort((a, b) => b.endIndex - a.endIndex);
             return nonNullResults[0] || null;
         }
-        _isBeyondRecursiveDepth() {
-            let depth = 0;
-            let pattern = this;
-            while (pattern != null) {
-                if (pattern.id === this.id) {
-                    depth++;
-                }
-                if (depth > this._recursiveDepth) {
-                    return true;
-                }
-                pattern = pattern.parent;
-            }
-            return false;
-        }
         getTokens() {
             const tokens = [];
             for (const child of this._children) {
@@ -1655,6 +1640,7 @@
         return filteredNodes;
     }
 
+    const depthCache = new DepthCache();
     let idIndex$2 = 0;
     class Sequence {
         get id() {
@@ -1711,8 +1697,10 @@
         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) {
@@ -1723,7 +1711,7 @@
             return null;
         }
         tryToParse(cursor) {
-            if (this._isBeyondRecursiveDepth()) {
+            if (depthCache.getDepth(this._id, this._firstIndex) > 1) {
                 cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
                 return false;
             }
@@ -1783,20 +1771,6 @@
             }
             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) {
@@ -2395,9 +2369,8 @@
                 errorAtIndex = startIndex;
             }
             else if (!isComplete && this._cursor.hasError && this._cursor.furthestError != null) {
-                errorAtIndex = this._cursor.furthestError.endIndex;
-                error = this._cursor.furthestError;
-                errorAtIndex = options.reduce((errorAtIndex, option) => Math.max(errorAtIndex, option.startIndex), errorAtIndex);
+                errorAtIndex = this.getFurthestPosition(cursor);
+                error = new ParseError(errorAtIndex, errorAtIndex, this._pattern);
             }
             return {
                 isComplete: isComplete,
@@ -2408,21 +2381,39 @@
                 ast,
             };
         }
+        getFurthestPosition(cursor) {
+            const furthestError = cursor.furthestError;
+            const furthestMatch = cursor.allMatchedNodes[cursor.allMatchedNodes.length - 1];
+            if (furthestError && furthestMatch) {
+                if (furthestError.endIndex > furthestMatch.endIndex) {
+                    return furthestMatch.endIndex;
+                }
+                else {
+                    return furthestError.endIndex;
+                }
+            }
+            if (furthestError == null && furthestMatch != null) {
+                return furthestMatch.endIndex;
+            }
+            if (furthestMatch == null && furthestError != null) {
+                return furthestError.endIndex;
+            }
+            return 0;
+        }
         suggestFor(text) {
             return this.suggestForWithCursor(new Cursor(text));
         }
         _getAllOptions() {
             const errorMatches = this._getOptionsFromErrors();
-            const validLeafMatches = this._cursor.leafMatches.filter(v => { var _a; return ((_a = v.node) === null || _a === void 0 ? void 0 : _a.lastIndex) === this._cursor.getLastIndex(); });
-            const leafMatchSuggestions = validLeafMatches.map((m) => this._createSuggestionsFromMatch(m)).flat();
-            const uniqueResults = [];
-            [...leafMatchSuggestions, ...errorMatches].forEach(m => {
-                const index = uniqueResults.findIndex(f => m.text === f.text);
+            const leafMatches = this._cursor.leafMatches.map((m) => this._createSuggestionsFromMatch(m)).flat();
+            const finalResults = [];
+            [...leafMatches, ...errorMatches].forEach(m => {
+                const index = finalResults.findIndex(f => m.text === f.text);
                 if (index === -1) {
-                    uniqueResults.push(m);
+                    finalResults.push(m);
                 }
             });
-            return uniqueResults;
+            return finalResults;
         }
         _getOptionsFromErrors() {
             // These errored because the length of the string.
@@ -2431,8 +2422,8 @@
                 const tokens = this._getTokensForPattern(e.pattern);
                 const adjustedTokens = tokens.map(t => t.slice(e.endIndex - e.startIndex));
                 return this._createSuggestions(e.endIndex, adjustedTokens);
-            }).flat();
-            return suggestions;
+            });
+            return suggestions.flat();
         }
         _createSuggestionsFromRoot() {
             const suggestions = [];