clarity-pattern-parser 10.2.3 → 10.2.5

package/dist/index.esm.js

@@ -2732,6 +2732,7 @@ class ExpressionPattern {
         this._binaryPatterns = [];
         this._recursivePatterns = [];
         this._recursiveNames = [];
+        this._endsInRecursion = [];
         this._binaryNames = [];
         this._binaryAssociation = [];
         this._precedenceMap = {};
@@ -2765,6 +2766,7 @@ class ExpressionPattern {
                 tail.parent = this;
                 this._recursivePatterns.push(tail);
                 this._recursiveNames.push(name);
+                this._endsInRecursion.push(this._endsWithRecursion(pattern));
                 finalPatterns.push(tail);
             }
             else {
@@ -2820,6 +2822,16 @@ class ExpressionPattern {
         }
         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;
@@ -2844,6 +2856,7 @@ class ExpressionPattern {
         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);
@@ -2878,14 +2891,23 @@ class ExpressionPattern {
                     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);
@@ -2909,7 +2931,7 @@ class ExpressionPattern {
                 }
                 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]);