clarity-pattern-parser 11.0.2 → 11.0.4

package/dist/index.browser.js

@@ -2144,7 +2144,10 @@
 
     const patternName = name$1.clone("pattern-name");
     patternName.setTokens(["[PATTERN_NAME]"]);
-    const patterns$1 = new Options("options-patterns", [patternName, anonymousPattern]);
+    const patterns$1 = new Sequence("patterns", [
+        new Options("options-patterns", [patternName, anonymousPattern]),
+        new Optional("optional-right-associated", new Literal("right-associated", " right"))
+    ]);
     const defaultDivider = new Regex("default-divider", "\\s*[|]\\s*");
     defaultDivider.setTokens(["|"]);
     const greedyDivider = new Regex("greedy-divider", "\\s*[<][|][>]\\s*");
@@ -2714,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;
@@ -2751,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) {
@@ -2767,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) {
@@ -2784,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;
             }
         }
@@ -2829,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;
             }
@@ -2850,13 +2874,12 @@
         reset() {
             this._prefixNode = null;
             this._atomNode = null;
-            this._orphanedAtom = null;
             this._postfixNode = null;
             this._binaryNode = null;
         }
     }
 
-    let indexId = 0;
+    let indexId$1 = 0;
     class ExpressionPattern {
         get id() {
             return this._id;
@@ -2895,7 +2918,7 @@
             if (patterns.length === 0) {
                 throw new Error("Need at least one pattern with an 'expression' pattern.");
             }
-            this._id = `expression-${indexId++}`;
+            this._id = `expression-${indexId$1++}`;
             this._type = "expression";
             this._name = name;
             this._parent = null;
@@ -3232,6 +3255,88 @@
         }
     }
 
+    let indexId = 0;
+    class RightAssociatedPattern {
+        get id() {
+            return this._id;
+        }
+        get type() {
+            return this._type;
+        }
+        get name() {
+            return this._name;
+        }
+        get parent() {
+            return this._parent;
+        }
+        set parent(pattern) {
+            this._parent = pattern;
+        }
+        get children() {
+            return this._children;
+        }
+        get startedOnIndex() {
+            return this._children[0].startedOnIndex;
+        }
+        constructor(pattern) {
+            this._id = `right-associated-${indexId++}`;
+            this._type = "right-associated";
+            this._name = "";
+            this._parent = null;
+            this._children = [pattern.clone()];
+        }
+        parse(cursor) {
+            return this.children[0].parse(cursor);
+        }
+        exec(text, record) {
+            return this.children[0].exec(text, record);
+        }
+        test(text, record) {
+            return this.children[0].test(text, record);
+        }
+        clone(_name) {
+            const clone = new RightAssociatedPattern(this.children[0]);
+            clone._id = this._id;
+            return clone;
+        }
+        getTokens() {
+            return this.children[0].getTokens();
+        }
+        getTokensAfter(_childReference) {
+            if (this._parent == null) {
+                return [];
+            }
+            return this._parent.getTokensAfter(this);
+        }
+        getNextTokens() {
+            if (this._parent == null) {
+                return [];
+            }
+            return this._parent.getTokensAfter(this);
+        }
+        getPatterns() {
+            return this.children[0].getPatterns();
+        }
+        getPatternsAfter(_childReference) {
+            if (this._parent == null) {
+                return [];
+            }
+            return this._parent.getPatternsAfter(this);
+        }
+        getNextPatterns() {
+            if (this._parent == null) {
+                return [];
+            }
+            return this._parent.getPatternsAfter(this);
+        }
+        find(predicate) {
+            return this.children[0].find(predicate);
+        }
+        isEqual(pattern) {
+            return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
+        }
+    }
+
     let anonymousIndexId = 0;
     const patternNodes = {
         "literal": true,
@@ -3413,7 +3518,15 @@
         _buildOptions(name, node) {
             const patternNodes = node.children.filter(n => n.name !== "default-divider" && n.name !== "greedy-divider");
             const isGreedy = node.find(n => n.name === "greedy-divider") != null;
-            const patterns = patternNodes.map(n => this._buildPattern(n));
+            const patterns = patternNodes.map(n => {
+                const rightAssociated = n.find(n => n.name === "right-associated");
+                if (rightAssociated != null) {
+                    return new RightAssociatedPattern(this._buildPattern(n.children[0]));
+                }
+                else {
+                    return this._buildPattern(n.children[0]);
+                }
+            });
             const hasRecursivePattern = patterns.some(p => this._isRecursive(name, p));
             if (hasRecursivePattern && !isGreedy) {
                 try {
@@ -3432,10 +3545,15 @@
             return this._isRecursivePattern(name, pattern);
         }
         _isRecursivePattern(name, pattern) {
-            return pattern.type === "sequence" &&
-                pattern.children[0].type === "reference" &&
-                pattern.children[0].name === name &&
-                pattern.children.length > 2;
+            if (pattern.children.length === 0) {
+                return false;
+            }
+            const firstChild = pattern.children[0];
+            const lastChild = pattern.children[pattern.children.length - 1];
+            const isLongEnough = pattern.children.length >= 2;
+            return pattern.type === "sequence" && isLongEnough &&
+                (firstChild.type === "reference" && firstChild.name === name) ||
+                (lastChild.type === "reference" && lastChild.name === name);
         }
         _buildPattern(node) {
             const type = node.name;