clarity-pattern-parser 11.0.3 → 11.0.5

package/dist/index.esm.js

@@ -2711,9 +2711,9 @@ class PrecedenceTree {
         this._binaryPlaceholder = Node.createNode("placeholder", "binary-placeholder");
         this._atomNode = null;
         this._binaryNode = null;
-        this._orphanedAtom = null;
         this._precedenceMap = precedenceMap;
         this._associationMap = associationMap;
+        this._revertBinary = () => { };
     }
     addPrefix(name, ...prefix) {
         const lastPrefixNode = this._prefixNode;
@@ -2748,15 +2748,22 @@ class PrecedenceTree {
             throw new Error("Cannot add a binary without an atom node.");
         }
         this._binaryPlaceholder.remove();
-        this._orphanedAtom = lastAtomNode;
         if (lastBinaryNode == null) {
             const node = Node.createNode("expression", name, [lastAtomNode, ...delimiterNode, this._binaryPlaceholder]);
             this._binaryNode = node;
+            this._revertBinary = () => {
+                lastAtomNode.remove();
+                this._binaryNode = lastAtomNode;
+            };
             return;
         }
         if (precedence === lastPrecendece && association === Association.right) {
             const node = Node.createNode("expression", name, [lastAtomNode, ...delimiterNode, this._binaryPlaceholder]);
             lastBinaryNode.appendChild(node);
+            this._revertBinary = () => {
+                node.replaceWith(lastAtomNode);
+                this._binaryNode = lastBinaryNode;
+            };
             this._binaryNode = node;
         }
         else if (precedence === lastPrecendece) {
@@ -2764,6 +2771,11 @@ class PrecedenceTree {
             lastBinaryNode.replaceWith(node);
             lastBinaryNode.appendChild(lastAtomNode);
             node.append(lastBinaryNode, ...delimiterNode, this._binaryPlaceholder);
+            this._revertBinary = () => {
+                lastBinaryNode.remove();
+                node.replaceWith(lastBinaryNode);
+                this._binaryNode = lastBinaryNode;
+            };
             this._binaryNode = node;
         }
         else if (precedence > lastPrecendece) {
@@ -2781,11 +2793,21 @@ class PrecedenceTree {
             const node = Node.createNode("expression", name, []);
             root.replaceWith(node);
             node.append(root, ...delimiterNode, this._binaryPlaceholder);
+            this._revertBinary = () => {
+                root.remove();
+                node.replaceWith(root);
+                this._binaryNode = root;
+            };
             this._binaryNode = node;
         }
         else {
             const node = Node.createNode("expression", name, [lastAtomNode, ...delimiterNode, this._binaryPlaceholder]);
             lastBinaryNode.appendChild(node);
+            this._revertBinary = () => {
+                lastAtomNode.remove();
+                node.replaceWith(lastAtomNode);
+                this._binaryNode = lastBinaryNode;
+            };
             this._binaryNode = node;
         }
     }
@@ -2826,14 +2848,13 @@ class PrecedenceTree {
         return this._atomNode != null;
     }
     commit() {
-        var _a;
         if (this._binaryNode == null) {
             return this._compileAtomNode();
         }
         const atomNode = this._compileAtomNode();
         if (atomNode == null) {
-            let root = this._binaryPlaceholder.findRoot();
-            (_a = this._binaryPlaceholder.parent) === null || _a === void 0 ? void 0 : _a.replaceWith(this._orphanedAtom);
+            this._revertBinary();
+            let root = this._binaryNode.findRoot();
             this.reset();
             return root;
         }
@@ -2847,7 +2868,6 @@ class PrecedenceTree {
     reset() {
         this._prefixNode = null;
         this._atomNode = null;
-        this._orphanedAtom = null;
         this._postfixNode = null;
         this._binaryNode = null;
     }
@@ -2904,12 +2924,12 @@ class ExpressionPattern {
         this._postfixNames = [];
         this._binaryPatterns = [];
         this._binaryNames = [];
-        this.associationMap = {};
+        this._associationMap = {};
         this._precedenceMap = {};
         this._originalPatterns = patterns;
         this._patterns = this._organizePatterns(patterns);
         this._shouldStopParsing = false;
-        this._precedenceTree = new PrecedenceTree(this._precedenceMap, this.associationMap);
+        this._precedenceTree = new PrecedenceTree(this._precedenceMap, this._associationMap);
         if (this._atomPatterns.length === 0) {
             throw new Error("Need at least one terminating pattern with an 'expression' pattern.");
         }
@@ -2947,10 +2967,10 @@ class ExpressionPattern {
                 this._binaryPatterns.push(clone);
                 this._binaryNames.push(name);
                 if (pattern.type === "right-associated") {
-                    this.associationMap[name] = Association.right;
+                    this._associationMap[name] = Association.right;
                 }
                 else {
-                    this.associationMap[name] = Association.left;
+                    this._associationMap[name] = Association.left;
                 }
                 finalPatterns.push(clone);
             }
@@ -3195,7 +3215,24 @@ class ExpressionPattern {
     getTokens() {
         return this.atomPatterns.map(p => p.getTokens()).flat();
     }
-    getTokensAfter(_childReference) {
+    getTokensAfter(childReference) {
+        if (this._prefixPatterns.includes(childReference) || this._binaryPatterns.includes(childReference)) {
+            const atomTokens = this._atomPatterns.map(p => p.getTokens()).flat();
+            const prefixTokens = this.prefixPatterns.map(p => p.getTokens()).flat();
+            return [...prefixTokens, ...atomTokens];
+        }
+        if (this._atomPatterns.includes(childReference)) {
+            const postfixTokens = this.prefixPatterns.map(p => p.getTokens()).flat();
+            if (postfixTokens.length === 0) {
+                return this._binaryPatterns.map(p => p.getTokens()).flat();
+            }
+            return postfixTokens;
+        }
+        if (this._postfixPatterns.includes(childReference)) {
+            const postfixTokens = this.postfixPatterns.map(p => p.getTokens()).flat();
+            const binaryTokens = this._binaryPatterns.map(p => p.getTokens()).flat();
+            return [...postfixTokens, ...binaryTokens];
+        }
         return [];
     }
     getNextTokens() {
@@ -3207,7 +3244,24 @@ class ExpressionPattern {
     getPatterns() {
         return this.atomPatterns.map(p => p.getPatterns()).flat();
     }
-    getPatternsAfter(_childReference) {
+    getPatternsAfter(childReference) {
+        if (this._prefixPatterns.includes(childReference) || this._binaryPatterns.includes(childReference)) {
+            const atomPatterns = this._atomPatterns.map(p => p.getPatterns()).flat();
+            const prefixPatterns = this.prefixPatterns.map(p => p.getPatterns()).flat();
+            return [...prefixPatterns, ...atomPatterns];
+        }
+        if (this._atomPatterns.includes(childReference)) {
+            const postfixPatterns = this.prefixPatterns.map(p => p.getPatterns()).flat();
+            if (postfixPatterns.length === 0) {
+                return this._binaryPatterns.map(p => p.getPatterns()).flat();
+            }
+            return postfixPatterns;
+        }
+        if (this._postfixPatterns.includes(childReference)) {
+            const postfixPaterns = this.postfixPatterns.map(p => p.getPatterns()).flat();
+            const binaryPatterns = this._binaryPatterns.map(p => p.getPatterns()).flat();
+            return [...postfixPaterns, ...binaryPatterns];
+        }
         return [];
     }
     getNextPatterns() {