clarity-pattern-parser 11.0.1 → 11.0.3

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*");
@@ -2637,7 +2640,6 @@
             return Object.assign({}, this._patterns);
         }
         constructor(name, pattern, context = []) {
-            this.shouldCompactAst = false;
             this._id = `context-${contextId++}`;
             this._type = "context";
             this._name = name;
@@ -2661,7 +2663,6 @@
         clone(name = this._name) {
             const clone = new Context(name, this._pattern, Object.values(this._patterns));
             clone._id = this._id;
-            clone.shouldCompactAst = this.shouldCompactAst;
             return clone;
         }
         getTokens() {
@@ -2809,7 +2810,7 @@
         _compileAtomNode() {
             let node = this._atomNode;
             if (this._prefixNode != null && this._atomNode != null) {
-                node = this._prefixNode;
+                node = this._prefixNode.findRoot();
                 this._prefixPlaceholder.replaceWith(this._atomNode);
             }
             if (this._postfixNode != null && node != null) {
@@ -2858,7 +2859,7 @@
         }
     }
 
-    let indexId = 0;
+    let indexId$1 = 0;
     class ExpressionPattern {
         get id() {
             return this._id;
@@ -2897,7 +2898,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;
@@ -3169,8 +3170,8 @@
                     break;
                 }
                 else {
-                    cursor.resolveError();
                     cursor.moveTo(onIndex);
+                    cursor.resolveError();
                 }
             }
             if (!foundMatch) {
@@ -3234,6 +3235,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,
@@ -3415,7 +3498,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 {
@@ -3434,10 +3525,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;