clarity-pattern-parser 10.3.1 → 10.3.3

package/dist/index.browser.js

@@ -534,6 +534,9 @@
         get children() {
             return [];
         }
+        get startedOnIndex() {
+            return this._firstIndex;
+        }
         constructor(name, value) {
             this.shouldCompactAst = false;
             if (value.length === 0) {
@@ -663,10 +666,13 @@
         get children() {
             return [];
         }
+        get startedOnIndex() {
+            return this._firstIndex;
+        }
         constructor(name, regex) {
             this._node = null;
             this._cursor = null;
-            this._firstIndex = -1;
+            this._firstIndex = 0;
             this._substring = "";
             this._tokens = [];
             this.shouldCompactAst = false;
@@ -819,6 +825,9 @@
         get children() {
             return this._children;
         }
+        get startedOnIndex() {
+            return this._firstIndex;
+        }
         constructor(name) {
             this.shouldCompactAst = false;
             this._id = `reference-${idIndex$7++}`;
@@ -828,6 +837,7 @@
             this._pattern = null;
             this._cachedPattern = null;
             this._children = [];
+            this._firstIndex = 0;
         }
         test(text) {
             const cursor = new Cursor(text);
@@ -844,6 +854,7 @@
             };
         }
         parse(cursor) {
+            this._firstIndex = cursor.index;
             return this.getReferencePatternSafely().parse(cursor);
         }
         getReferencePatternSafely() {
@@ -957,29 +968,6 @@
         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;
-        }
-    }
-
     function isRecursivePattern(pattern) {
         let onPattern = pattern.parent;
         let depth = 0;
@@ -995,10 +983,6 @@
         return false;
     }
 
-    /*
-      The following is created to reduce the overhead of recursion check.
-    */
-    const depthCache$2 = new DepthCache();
     let idIndex$6 = 0;
     class Options {
         get id() {
@@ -1019,6 +1003,9 @@
         get children() {
             return this._children;
         }
+        get startedOnIndex() {
+            return this._firstIndex;
+        }
         constructor(name, options, isGreedy = false) {
             this.shouldCompactAst = false;
             if (options.length === 0) {
@@ -1054,12 +1041,8 @@
             };
         }
         parse(cursor) {
-            // This is a cache to help with speed
-            this._firstIndex = cursor.index;
-            depthCache$2.incrementDepth(this._id, this._firstIndex);
             this._firstIndex = cursor.index;
             const node = this._tryToParse(cursor);
-            depthCache$2.decrementDepth(this._id, this._firstIndex);
             if (node != null) {
                 cursor.moveTo(node.lastIndex);
                 cursor.resolveError();
@@ -1072,7 +1055,7 @@
             return null;
         }
         _tryToParse(cursor) {
-            if (depthCache$2.getDepth(this._id, this._firstIndex) > 2) {
+            if (this._isBeyondRecursiveAllowance()) {
                 return null;
             }
             const results = [];
@@ -1092,6 +1075,20 @@
             nonNullResults.sort((a, b) => b.endIndex - a.endIndex);
             return nonNullResults[0] || null;
         }
+        _isBeyondRecursiveAllowance() {
+            let depth = 0;
+            let pattern = this;
+            while (pattern != null) {
+                if (pattern.id === this.id && pattern.startedOnIndex === this.startedOnIndex) {
+                    depth++;
+                }
+                if (depth > 2) {
+                    return true;
+                }
+                pattern = pattern.parent;
+            }
+            return false;
+        }
         getTokens() {
             const tokens = [];
             for (const pattern of this._children) {
@@ -1176,6 +1173,9 @@
         get max() {
             return this._max;
         }
+        get startedOnIndex() {
+            return this._firstIndex;
+        }
         constructor(name, pattern, options = {}) {
             this.shouldCompactAst = false;
             this._id = `finite-repeat-${idIndex$5++}`;
@@ -1187,6 +1187,7 @@
             this._min = options.min != null ? Math.max(options.min, 1) : 1;
             this._max = Math.max(this.min, options.max || this.min);
             this._trimDivider = options.trimDivider == null ? false : options.trimDivider;
+            this._firstIndex = 0;
             for (let i = 0; i < this._max; i++) {
                 const child = pattern.clone();
                 child.parent = this;
@@ -1199,6 +1200,7 @@
             }
         }
         parse(cursor) {
+            this._firstIndex = cursor.index;
             const startIndex = cursor.index;
             const nodes = [];
             const modulo = this._hasDivider ? 2 : 1;
@@ -1354,6 +1356,9 @@
         get min() {
             return this._min;
         }
+        get startedOnIndex() {
+            return this._firstIndex;
+        }
         constructor(name, pattern, options = {}) {
             this.shouldCompactAst = false;
             const min = options.min != null ? Math.max(options.min, 1) : 1;
@@ -1629,6 +1634,9 @@
         get max() {
             return this._options.max;
         }
+        get startedOnIndex() {
+            return this._repeatPattern.startedOnIndex;
+        }
         constructor(name, pattern, options = {}) {
             this._id = `repeat-${idIndex$3++}`;
             this._pattern = pattern;
@@ -1711,7 +1719,6 @@
         return filteredNodes;
     }
 
-    const depthCache$1 = new DepthCache();
     let idIndex$2 = 0;
     class Sequence {
         get id() {
@@ -1732,6 +1739,9 @@
         get children() {
             return this._children;
         }
+        get startedOnIndex() {
+            return this._firstIndex;
+        }
         constructor(name, sequence) {
             this.shouldCompactAst = false;
             if (sequence.length === 0) {
@@ -1767,12 +1777,9 @@
             };
         }
         parse(cursor) {
-            // This is a cache to help with speed
             this._firstIndex = cursor.index;
-            depthCache$1.incrementDepth(this._id, this._firstIndex);
             this._nodes = [];
             const passed = this.tryToParse(cursor);
-            depthCache$1.decrementDepth(this._id, this._firstIndex);
             if (passed) {
                 const node = this.createNode(cursor);
                 if (node !== null) {
@@ -1786,7 +1793,7 @@
             return null;
         }
         tryToParse(cursor) {
-            if (depthCache$1.getDepth(this._id, this._firstIndex) > 1) {
+            if (this._isBeyondRecursiveAllowance()) {
                 cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
                 return false;
             }
@@ -1853,6 +1860,20 @@
             }
             return nodes[nodes.length - 1];
         }
+        _isBeyondRecursiveAllowance() {
+            let depth = 0;
+            let pattern = this;
+            while (pattern != null) {
+                if (pattern.id === this.id && pattern.startedOnIndex === this.startedOnIndex) {
+                    depth++;
+                }
+                if (depth > 1) {
+                    return true;
+                }
+                pattern = pattern.parent;
+            }
+            return false;
+        }
         areRemainingPatternsOptional(fromIndex) {
             const startOnIndex = fromIndex + 1;
             const length = this._children.length;
@@ -2012,6 +2033,9 @@
         get children() {
             return this._children;
         }
+        get startedOnIndex() {
+            return this._children[0].startedOnIndex;
+        }
         constructor(name, pattern) {
             this.shouldCompactAst = false;
             this._id = `optional-${idIndex$1++}`;
@@ -2333,6 +2357,9 @@
         get children() {
             return this._children;
         }
+        get startedOnIndex() {
+            return this.children[0].startedOnIndex;
+        }
         constructor(name, pattern) {
             this.shouldCompactAst = false;
             this._id = `not-${idIndex++}`;
@@ -2672,6 +2699,9 @@
         get children() {
             return this._children;
         }
+        get startedOnIndex() {
+            return this.children[0].startedOnIndex;
+        }
         getPatternWithinContext(name) {
             return this._patterns[name] || null;
         }
@@ -2745,7 +2775,6 @@
     }
 
     let indexId = 0;
-    const depthCache = new DepthCache();
     function createNode(name, children) {
         return new Node("expression", name, 0, 0, children, "");
     }
@@ -2774,7 +2803,7 @@
             return this._patterns;
         }
         get unaryPatterns() {
-            return this._unaryPatterns;
+            return this._atomPatterns;
         }
         get binaryPatterns() {
             return this._binaryPatterns;
@@ -2782,6 +2811,9 @@
         get recursivePatterns() {
             return this._recursivePatterns;
         }
+        get startedOnIndex() {
+            return this._firstIndex;
+        }
         constructor(name, patterns) {
             this.shouldCompactAst = false;
             if (patterns.length === 0) {
@@ -2792,7 +2824,9 @@
             this._name = name;
             this._parent = null;
             this._firstIndex = -1;
-            this._unaryPatterns = [];
+            this._atomPatterns = [];
+            this._unaryPrefixPatterns = [];
+            this._unaryPrefixNames = [];
             this._binaryPatterns = [];
             this._recursivePatterns = [];
             this._recursiveNames = [];
@@ -2803,7 +2837,7 @@
             this._originalPatterns = patterns;
             this._shouldCompactPatternsMap = {};
             this._patterns = this._organizePatterns(patterns);
-            if (this._unaryPatterns.length === 0) {
+            if (this._atomPatterns.length === 0) {
                 throw new Error("Need at least one operand pattern with an 'expression' pattern.");
             }
         }
@@ -2811,7 +2845,13 @@
             const finalPatterns = [];
             patterns.forEach((pattern) => {
                 this._shouldCompactPatternsMap[pattern.name] = pattern.shouldCompactAst;
-                if (this._isBinary(pattern)) {
+                if (this._isUnary(pattern)) {
+                    const unaryPrefix = this._extractUnaryPrefixPattern(pattern).clone();
+                    this._unaryPrefixPatterns.push(pattern);
+                    this._unaryPrefixNames.push(pattern.name);
+                    finalPatterns.push(unaryPrefix);
+                }
+                else if (this._isBinary(pattern)) {
                     const binaryName = this._extractName(pattern);
                     const clone = this._extractDelimiter(pattern).clone();
                     clone.parent = this;
@@ -2838,7 +2878,7 @@
                 else {
                     const clone = pattern.clone();
                     clone.parent = this;
-                    this._unaryPatterns.push(clone);
+                    this._atomPatterns.push(clone);
                     finalPatterns.push(clone);
                 }
             });
@@ -2870,6 +2910,26 @@
             }
             return pattern.name;
         }
+        _isUnary(pattern) {
+            if (pattern.type === "right-associated" && this._isUnaryPattern(pattern.children[0])) {
+                return true;
+            }
+            return this._isUnaryPattern(pattern);
+        }
+        _isUnaryPattern(pattern) {
+            return pattern.type === "sequence" &&
+                pattern.children[0].type !== "reference" &&
+                pattern.children[0].name !== this.name &&
+                pattern.children[1].type === "reference" &&
+                pattern.children[1].name === this.name &&
+                pattern.children.length === 2;
+        }
+        _extractUnaryPrefixPattern(pattern) {
+            if (pattern.type === "right-associated") {
+                return pattern.children[0].children[0];
+            }
+            return pattern.children[0];
+        }
         _isRecursive(pattern) {
             if (pattern.type === "right-associated" && this._isRecursivePattern(pattern.children[0])) {
                 return true;
@@ -2880,7 +2940,7 @@
             return pattern.type === "sequence" &&
                 pattern.children[0].type === "reference" &&
                 pattern.children[0].name === this.name &&
-                pattern.children.length > 1;
+                pattern.children.length > 2;
         }
         _extractRecursiveTail(pattern) {
             if (pattern.type === "right-associated") {
@@ -2899,11 +2959,8 @@
                 lastChild.name === this.name;
         }
         parse(cursor) {
-            this._firstIndex = cursor.index;
-            depthCache.incrementDepth(this._id, this._firstIndex);
             this._firstIndex = cursor.index;
             const node = this._tryToParse(cursor);
-            depthCache.decrementDepth(this._id, this._firstIndex);
             if (node != null) {
                 cursor.moveTo(node.lastIndex);
                 cursor.resolveError();
@@ -2933,38 +2990,63 @@
             }
         }
         _tryToParse(cursor) {
-            if (depthCache.getDepth(this._id, this._firstIndex) > 2) {
+            if (this._isBeyondRecursiveAllowance()) {
                 cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
                 return null;
             }
-            let lastUnaryNode = null;
+            let lastAtomNode = null;
             let lastBinaryNode = null;
             let onIndex = cursor.index;
             outer: while (true) {
                 cursor.resolveError();
                 onIndex = cursor.index;
-                for (let i = 0; i < this._unaryPatterns.length; i++) {
+                let prefix = null;
+                let prefixName = "";
+                for (let i = 0; i < this._unaryPrefixPatterns.length; i++) {
+                    cursor.moveTo(onIndex);
+                    const pattern = this._unaryPrefixPatterns[i];
+                    const node = pattern.parse(cursor);
+                    if (node != null) {
+                        prefix = node;
+                        prefixName = this._unaryPrefixNames[i];
+                        if (cursor.hasNext()) {
+                            cursor.next();
+                        }
+                        else {
+                            break outer;
+                        }
+                        break;
+                    }
+                    else {
+                        cursor.resolveError();
+                    }
+                }
+                onIndex = cursor.index;
+                for (let i = 0; i < this._atomPatterns.length; i++) {
                     cursor.moveTo(onIndex);
-                    const pattern = this._unaryPatterns[i];
+                    const pattern = this._atomPatterns[i];
                     const node = pattern.parse(cursor);
                     if (node != null) {
-                        lastUnaryNode = node;
+                        lastAtomNode = node;
                         break;
                     }
                     else {
-                        lastUnaryNode = null;
+                        lastAtomNode = null;
                         cursor.resolveError();
                     }
                 }
-                if (lastUnaryNode == null) {
+                if (lastAtomNode == null) {
                     break;
                 }
                 if (cursor.hasNext()) {
                     cursor.next();
                 }
                 else {
-                    if (lastBinaryNode != null && lastUnaryNode != null) {
-                        lastBinaryNode.appendChild(lastUnaryNode);
+                    if (lastBinaryNode != null && lastAtomNode != null) {
+                        if (prefix != null) {
+                            lastAtomNode = createNode(prefixName, [prefix, lastAtomNode]);
+                        }
+                        lastBinaryNode.appendChild(lastAtomNode);
                     }
                     break;
                 }
@@ -2975,24 +3057,30 @@
                     if (node != null) {
                         const name = this._recursiveNames[i];
                         if (this._endsInRecursion[i]) {
-                            if (lastBinaryNode != null && lastUnaryNode != null) {
-                                lastBinaryNode.appendChild(lastUnaryNode);
+                            if (lastBinaryNode != null && lastAtomNode != null) {
+                                if (prefix != null) {
+                                    lastAtomNode = createNode(prefixName, [prefix, lastAtomNode]);
+                                }
+                                lastBinaryNode.appendChild(lastAtomNode);
                             }
-                            const frontExpression = lastBinaryNode == null ? lastUnaryNode : lastBinaryNode.findRoot();
+                            const frontExpression = lastBinaryNode == null ? lastAtomNode : lastBinaryNode.findRoot();
                             const recursiveNode = createNode(name, [frontExpression, ...node.children]);
                             recursiveNode.normalize(this._firstIndex);
                             return recursiveNode;
                         }
                         else {
-                            const recursiveNode = createNode(name, [lastUnaryNode, ...node.children]);
-                            recursiveNode.normalize(lastUnaryNode.startIndex);
-                            lastUnaryNode = recursiveNode;
+                            if (prefix != null) {
+                                lastAtomNode = createNode(prefixName, [prefix, lastAtomNode]);
+                            }
+                            const recursiveNode = createNode(name, [lastAtomNode, ...node.children]);
+                            recursiveNode.normalize(lastAtomNode.startIndex);
+                            lastAtomNode = recursiveNode;
                             if (cursor.hasNext()) {
                                 cursor.next();
                             }
                             else {
-                                if (lastBinaryNode != null) {
-                                    lastBinaryNode.appendChild(lastUnaryNode);
+                                if (lastBinaryNode != null && lastAtomNode != null) {
+                                    lastBinaryNode.appendChild(lastAtomNode);
                                 }
                                 break outer;
                             }
@@ -3014,31 +3102,31 @@
                     if (delimiterNode == null) {
                         if (i === this._binaryPatterns.length - 1) {
                             if (lastBinaryNode == null) {
-                                return lastUnaryNode;
+                                return lastAtomNode;
                             }
-                            else if (lastUnaryNode != null) {
-                                lastBinaryNode.appendChild(lastUnaryNode);
+                            else if (lastAtomNode != null) {
+                                lastBinaryNode.appendChild(lastAtomNode);
                             }
                         }
                         continue;
                     }
-                    if (lastBinaryNode == null && lastUnaryNode != null && delimiterNode != null) {
-                        const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                    if (lastBinaryNode == null && lastAtomNode != null && delimiterNode != null) {
+                        const node = createNode(name, [lastAtomNode, delimiterNode]);
                         lastBinaryNode = node;
                     }
-                    else if (lastBinaryNode != null && lastUnaryNode != null && delimiterNode != null) {
+                    else if (lastBinaryNode != null && lastAtomNode != null && delimiterNode != null) {
                         const precedence = this._precedenceMap[name];
                         const lastPrecendece = lastBinaryNode == null ? 0 : this._precedenceMap[lastBinaryNode.name] == null ? -1 : this._precedenceMap[lastBinaryNode.name];
                         const association = this._binaryAssociation[i];
                         if (precedence === lastPrecendece && association === Association.right) {
-                            const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                            const node = createNode(name, [lastAtomNode, delimiterNode]);
                             lastBinaryNode.appendChild(node);
                             lastBinaryNode = node;
                         }
                         else if (precedence === lastPrecendece) {
                             const node = createNode(name, []);
                             lastBinaryNode.replaceWith(node);
-                            lastBinaryNode.appendChild(lastUnaryNode);
+                            lastBinaryNode.appendChild(lastAtomNode);
                             node.append(lastBinaryNode, delimiterNode);
                             lastBinaryNode = node;
                         }
@@ -3053,7 +3141,7 @@
                                 root = ancestor;
                                 ancestor = ancestor.parent;
                             }
-                            lastBinaryNode.appendChild(lastUnaryNode);
+                            lastBinaryNode.appendChild(lastAtomNode);
                             if (root != null) {
                                 const node = createNode(name, []);
                                 root.replaceWith(node);
@@ -3061,12 +3149,12 @@
                                 lastBinaryNode = node;
                             }
                             else {
-                                const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                                const node = createNode(name, [lastAtomNode, delimiterNode]);
                                 lastBinaryNode = node;
                             }
                         }
                         else {
-                            const node = createNode(name, [lastUnaryNode, delimiterNode]);
+                            const node = createNode(name, [lastAtomNode, delimiterNode]);
                             lastBinaryNode.appendChild(node);
                             lastBinaryNode = node;
                         }
@@ -3084,20 +3172,34 @@
                 }
             }
             if (lastBinaryNode == null) {
-                return lastUnaryNode;
+                return lastAtomNode;
             }
             else {
                 const root = lastBinaryNode.findAncestor(n => n.parent == null) || lastBinaryNode;
                 if (lastBinaryNode.children.length < 3) {
                     lastBinaryNode.remove();
                     if (lastBinaryNode === root) {
-                        return lastUnaryNode;
+                        return lastAtomNode;
                     }
                 }
                 root.normalize(this._firstIndex);
                 return root;
             }
         }
+        _isBeyondRecursiveAllowance() {
+            let depth = 0;
+            let pattern = this;
+            while (pattern != null) {
+                if (pattern.id === this.id && pattern.startedOnIndex === this.startedOnIndex) {
+                    depth++;
+                }
+                if (depth > 2) {
+                    return true;
+                }
+                pattern = pattern.parent;
+            }
+            return false;
+        }
         test(text) {
             const cursor = new Cursor(text);
             const ast = this.parse(cursor);
@@ -3125,7 +3227,7 @@
                 return this._binaryPatterns.map(p => p.getTokens()).flat();
             }
             if (this.binaryPatterns.indexOf(childReference)) {
-                const unaryTokens = this._unaryPatterns.map(p => p.getTokens()).flat();
+                const unaryTokens = this._atomPatterns.map(p => p.getTokens()).flat();
                 if (this._parent != null) {
                     const nextTokens = this._parent.getTokensAfter(this);
                     return [...unaryTokens, ...nextTokens];
@@ -3153,7 +3255,7 @@
                 return this._binaryPatterns.map(p => p.getPatterns()).flat();
             }
             if (this.binaryPatterns.indexOf(childReference)) {
-                const unaryPatterns = this._unaryPatterns.map(p => p.getPatterns()).flat();
+                const unaryPatterns = this._atomPatterns.map(p => p.getPatterns()).flat();
                 if (this._parent != null) {
                     const nextPatterns = this._parent.getPatternsAfter(this);
                     return [...unaryPatterns, ...nextPatterns];