clarity-pattern-parser 11.0.3 → 11.0.5

package/dist/index.browser.js

@@ -2717,9 +2717,9 @@
             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;
@@ -2754,15 +2754,22 @@
                 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) {
@@ -2770,6 +2777,11 @@
                 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) {
@@ -2787,11 +2799,21 @@
                 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;
             }
         }
@@ -2832,14 +2854,13 @@
             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;
             }
@@ -2853,7 +2874,6 @@
         reset() {
             this._prefixNode = null;
             this._atomNode = null;
-            this._orphanedAtom = null;
             this._postfixNode = null;
             this._binaryNode = null;
         }
@@ -2910,12 +2930,12 @@
             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.");
             }
@@ -2953,10 +2973,10 @@
                     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);
                 }
@@ -3201,7 +3221,24 @@
         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() {
@@ -3213,7 +3250,24 @@
         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() {