clarity-pattern-parser 10.2.3 → 10.2.5

package/dist/index.browser.js

@@ -2738,6 +2738,7 @@
             this._binaryPatterns = [];
             this._recursivePatterns = [];
             this._recursiveNames = [];
+            this._endsInRecursion = [];
             this._binaryNames = [];
             this._binaryAssociation = [];
             this._precedenceMap = {};
@@ -2771,6 +2772,7 @@
                     tail.parent = this;
                     this._recursivePatterns.push(tail);
                     this._recursiveNames.push(name);
+                    this._endsInRecursion.push(this._endsWithRecursion(pattern));
                     finalPatterns.push(tail);
                 }
                 else {
@@ -2826,6 +2828,16 @@
             }
             return new Sequence(`${pattern.name}-tail`, pattern.children.slice(1));
         }
+        _endsWithRecursion(pattern) {
+            if (pattern.type === "right-associated") {
+                pattern = pattern.children[0];
+            }
+            const lastChild = pattern.children[pattern.children.length - 1];
+            return pattern.type === "sequence" &&
+                pattern.children.length > 1 &&
+                lastChild.type === "reference" &&
+                lastChild.name === this.name;
+        }
         parse(cursor) {
             // This is a cache to help with speed
             this._firstIndex = cursor.index;
@@ -2850,6 +2862,7 @@
             let lastBinaryNode = null;
             let onIndex = cursor.index;
             outer: while (true) {
+                cursor.resolveError();
                 onIndex = cursor.index;
                 for (let i = 0; i < this._unaryPatterns.length; i++) {
                     cursor.moveTo(onIndex);
@@ -2884,14 +2897,23 @@
                         if (lastBinaryNode != null && lastUnaryNode != null) {
                             lastBinaryNode.appendChild(lastUnaryNode);
                         }
-                        const frontExpression = lastBinaryNode == null ? lastUnaryNode : lastBinaryNode.findRoot();
                         const name = this._recursiveNames[i];
-                        const recursiveNode = createNode(name, [frontExpression, ...node.children]);
-                        recursiveNode.normalize(this._firstIndex);
-                        return recursiveNode;
+                        if (this._endsInRecursion[i]) {
+                            const frontExpression = lastBinaryNode == null ? lastUnaryNode : 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(this._firstIndex);
+                            lastUnaryNode = recursiveNode;
+                            break;
+                        }
                     }
                     cursor.moveTo(onIndex);
                 }
+                cursor.resolveError();
                 onIndex = cursor.index;
                 for (let i = 0; i < this._binaryPatterns.length; i++) {
                     cursor.moveTo(onIndex);
@@ -2915,7 +2937,7 @@
                     }
                     else if (lastBinaryNode != null && lastUnaryNode != null && delimiterNode != null) {
                         const precedence = this._precedenceMap[name];
-                        const lastPrecendece = lastBinaryNode == null ? 0 : this._precedenceMap[lastBinaryNode.name];
+                        const lastPrecendece = lastBinaryNode == null ? 0 : this._precedenceMap[lastBinaryNode.name] || -1;
                         const association = this._binaryAssociation[i];
                         if (precedence === lastPrecendece && association === Association.right) {
                             const node = createNode(name, [lastUnaryNode, delimiterNode]);