clarity-pattern-parser 8.4.15 → 9.0.0

package/dist/index.browser.js

@@ -249,6 +249,7 @@
             this._patterns = [];
             this._nodes = [];
             this._errors = [];
+            this._trace = [];
         }
         get isRecording() {
             return this._isRecording;
@@ -277,6 +278,9 @@
         get patterns() {
             return this._patterns;
         }
+        get trace() {
+            return this._trace;
+        }
         recordMatch(pattern, node) {
             if (this._isRecording) {
                 this._patterns.push(pattern);
@@ -331,6 +335,11 @@
         resolveError() {
             this._currentError = null;
         }
+        pushStackTrace(trace) {
+            if (this._isRecording) {
+                this._trace.push(trace);
+            }
+        }
     }
 
     class Cursor {
@@ -387,6 +396,7 @@
             this._index = 0;
             this._length = text.length;
             this._history = new CursorHistory();
+            this._stackTrace = [];
         }
         hasNext() {
             return this._index + 1 < this._length;
@@ -436,9 +446,42 @@
         stopRecording() {
             this._history.stopRecording();
         }
+        startParseWith(pattern) {
+            const patternName = pattern.name;
+            const trace = {
+                pattern,
+                cursorIndex: this.index
+            };
+            if (this._stackTrace.find(t => t.pattern.id === pattern.id && this.index === t.cursorIndex)) {
+                throw new Error(`Cyclical Pattern: ${this._stackTrace.map(t => `${t.pattern.name}#${t.pattern.id}{${t.cursorIndex}}`).join(" -> ")} -> ${patternName}#${pattern.id}{${this.index}}.`);
+            }
+            this._history.pushStackTrace(trace);
+            this._stackTrace.push(trace);
+        }
+        endParse() {
+            this._stackTrace.pop();
+        }
+        audit() {
+            return this._history.trace.map(t => {
+                const onChar = this.getChars(t.cursorIndex, t.cursorIndex);
+                const restChars = this.getChars(t.cursorIndex + 1, t.cursorIndex + 5);
+                const context = `{${t.cursorIndex}}[${onChar}]${restChars}`;
+                return `${this._buildPatternContext(t.pattern)}-->${context}`;
+            });
+        }
+        _buildPatternContext(pattern) {
+            if (pattern.parent != null) {
+                return `${pattern.parent.name}.${pattern.name}`;
+            }
+            return pattern.name;
+        }
     }
 
+    let idIndex$8 = 0;
     class Literal {
+        get id() {
+            return this._id;
+        }
         get type() {
             return this._type;
         }
@@ -461,9 +504,10 @@
             if (value.length === 0) {
                 throw new Error("Value Cannot be empty.");
             }
+            this._id = `literal-${idIndex$8++}`;
             this._type = "literal";
             this._name = name;
-            this._literal = value;
+            this._text = value;
             this._runes = Array.from(value);
             this._isOptional = isOptional;
             this._parent = null;
@@ -476,8 +520,9 @@
             const ast = this.parse(cursor);
             return (ast === null || ast === void 0 ? void 0 : ast.value) === text;
         }
-        exec(text) {
+        exec(text, record = false) {
             const cursor = new Cursor(text);
+            record && cursor.startRecording();
             const ast = this.parse(cursor);
             return {
                 ast: (ast === null || ast === void 0 ? void 0 : ast.value) === text ? ast : null,
@@ -485,20 +530,24 @@
             };
         }
         parse(cursor) {
+            cursor.startParseWith(this);
             this._firstIndex = cursor.index;
             const passed = this._tryToParse(cursor);
             if (passed) {
                 cursor.resolveError();
                 const node = this._createNode();
                 cursor.recordMatch(this, node);
+                cursor.endParse();
                 return node;
             }
             if (!this._isOptional) {
                 cursor.recordErrorAt(this._firstIndex, this._endIndex, this);
+                cursor.endParse();
                 return null;
             }
             cursor.resolveError();
             cursor.moveTo(this._firstIndex);
+            cursor.endParse();
             return null;
         }
         _tryToParse(cursor) {
@@ -512,7 +561,7 @@
                     break;
                 }
                 if (i + 1 === literalRuneLength) {
-                    this._lastIndex = this._firstIndex + this._literal.length - 1;
+                    this._lastIndex = this._firstIndex + this._text.length - 1;
                     passed = true;
                     break;
                 }
@@ -525,14 +574,15 @@
             return passed;
         }
         _createNode() {
-            return new Node("literal", this._name, this._firstIndex, this._lastIndex, undefined, this._literal);
+            return new Node("literal", this._name, this._firstIndex, this._lastIndex, undefined, this._text);
         }
         clone(name = this._name, isOptional = this._isOptional) {
-            const clone = new Literal(name, this._literal, isOptional);
+            const clone = new Literal(name, this._text, isOptional);
+            clone._id = this._id;
             return clone;
         }
         getTokens() {
-            return [this._literal];
+            return [this._text];
         }
         getTokensAfter(_lastMatched) {
             return [];
@@ -558,9 +608,16 @@
         find(_predicate) {
             return null;
         }
+        isEqual(pattern) {
+            return pattern.type === this.type && pattern._text === this._text;
+        }
     }
 
+    let idIndex$7 = 0;
     class Regex {
+        get id() {
+            return this._id;
+        }
         get type() {
             return this._type;
         }
@@ -585,6 +642,7 @@
             this._firstIndex = -1;
             this._substring = "";
             this._tokens = [];
+            this._id = `regex-${idIndex$7++}`;
             this._type = "regex";
             this._name = name;
             this._isOptional = isOptional;
@@ -609,8 +667,9 @@
             const ast = this.parse(cursor);
             return (ast === null || ast === void 0 ? void 0 : ast.value) === text;
         }
-        exec(text) {
+        exec(text, record = false) {
             const cursor = new Cursor(text);
+            record && cursor.startRecording();
             const ast = this.parse(cursor);
             return {
                 ast: (ast === null || ast === void 0 ? void 0 : ast.value) === text ? ast : null,
@@ -618,9 +677,11 @@
             };
         }
         parse(cursor) {
+            cursor.startParseWith(this);
             this._firstIndex = cursor.index;
             this.resetState(cursor);
             this.tryToParse(cursor);
+            cursor.endParse();
             return this._node;
         }
         resetState(cursor) {
@@ -652,9 +713,10 @@
             this._node = null;
         }
         clone(name = this._name, isOptional = this._isOptional) {
-            const pattern = new Regex(name, this._originalRegexString, isOptional);
-            pattern._tokens = this._tokens.slice();
-            return pattern;
+            const clone = new Regex(name, this._originalRegexString, isOptional);
+            clone._tokens = this._tokens.slice();
+            clone._id = this._id;
+            return clone;
         }
         getTokens() {
             return this._tokens;
@@ -686,6 +748,9 @@
         setTokens(tokens) {
             this._tokens = tokens;
         }
+        isEqual(pattern) {
+            return pattern.type === this.type && pattern._originalRegexString === this._originalRegexString;
+        }
     }
 
     function findPattern(pattern, predicate) {
@@ -710,7 +775,11 @@
         }
     }
 
+    let idIndex$6 = 0;
     class Reference {
+        get id() {
+            return this._id;
+        }
         get type() {
             return this._type;
         }
@@ -730,6 +799,7 @@
             return this._isOptional;
         }
         constructor(name, isOptional = false) {
+            this._id = `reference-${idIndex$6++}`;
             this._type = "reference";
             this._name = name;
             this._parent = null;
@@ -742,8 +812,9 @@
             const ast = this.parse(cursor);
             return (ast === null || ast === void 0 ? void 0 : ast.value) === text;
         }
-        exec(text) {
+        exec(text, record = false) {
             const cursor = new Cursor(text);
+            record && cursor.startRecording();
             const ast = this.parse(cursor);
             return {
                 ast: (ast === null || ast === void 0 ? void 0 : ast.value) === text ? ast : null,
@@ -819,7 +890,12 @@
             return null;
         }
         clone(name = this._name, isOptional = this._isOptional) {
-            return new Reference(name, isOptional);
+            const clone = new Reference(name, isOptional);
+            clone._id = this._id;
+            return clone;
+        }
+        isEqual(pattern) {
+            return pattern.type === this.type && pattern.name === this.name;
         }
     }
 
@@ -827,7 +903,11 @@
         return patterns.map(p => p.clone(p.name, isOptional));
     }
 
+    let idIndex$5 = 0;
     class Or {
+        get id() {
+            return this._id;
+        }
         get type() {
             return this._type;
         }
@@ -852,6 +932,7 @@
             }
             const children = clonePatterns(options, false);
             this._assignChildrenToParent(children);
+            this._id = `or-${idIndex$5++}`;
             this._type = "or";
             this._name = name;
             this._parent = null;
@@ -870,8 +951,9 @@
             const ast = this.parse(cursor);
             return (ast === null || ast === void 0 ? void 0 : ast.value) === text;
         }
-        exec(text) {
+        exec(text, record = false) {
             const cursor = new Cursor(text);
+            record && cursor.startRecording();
             const ast = this.parse(cursor);
             return {
                 ast: (ast === null || ast === void 0 ? void 0 : ast.value) === text ? ast : null,
@@ -879,19 +961,23 @@
             };
         }
         parse(cursor) {
+            cursor.startParseWith(this);
             this._firstIndex = cursor.index;
             const node = this._tryToParse(cursor);
             if (node != null) {
                 cursor.moveTo(node.lastIndex);
                 cursor.resolveError();
+                cursor.endParse();
                 return node;
             }
             if (!this._isOptional) {
                 cursor.recordErrorAt(this._firstIndex, this._firstIndex, this);
+                cursor.endParse();
                 return null;
             }
             cursor.resolveError();
             cursor.moveTo(this._firstIndex);
+            cursor.endParse();
             return null;
         }
         _tryToParse(cursor) {
@@ -954,11 +1040,19 @@
         }
         clone(name = this._name, isOptional = this._isOptional) {
             const or = new Or(name, this._children, isOptional, this._isGreedy);
+            or._id = this._id;
             return or;
         }
+        isEqual(pattern) {
+            return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
+        }
     }
 
+    let idIndex$4 = 0;
     class FiniteRepeat {
+        get id() {
+            return this._id;
+        }
         get type() {
             return this._type;
         }
@@ -984,6 +1078,7 @@
             return this._max;
         }
         constructor(name, pattern, repeatAmount, options = {}) {
+            this._id = `finite-repeat-${idIndex$4++}`;
             this._type = "finite-repeat";
             this._name = name;
             this._parent = null;
@@ -1000,6 +1095,7 @@
             }
         }
         parse(cursor) {
+            cursor.startParseWith(this);
             const startIndex = cursor.index;
             const nodes = [];
             const modulo = this._hasDivider ? 2 : 1;
@@ -1034,16 +1130,19 @@
                 const lastIndex = cursor.index;
                 cursor.moveTo(startIndex);
                 cursor.recordErrorAt(startIndex, lastIndex, this);
+                cursor.endParse();
                 return null;
             }
             else if (nodes.length === 0) {
                 cursor.resolveError();
                 cursor.moveTo(startIndex);
+                cursor.endParse();
                 return null;
             }
             const firstIndex = nodes[0].firstIndex;
             const lastIndex = nodes[nodes.length - 1].lastIndex;
             cursor.moveTo(lastIndex);
+            cursor.endParse();
             return new Node(this._type, this.name, firstIndex, lastIndex, nodes);
         }
         test(text) {
@@ -1051,8 +1150,9 @@
             const ast = this.parse(cursor);
             return (ast === null || ast === void 0 ? void 0 : ast.value) === text;
         }
-        exec(text) {
+        exec(text, record = false) {
             const cursor = new Cursor(text);
+            record && cursor.startRecording();
             const ast = this.parse(cursor);
             return {
                 ast: (ast === null || ast === void 0 ? void 0 : ast.value) === text ? ast : null,
@@ -1069,11 +1169,13 @@
                     min = Math.max(this._min, 1);
                 }
             }
-            return new FiniteRepeat(name, this._children[0], this._max, {
+            const clone = new FiniteRepeat(name, this._children[0], this._max, {
                 divider: this._hasDivider ? this._children[1] : undefined,
                 min,
                 trimDivider: this._trimDivider
             });
+            clone._id = this._id;
+            return clone;
         }
         getTokens() {
             return this._children[0].getTokens();
@@ -1121,9 +1223,16 @@
         find(predicate) {
             return findPattern(this, predicate);
         }
+        isEqual(pattern) {
+            return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
+        }
     }
 
+    let idIndex$3 = 0;
     class InfiniteRepeat {
+        get id() {
+            return this._id;
+        }
         get type() {
             return this._type;
         }
@@ -1156,6 +1265,7 @@
                 children = [pattern.clone(pattern.name, false)];
             }
             this._assignChildrenToParent(children);
+            this._id = `infinite-repeat-${idIndex$3++}`;
             this._type = "infinite-repeat";
             this._name = name;
             this._min = min;
@@ -1177,8 +1287,9 @@
             const ast = this.parse(cursor);
             return (ast === null || ast === void 0 ? void 0 : ast.value) === text;
         }
-        exec(text) {
+        exec(text, record = false) {
             const cursor = new Cursor(text);
+            record && cursor.startRecording();
             const ast = this.parse(cursor);
             return {
                 ast: (ast === null || ast === void 0 ? void 0 : ast.value) === text ? ast : null,
@@ -1186,6 +1297,7 @@
             };
         }
         parse(cursor) {
+            cursor.startParseWith(this);
             this._firstIndex = cursor.index;
             this._nodes = [];
             const passed = this._tryToParse(cursor);
@@ -1196,12 +1308,15 @@
                     cursor.moveTo(node.lastIndex);
                     cursor.recordMatch(this, node);
                 }
+                cursor.endParse();
                 return node;
             }
             if (this._min > 0) {
+                cursor.endParse();
                 return null;
             }
             cursor.resolveError();
+            cursor.endParse();
             return null;
         }
         _meetsMin() {
@@ -1355,15 +1470,24 @@
                     min = Math.max(this._min, 1);
                 }
             }
-            return new InfiniteRepeat(name, this._pattern, {
+            const clone = new InfiniteRepeat(name, this._pattern, {
                 divider: this._divider == null ? undefined : this._divider,
                 min: min,
                 trimDivider: this._trimDivider
             });
+            clone._id = this._id;
+            return clone;
+        }
+        isEqual(pattern) {
+            return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
         }
     }
 
+    let idIndex$2 = 0;
     class Repeat {
+        get id() {
+            return this._id;
+        }
         get type() {
             return this._repeatPattern.type;
         }
@@ -1383,6 +1507,7 @@
             return this._repeatPattern.isOptional;
         }
         constructor(name, pattern, options = {}) {
+            this._id = `repeat-${idIndex$2++}`;
             this._pattern = pattern;
             this._parent = null;
             this._options = Object.assign(Object.assign({}, options), { min: options.min == null ? 1 : options.min, max: options.max == null ? Infinity : options.max });
@@ -1414,7 +1539,9 @@
                     min = Math.max(this._options.min, 1);
                 }
             }
-            return new Repeat(name, this._pattern, Object.assign(Object.assign({}, this._options), { min }));
+            const clone = new Repeat(name, this._pattern, Object.assign(Object.assign({}, this._options), { min }));
+            clone._id = this._id;
+            return clone;
         }
         getTokens() {
             return this._repeatPattern.getTokens();
@@ -1449,6 +1576,9 @@
         find(predicate) {
             return this._repeatPattern.find(predicate);
         }
+        isEqual(pattern) {
+            return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
+        }
     }
 
     const comment = new Regex("comment", "#[^\r\n]+");
@@ -1463,7 +1593,11 @@
         return filteredNodes;
     }
 
+    let idIndex$1 = 0;
     class And {
+        get id() {
+            return this._id;
+        }
         get type() {
             return this._type;
         }
@@ -1488,6 +1622,7 @@
             }
             const children = clonePatterns(sequence);
             this._assignChildrenToParent(children);
+            this._id = `and-${idIndex$1++}`;
             this._type = "and";
             this._name = name;
             this._isOptional = isOptional;
@@ -1506,8 +1641,9 @@
             const ast = this.parse(cursor);
             return (ast === null || ast === void 0 ? void 0 : ast.value) === text;
         }
-        exec(text) {
+        exec(text, record = false) {
             const cursor = new Cursor(text);
+            record && cursor.startRecording();
             const ast = this.parse(cursor);
             return {
                 ast: (ast === null || ast === void 0 ? void 0 : ast.value) === text ? ast : null,
@@ -1515,6 +1651,7 @@
             };
         }
         parse(cursor) {
+            cursor.startParseWith(this);
             this._firstIndex = cursor.index;
             this._nodes = [];
             const passed = this.tryToParse(cursor);
@@ -1523,11 +1660,13 @@
                 if (node !== null) {
                     cursor.recordMatch(this, node);
                 }
+                cursor.endParse();
                 return node;
             }
             if (this._isOptional) {
                 cursor.resolveError();
             }
+            cursor.endParse();
             return null;
         }
         tryToParse(cursor) {
@@ -1686,7 +1825,12 @@
             return findPattern(this, predicate);
         }
         clone(name = this._name, isOptional = this._isOptional) {
-            return new And(name, this._children, isOptional);
+            const clone = new And(name, this._children, isOptional);
+            clone._id = this._id;
+            return clone;
+        }
+        isEqual(pattern) {
+            return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
         }
     }
 
@@ -1703,34 +1847,45 @@
 
     const name$1 = new Regex("name", "[a-zA-Z_-]+[a-zA-Z0-9_-]*");
 
-    const optionalNot = new Literal("not", "!", true);
-    const optionalIsOptional = new Literal("is-optional", "?", true);
-    const patternName$1 = name$1.clone("pattern-name");
-    const pattern = new And("pattern", [
-        optionalNot,
-        patternName$1,
-        optionalIsOptional,
-    ]);
-
-    const divider$1 = new Regex("and-divider", "\\s*[&]\\s*");
-    divider$1.setTokens([" & "]);
-    const andLiteral = new Repeat("and-literal", pattern, { divider: divider$1, min: 2, trimDivider: true });
+    const regexLiteral = new Regex("regex-literal", "/(\\\\/|[^/\\n\\r])*/");
 
-    const divider = new Regex("or-divider", "\\s*[|]\\s*");
-    divider.setTokens([" | "]);
-    const orLiteral = new Repeat("or-literal", name$1.clone("pattern-name"), { divider, min: 2, trimDivider: true });
+    const patternName$3 = name$1.clone("pattern-name");
+    const anonymousLiterals = new Or("anonymous-literals", [
+        literal,
+        regexLiteral,
+        patternName$3,
+        new Reference("repeat-literal"),
+    ]);
+    const anonymousWrappedLiterals = new Or("anonymous-wrapped-literals", [
+        new Reference("or-literal"),
+        new Reference("and-literal"),
+        new Reference("complex-anonymous-pattern")
+    ]);
 
-    const regexLiteral = new Regex("regex-literal", "/(\\\\/|[^/\\n\\r])*/");
+    const inlinePatternOpenParen = new Literal("anonymous-pattern-open-paren", "(");
+    const inlinePatternCloseParen = new Literal("anonymous-pattern-close-paren", ")");
+    const optionalLineSpaces$1 = lineSpaces$1.clone(undefined, true);
+    const complexAnonymousPattern = new And("complex-anonymous-pattern", [
+        inlinePatternOpenParen,
+        optionalLineSpaces$1,
+        anonymousWrappedLiterals,
+        optionalLineSpaces$1,
+        inlinePatternCloseParen,
+    ]);
+    const anonymousPattern = new Or("anonymous-pattern", [
+        anonymousLiterals,
+        complexAnonymousPattern
+    ]);
 
-    const patternName = name$1.clone("pattern-name");
     const optionalSpaces$2 = spaces$1.clone("optional-spaces", true);
-    const dividerPattern = name$1.clone("divider-pattern");
     const openBracket$1 = new Literal("open-bracket", "{");
     const closeBracket$1 = new Literal("close-bracket", "}");
     const comma = new Literal("comma", ",");
     const integer = new Regex("integer", "([1-9][0-9]*)|0");
     integer.setTokens(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]);
     const optionalInteger = integer.clone("integer", true);
+    const trimKeyword = new Literal("trim-keyword", "trim", true);
+    const trimFlag = new And("trim-flag", [lineSpaces$1, trimKeyword], true);
     const bounds = new And("bounds", [
         openBracket$1,
         optionalSpaces$2,
@@ -1739,7 +1894,6 @@
         comma,
         optionalSpaces$2,
         optionalInteger.clone("max"),
-        optionalSpaces$2,
         closeBracket$1
     ]);
     const exactCount = new And("exact-count", [
@@ -1756,41 +1910,67 @@
         exactCount,
         bounds
     ]);
-    const optional = new Literal("is-optional", "?", true);
-    const trimDivider = new Literal("trim-divider", "-t");
-    const openParen = new Literal("open-paren", "(");
-    const closeParen = new Literal("close-paren", ")");
+    const openParen = new Literal("repeat-open-paren", "(");
+    const closeParen = new Literal("repeat-close-paren", ")");
     const dividerComma = new Regex("divider-comma", "\\s*,\\s*");
     dividerComma.setTokens([", "]);
+    const patternName$2 = name$1.clone("pattern-name");
+    const patterns$3 = new Or("or-patterns", [patternName$2, anonymousPattern]);
+    const dividerPattern = patterns$3.clone("divider-pattern");
     const repeatLiteral = new And("repeat-literal", [
         openParen,
         optionalSpaces$2,
-        patternName,
-        optional,
-        new And("optional-divider-section", [dividerComma, dividerPattern], true),
+        patterns$3,
+        new And("optional-divider-section", [dividerComma, dividerPattern, trimFlag], true),
         optionalSpaces$2,
         closeParen,
-        new And("quantifier-section", [optionalSpaces$2, quantifier]),
-        new And("optional-trim-divider-section", [spaces$1, trimDivider], true)
+        new And("quantifier-section", [quantifier]),
     ]);
 
-    const optionalSpaces$1 = spaces$1.clone("optional-spaces", true);
-    const assignOperator = new Literal("assign-operator", "=");
-    const statements = new Or("statements", [
+    const optionalNot = new Literal("not", "!", true);
+    const optionalIsOptional$1 = new Literal("is-optional", "?", true);
+    const patternName$1 = name$1.clone("pattern-name");
+    const patterns$2 = new Or("and-patterns", [patternName$1, anonymousPattern]);
+    const pattern$1 = new And("and-child-pattern", [
+        optionalNot,
+        patterns$2,
+        optionalIsOptional$1,
+    ]);
+    const divider$1 = new Regex("and-divider", "\\s*[+]\\s*");
+    divider$1.setTokens([" + "]);
+    const andLiteral = new Repeat("and-literal", pattern$1, { divider: divider$1, min: 2, trimDivider: true });
+
+    const patternName = name$1.clone("pattern-name");
+    const patterns$1 = new Or("or-patterns", [patternName, anonymousPattern]);
+    const defaultDivider = new Regex("default-divider", "\\s*[|]\\s*");
+    const greedyDivider = new Regex("greedy-divider", "\\s*[<][|][>]\\s*");
+    const divider = new Or("or-divider", [defaultDivider, greedyDivider]);
+    defaultDivider.setTokens([" | "]);
+    greedyDivider.setTokens([" <|> "]);
+    const orLiteral = new Repeat("or-literal", patterns$1, { divider, min: 2, trimDivider: true });
+
+    const aliasLiteral = name$1.clone("alias-literal");
+    const optionalIsOptional = new Literal("is-optional", "?", true);
+    const configurableAnonymousPattern = new And("configurable-anonymous-pattern", [anonymousPattern, optionalIsOptional]);
+    const pattern = new Or("pattern", [
         literal,
         regexLiteral,
+        repeatLiteral,
+        aliasLiteral,
         orLiteral,
         andLiteral,
-        repeatLiteral,
-        name$1.clone("alias-literal"),
-    ]);
+        configurableAnonymousPattern,
+    ], false, true);
+
+    const optionalSpaces$1 = spaces$1.clone("optional-spaces", true);
+    const assignOperator = new Literal("assign-operator", "=");
     const assignStatement = new And("assign-statement", [
         optionalSpaces$1,
         name$1,
         optionalSpaces$1,
         assignOperator,
         optionalSpaces$1,
-        statements
+        pattern
     ]);
     const statement = new Or("statement", [assignStatement, name$1.clone("export-name")]);
 
@@ -1885,7 +2065,11 @@
         allSpaces
     ]);
 
+    let idIndex = 0;
     class Not {
+        get id() {
+            return this._id;
+        }
         get type() {
             return this._type;
         }
@@ -1905,6 +2089,7 @@
             return false;
         }
         constructor(name, pattern) {
+            this._id = `not-${idIndex++}`;
             this._type = "not";
             this._name = name;
             this._parent = null;
@@ -1916,15 +2101,17 @@
             this.parse(cursor);
             return !cursor.hasError;
         }
-        exec(text) {
+        exec(text, record = false) {
             const cursor = new Cursor(text);
+            record && cursor.startRecording();
             const ast = this.parse(cursor);
             return {
-                ast,
+                ast: (ast === null || ast === void 0 ? void 0 : ast.value) === text ? ast : null,
                 cursor
             };
         }
         parse(cursor) {
+            cursor.startParseWith(this);
             const firstIndex = cursor.index;
             this._children[0].parse(cursor);
             if (cursor.hasError) {
@@ -1936,10 +2123,12 @@
                 cursor.resolveError();
                 cursor.recordErrorAt(firstIndex, firstIndex, this);
             }
+            cursor.endParse();
             return null;
         }
         clone(name = this._name) {
             const not = new Not(name, this._children[0]);
+            not._id = this._id;
             return not;
         }
         getTokens() {
@@ -1981,6 +2170,9 @@
         find(predicate) {
             return predicate(this._children[0]) ? this._children[0] : null;
         }
+        isEqual(pattern) {
+            return pattern.type === this.type && this.children.every((c, index) => c.isEqual(pattern.children[index]));
+        }
     }
 
     const defaultOptions = { greedyPatternNames: [], customTokens: {} };
@@ -2185,6 +2377,16 @@
         return furthestOptions;
     }
 
+    let anonymousIndexId = 0;
+    const patternNodes = {
+        "literal": true,
+        "regex-literal": true,
+        "or-literal": true,
+        "and-literal": true,
+        "repeat-literal": true,
+        "alias-literal": true,
+        "configurable-anonymous-pattern": true
+    };
     class ParseContext {
         constructor(params) {
             this.patternsByName = new Map();
@@ -2229,7 +2431,7 @@
                 const ast = this._tryToParse(expression);
                 yield this._resolveImports(ast);
                 this._buildPatterns(ast);
-                return this._parseContext.patternsByName;
+                return Object.fromEntries(this._parseContext.patternsByName);
             });
         }
         parseString(expression) {
@@ -2239,7 +2441,7 @@
                 throw new Error("Cannot use imports on parseString, use parse instead.");
             }
             this._buildPatterns(ast);
-            return this._parseContext.patternsByName;
+            return Object.fromEntries(this._parseContext.patternsByName);
         }
         _tryToParse(expression) {
             const { ast, cursor, options, isComplete } = this._autoComplete.suggestFor(expression);
@@ -2269,41 +2471,207 @@
             if (body == null) {
                 return;
             }
-            body.findAll(n => n.name === "assign-statement" || n.name === "export-name").forEach((n) => {
-                const typeNode = n.find(n => n.name.includes("literal"));
-                const type = n.name === "export-name" ? "export-name" : (typeNode === null || typeNode === void 0 ? void 0 : typeNode.name) || "unknown";
-                switch (type) {
+            body.findAll(n => n.name === "assign-statement").forEach((n) => {
+                const patternNode = n.children.find(n => patternNodes[n.name] != null);
+                if (patternNode == null) {
+                    return;
+                }
+                switch (patternNode.name) {
                     case "literal": {
-                        this._buildLiteral(n);
+                        this._saveLiteral(n);
                         break;
                     }
                     case "regex-literal": {
-                        this._buildRegex(n);
+                        this._saveRegex(n);
                         break;
                     }
                     case "or-literal": {
-                        this._buildOr(n);
+                        this._saveOr(n);
                         break;
                     }
                     case "and-literal": {
-                        this._buildAnd(n);
+                        this._saveAnd(n);
                         break;
                     }
                     case "repeat-literal": {
-                        this._buildRepeat(n);
+                        this._saveRepeat(n);
                         break;
                     }
                     case "alias-literal": {
-                        this._buildAlias(n);
+                        this._saveAlias(n);
                         break;
                     }
-                    case "export-name": {
-                        const pattern = this._getPattern(n.value);
-                        this._parseContext.patternsByName.set(n.value, pattern);
+                    case "configurable-anonymous-pattern": {
+                        this._saveConfigurableAnonymous(n);
                         break;
                     }
                 }
             });
+            body.findAll(n => n.name === "export-name").forEach((n) => {
+                const pattern = this._getPattern(n.value).clone();
+                this._parseContext.patternsByName.set(n.value, pattern);
+            });
+        }
+        _saveLiteral(statementNode) {
+            const nameNode = statementNode.find(n => n.name === "name");
+            const literalNode = statementNode.find(n => n.name === "literal");
+            const name = nameNode.value;
+            const literal = this._buildLiteral(name, literalNode);
+            this._parseContext.patternsByName.set(name, literal);
+        }
+        _buildLiteral(name, node) {
+            return new Literal(name, this._resolveStringValue(node.value));
+        }
+        _resolveStringValue(value) {
+            return value.replace(/\\n/g, '\n')
+                .replace(/\\r/g, '\r')
+                .replace(/\\t/g, '\t')
+                .replace(/\\b/g, '\b')
+                .replace(/\\f/g, '\f')
+                .replace(/\\v/g, '\v')
+                .replace(/\\0/g, '\0')
+                .replace(/\\x([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
+                .replace(/\\u([0-9A-Fa-f]{4})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
+                .replace(/\\(.)/g, '$1').slice(1, -1);
+        }
+        _saveRegex(statementNode) {
+            const nameNode = statementNode.find(n => n.name === "name");
+            const regexNode = statementNode.find(n => n.name === "regex-literal");
+            const name = nameNode.value;
+            const regex = this._buildRegex(name, regexNode);
+            this._parseContext.patternsByName.set(name, regex);
+        }
+        _buildRegex(name, node) {
+            const value = node.value.slice(1, node.value.length - 1);
+            return new Regex(name, value);
+        }
+        _saveOr(statementNode) {
+            const nameNode = statementNode.find(n => n.name === "name");
+            const name = nameNode.value;
+            const orNode = statementNode.find(n => n.name === "or-literal");
+            const or = this._buildOr(name, orNode);
+            this._parseContext.patternsByName.set(name, or);
+        }
+        _buildOr(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 or = new Or(name, patterns, false, isGreedy);
+            return or;
+        }
+        _buildPattern(node) {
+            const type = node.name;
+            const name = `anonymous-pattern-${anonymousIndexId++}`;
+            switch (type) {
+                case "pattern-name": {
+                    return this._getPattern(node.value).clone();
+                }
+                case "literal": {
+                    return this._buildLiteral(node.value.slice(1, -1), node);
+                }
+                case "regex-literal": {
+                    return this._buildRegex(node.value.slice(1, -1), node);
+                }
+                case "repeat-literal": {
+                    return this._buildRepeat(name, node);
+                }
+                case "or-literal": {
+                    return this._buildOr(name, node);
+                }
+                case "and-literal": {
+                    return this._buildAnd(name, node);
+                }
+                case "complex-anonymous-pattern": {
+                    return this._buildComplexAnonymousPattern(node);
+                }
+            }
+            throw new Error(`Couldn't build node: ${node.name}.`);
+        }
+        _saveAnd(statementNode) {
+            const nameNode = statementNode.find(n => n.name === "name");
+            const name = nameNode.value;
+            const andNode = statementNode.find(n => n.name === "and-literal");
+            const and = this._buildAnd(name, andNode);
+            this._parseContext.patternsByName.set(name, and);
+        }
+        _buildAnd(name, node) {
+            const patternNodes = node.children.filter(n => n.name !== "and-divider");
+            const patterns = patternNodes.map(n => {
+                const patternNode = n.children[0].name === "not" ? n.children[1] : n.children[0];
+                const isNot = n.find(n => n.name === "not") != null;
+                const isOptional = n.find(n => n.name === "is-optional");
+                const pattern = this._buildPattern(patternNode).clone(undefined, isOptional == null ? undefined : true);
+                if (isNot) {
+                    return new Not(`not-${pattern.name}`, pattern);
+                }
+                return pattern;
+            });
+            return new And(name, patterns);
+        }
+        _saveRepeat(statementNode) {
+            const nameNode = statementNode.find(n => n.name === "name");
+            const name = nameNode.value;
+            const repeatNode = statementNode.find(n => n.name === "repeat-literal");
+            const repeat = this._buildRepeat(name, repeatNode);
+            this._parseContext.patternsByName.set(name, repeat);
+        }
+        _buildRepeat(name, repeatNode) {
+            const bounds = repeatNode.find(n => n.name === "bounds");
+            const exactCount = repeatNode.find(n => n.name === "exact-count");
+            const quantifier = repeatNode.find(n => n.name === "quantifier-shorthand");
+            const trimDivider = repeatNode.find(n => n.name === "trim-flag") != null;
+            const patterNode = repeatNode.children[1].type === "optional-spaces" ? repeatNode.children[2] : repeatNode.children[1];
+            const pattern = this._buildPattern(patterNode);
+            const dividerSectionNode = repeatNode.find(n => n.name === "optional-divider-section");
+            const options = {
+                min: 1,
+                max: Infinity
+            };
+            if (trimDivider) {
+                options.trimDivider = trimDivider;
+            }
+            if (dividerSectionNode != null) {
+                const dividerNode = dividerSectionNode.children[1];
+                options.divider = this._buildPattern(dividerNode);
+            }
+            if (bounds != null) {
+                const minNode = bounds.find(p => p.name === "min");
+                const maxNode = bounds.find(p => p.name === "max");
+                const min = minNode == null ? 0 : Number(minNode.value);
+                const max = maxNode == null ? Infinity : Number(maxNode.value);
+                options.min = min;
+                options.max = max;
+            }
+            else if (exactCount != null) {
+                const integerNode = exactCount.find(p => p.name === "integer");
+                const integer = Number(integerNode.value);
+                options.min = integer;
+                options.max = integer;
+            }
+            else if (quantifier != null) {
+                const type = quantifier.value;
+                if (type === "+") {
+                    options.min = 1;
+                    options.max = Infinity;
+                }
+                else {
+                    options.min = 0;
+                    options.max = Infinity;
+                }
+            }
+            return new Repeat(name, pattern.clone(pattern.name), options);
+        }
+        _saveConfigurableAnonymous(node) {
+            const nameNode = node.find(n => n.name === "name");
+            const name = nameNode.value;
+            const anonymousNode = node.find(n => n.name === "complex-anonymous-pattern");
+            const isOptional = node.children[1] != null;
+            const anonymous = this._buildPattern(anonymousNode).clone(name, isOptional);
+            this._parseContext.patternsByName.set(name, anonymous);
+        }
+        _buildComplexAnonymousPattern(node) {
+            const wrappedNode = node.children[1].name === "line-spaces" ? node.children[2] : node.children[1];
+            return this._buildPattern(wrappedNode);
         }
         _resolveImports(ast) {
             return __awaiter(this, void 0, void 0, function* () {
@@ -2332,7 +2700,7 @@
                                 if (parseContext.importedPatternsByName.has(importName)) {
                                     throw new Error(`'${importName}' was already used within another import.`);
                                 }
-                                const pattern = patterns.get(importName);
+                                const pattern = patterns[importName];
                                 if (pattern == null) {
                                     throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
                                 }
@@ -2346,7 +2714,7 @@
                                 if (parseContext.importedPatternsByName.has(alias)) {
                                     throw new Error(`'${alias}' was already used within another import.`);
                                 }
-                                const pattern = patterns.get(importName);
+                                const pattern = patterns[importName];
                                 if (pattern == null) {
                                     throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
                                 }
@@ -2377,48 +2745,11 @@
                         resolveImport: this._resolveImport
                     });
                     const patterns = grammar.parseString(expression);
-                    params = Array.from(patterns.values());
+                    params = Array.from(Object.values(patterns));
                 }
             }
             return params;
         }
-        _buildLiteral(statementNode) {
-            const nameNode = statementNode.find(n => n.name === "name");
-            const literalNode = statementNode.find(n => n.name === "literal");
-            const name = nameNode.value;
-            const value = this._resolveStringValue(literalNode.value.slice(1, -1));
-            const literal = new Literal(name, value);
-            this._parseContext.patternsByName.set(name, literal);
-        }
-        _resolveStringValue(value) {
-            return value.replace(/\\n/g, '\n')
-                .replace(/\\r/g, '\r')
-                .replace(/\\t/g, '\t')
-                .replace(/\\b/g, '\b')
-                .replace(/\\f/g, '\f')
-                .replace(/\\v/g, '\v')
-                .replace(/\\0/g, '\0')
-                .replace(/\\x([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
-                .replace(/\\u([0-9A-Fa-f]{4})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
-                .replace(/\\(.)/g, '$1');
-        }
-        _buildRegex(statementNode) {
-            const nameNode = statementNode.find(n => n.name === "name");
-            const regexNode = statementNode.find(n => n.name === "regex-literal");
-            const value = regexNode.value.slice(1, regexNode.value.length - 1);
-            const name = nameNode.value;
-            const regex = new Regex(name, value);
-            this._parseContext.patternsByName.set(name, regex);
-        }
-        _buildOr(statementNode) {
-            const nameNode = statementNode.find(n => n.name === "name");
-            const orNode = statementNode.find(n => n.name === "or-literal");
-            const patternNodes = orNode.children.filter(n => n.name === "pattern-name");
-            const name = nameNode.value;
-            const patterns = patternNodes.map(n => this._getPattern(n.value));
-            const or = new Or(name, patterns, false, true);
-            this._parseContext.patternsByName.set(name, or);
-        }
         _getPattern(name) {
             let pattern = this._parseContext.patternsByName.get(name);
             if (pattern == null) {
@@ -2432,82 +2763,12 @@
             }
             return pattern;
         }
-        _buildAnd(statementNode) {
-            const nameNode = statementNode.find(n => n.name === "name");
-            const andNode = statementNode.find(n => n.name === "and-literal");
-            const patternNodes = andNode.children.filter(n => n.name === "pattern");
-            const name = nameNode.value;
-            const patterns = patternNodes.map(n => {
-                const nameNode = n.find(n => n.name === "pattern-name");
-                const isNot = n.find(n => n.name === "not") != null;
-                const isOptional = n.find(n => n.name === "is-optional") != null;
-                const name = nameNode.value;
-                const pattern = this._getPattern(name);
-                if (isNot) {
-                    return new Not(`not-${name}`, pattern.clone(name, isOptional));
-                }
-                return pattern.clone(name, isOptional);
-            });
-            const and = new And(name, patterns);
-            this._parseContext.patternsByName.set(name, and);
-        }
-        _buildRepeat(statementNode) {
-            const nameNode = statementNode.find(n => n.name === "name");
-            const repeatNode = statementNode.find(n => n.name === "repeat-literal");
-            const patternNameNode = statementNode.find(n => n.name === "pattern-name");
-            const dividerNode = repeatNode.find(n => n.name === "divider-pattern");
-            const bounds = repeatNode.find(n => n.name === "bounds");
-            const exactCount = repeatNode.find(n => n.name === "exact-count");
-            const quantifier = repeatNode.find(n => n.name === "quantifier-shorthand");
-            const isPatternOptional = repeatNode.find(n => n.name === "is-optional") != null;
-            const trimDivider = repeatNode.find(n => n.name === "trim-divider") != null;
-            const name = nameNode.value;
-            const pattern = this._getPattern(patternNameNode.value);
-            const options = {
-                min: 1,
-                max: Infinity
-            };
-            if (trimDivider) {
-                options.trimDivider = trimDivider;
-            }
-            if (dividerNode != null) {
-                options.divider = this._getPattern(dividerNode.value);
-            }
-            if (bounds != null) {
-                const minNode = bounds.find(p => p.name === "min");
-                const maxNode = bounds.find(p => p.name === "max");
-                const min = minNode == null ? 0 : Number(minNode.value);
-                const max = maxNode == null ? Infinity : Number(maxNode.value);
-                options.min = min;
-                options.max = max;
-            }
-            else if (exactCount != null) {
-                const integerNode = exactCount.find(p => p.name === "integer");
-                const integer = Number(integerNode.value);
-                options.min = integer;
-                options.max = integer;
-            }
-            else if (quantifier != null) {
-                const type = quantifier.value;
-                if (type === "+") {
-                    options.min = 1;
-                    options.max = Infinity;
-                }
-                else {
-                    options.min = 0;
-                    options.max = Infinity;
-                }
-            }
-            const repeat = new Repeat(name, pattern.clone(pattern.name, isPatternOptional), options);
-            this._parseContext.patternsByName.set(name, repeat);
-        }
-        _buildAlias(statementNode) {
+        _saveAlias(statementNode) {
             const nameNode = statementNode.find(n => n.name === "name");
             const aliasNode = statementNode.find(n => n.name === "alias-literal");
             const aliasName = aliasNode.value;
             const name = nameNode.value;
-            const pattern = this._getPattern(aliasName);
-            const alias = pattern.clone(name);
+            const alias = this._getPattern(aliasName).clone(name);
             this._parseContext.patternsByName.set(name, alias);
         }
         static parse(expression, options) {
@@ -2524,6 +2785,30 @@
         }
     }
 
+    function arePatternsEqual(a, b) {
+        if (a === b) {
+            return true;
+        }
+        else if (a == null || b == null) {
+            return false;
+        }
+        return a.isEqual(b);
+    }
+
+    const kebabRegex = /-([a-z])/g; // Define the regex once
+    function kebabToCamelCase(str) {
+        return str.replace(kebabRegex, (_, char) => char.toUpperCase());
+    }
+    function patterns(strings, ...values) {
+        const combinedString = strings.reduce((result, str, i) => result + str + (values[i] || ''), '');
+        const result = {};
+        const patterns = Grammar.parseString(combinedString);
+        Object.keys(patterns).forEach(k => {
+            result[kebabToCamelCase(k)] = patterns[k];
+        });
+        return result;
+    }
+
     exports.And = And;
     exports.AutoComplete = AutoComplete;
     exports.Cursor = Cursor;
@@ -2537,7 +2822,9 @@
     exports.Reference = Reference;
     exports.Regex = Regex;
     exports.Repeat = Repeat;
+    exports.arePatternsEqual = arePatternsEqual;
     exports.grammar = grammar;
+    exports.patterns = patterns;
 
     Object.defineProperty(exports, '__esModule', { value: true });