clarity-pattern-parser 11.5.3 → 11.5.4

package/dist/index.browser.js

@@ -2885,6 +2885,10 @@
         get postfixPatterns() {
             return this._postfixPatterns;
         }
+        get infixPatterns() {
+            return this._infixPatterns;
+        }
+        // @deprecated use infixPatterns instead
         get binaryPatterns() {
             return this._infixPatterns;
         }
@@ -2911,7 +2915,7 @@
             this._postfixPatterns = [];
             this._postfixNames = [];
             this._infixPatterns = [];
-            this._binaryNames = [];
+            this._infixNames = [];
             this._associationMap = {};
             this._precedenceMap = {};
             this._originalPatterns = patterns;
@@ -2950,18 +2954,18 @@
                 }
                 else if (this._isBinary(pattern)) {
                     const name = this._extractName(pattern);
-                    const binary = this._extractBinary(pattern);
-                    binary.parent = this;
+                    const infix = this._extractInfix(pattern);
+                    infix.parent = this;
                     this._precedenceMap[name] = index;
-                    this._infixPatterns.push(binary);
-                    this._binaryNames.push(name);
+                    this._infixPatterns.push(infix);
+                    this._infixNames.push(name);
                     if (pattern.type === "right-associated") {
                         this._associationMap[name] = Association.right;
                     }
                     else {
                         this._associationMap[name] = Association.left;
                     }
-                    finalPatterns.push(binary);
+                    finalPatterns.push(infix);
                 }
             });
             this._patterns = finalPatterns;
@@ -3027,11 +3031,11 @@
             const lastChildIsReference = this._isRecursiveReference(lastChild);
             return firstChildIsReference && lastChildIsReference && pattern.children.length > 2;
         }
-        _extractBinary(pattern) {
+        _extractInfix(pattern) {
             pattern = this._unwrapAssociationIfNecessary(pattern);
             const children = pattern.children.slice(1, -1);
-            const binarySequence = new Sequence(`${pattern.name}-delimiter`, children);
-            return binarySequence;
+            const infixSequence = new Sequence(`${pattern.name}-delimiter`, children);
+            return infixSequence;
         }
         _unwrapAssociationIfNecessary(pattern) {
             if (pattern.type === "right-associated") {
@@ -3191,13 +3195,13 @@
         _tryToMatchBinary(cursor) {
             let onIndex = cursor.index;
             let foundMatch = false;
-            if (this.binaryPatterns.length === 0) {
+            if (this.infixPatterns.length === 0) {
                 this._shouldStopParsing = true;
             }
             for (let i = 0; i < this._infixPatterns.length; i++) {
                 cursor.moveTo(onIndex);
                 const pattern = this._infixPatterns[i];
-                const name = this._binaryNames[i];
+                const name = this._infixNames[i];
                 const node = pattern.parse(cursor);
                 if (node != null) {
                     foundMatch = true;
@@ -3246,6 +3250,10 @@
                 }
                 return [...postfixTokens, ...infixTokens];
             }
+            if (this._infixPatterns.includes(childReference)) {
+                const atomTokens = this._atomPatterns.map(p => p.getTokens()).flat();
+                return atomTokens;
+            }
             if (this._postfixPatterns.includes(childReference)) {
                 const postfixTokens = this.postfixPatterns.map(p => p.getTokens()).flat();
                 const infixTokens = this._infixPatterns.map(p => p.getTokens()).flat();
@@ -3283,6 +3291,10 @@
                 }
                 return [...postfixPatterns, ...infixPatterns];
             }
+            if (this._infixPatterns.includes(childReference)) {
+                const atomPatterns = this._atomPatterns.map(p => p.getPatterns()).flat();
+                return atomPatterns;
+            }
             if (this._postfixPatterns.includes(childReference)) {
                 const postfixPatterns = this.postfixPatterns.map(p => p.getPatterns()).flat();
                 const infixPatterns = this._infixPatterns.map(p => p.getPatterns()).flat();