clarity-pattern-parser 8.4.15 → 9.0.0

package/dist/index.esm.js

@@ -243,6 +243,7 @@ class CursorHistory {
         this._patterns = [];
         this._nodes = [];
         this._errors = [];
+        this._trace = [];
     }
     get isRecording() {
         return this._isRecording;
@@ -271,6 +272,9 @@ class CursorHistory {
     get patterns() {
         return this._patterns;
     }
+    get trace() {
+        return this._trace;
+    }
     recordMatch(pattern, node) {
         if (this._isRecording) {
             this._patterns.push(pattern);
@@ -325,6 +329,11 @@ class CursorHistory {
     resolveError() {
         this._currentError = null;
     }
+    pushStackTrace(trace) {
+        if (this._isRecording) {
+            this._trace.push(trace);
+        }
+    }
 }
 
 class Cursor {
@@ -381,6 +390,7 @@ class Cursor {
         this._index = 0;
         this._length = text.length;
         this._history = new CursorHistory();
+        this._stackTrace = [];
     }
     hasNext() {
         return this._index + 1 < this._length;
@@ -430,9 +440,42 @@ class Cursor {
     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;
     }
@@ -455,9 +498,10 @@ class Literal {
         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;
@@ -470,8 +514,9 @@ class Literal {
         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,
@@ -479,20 +524,24 @@ class Literal {
         };
     }
     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) {
@@ -506,7 +555,7 @@ class Literal {
                 break;
             }
             if (i + 1 === literalRuneLength) {
-                this._lastIndex = this._firstIndex + this._literal.length - 1;
+                this._lastIndex = this._firstIndex + this._text.length - 1;
                 passed = true;
                 break;
             }
@@ -519,14 +568,15 @@ class Literal {
         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 [];
@@ -552,9 +602,16 @@ class Literal {
     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;
     }
@@ -579,6 +636,7 @@ class Regex {
         this._firstIndex = -1;
         this._substring = "";
         this._tokens = [];
+        this._id = `regex-${idIndex$7++}`;
         this._type = "regex";
         this._name = name;
         this._isOptional = isOptional;
@@ -603,8 +661,9 @@ class Regex {
         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,
@@ -612,9 +671,11 @@ class Regex {
         };
     }
     parse(cursor) {
+        cursor.startParseWith(this);
         this._firstIndex = cursor.index;
         this.resetState(cursor);
         this.tryToParse(cursor);
+        cursor.endParse();
         return this._node;
     }
     resetState(cursor) {
@@ -646,9 +707,10 @@ class Regex {
         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;
@@ -680,6 +742,9 @@ class Regex {
     setTokens(tokens) {
         this._tokens = tokens;
     }
+    isEqual(pattern) {
+        return pattern.type === this.type && pattern._originalRegexString === this._originalRegexString;
+    }
 }
 
 function findPattern(pattern, predicate) {
@@ -704,7 +769,11 @@ function findPattern(pattern, predicate) {
     }
 }
 
+let idIndex$6 = 0;
 class Reference {
+    get id() {
+        return this._id;
+    }
     get type() {
         return this._type;
     }
@@ -724,6 +793,7 @@ class Reference {
         return this._isOptional;
     }
     constructor(name, isOptional = false) {
+        this._id = `reference-${idIndex$6++}`;
         this._type = "reference";
         this._name = name;
         this._parent = null;
@@ -736,8 +806,9 @@ class Reference {
         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,
@@ -813,7 +884,12 @@ class Reference {
         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;
     }
 }
 
@@ -821,7 +897,11 @@ function clonePatterns(patterns, isOptional) {
     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;
     }
@@ -846,6 +926,7 @@ class Or {
         }
         const children = clonePatterns(options, false);
         this._assignChildrenToParent(children);
+        this._id = `or-${idIndex$5++}`;
         this._type = "or";
         this._name = name;
         this._parent = null;
@@ -864,8 +945,9 @@ class Or {
         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,
@@ -873,19 +955,23 @@ class Or {
         };
     }
     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) {
@@ -948,11 +1034,19 @@ class Or {
     }
     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;
     }
@@ -978,6 +1072,7 @@ class FiniteRepeat {
         return this._max;
     }
     constructor(name, pattern, repeatAmount, options = {}) {
+        this._id = `finite-repeat-${idIndex$4++}`;
         this._type = "finite-repeat";
         this._name = name;
         this._parent = null;
@@ -994,6 +1089,7 @@ class FiniteRepeat {
         }
     }
     parse(cursor) {
+        cursor.startParseWith(this);
         const startIndex = cursor.index;
         const nodes = [];
         const modulo = this._hasDivider ? 2 : 1;
@@ -1028,16 +1124,19 @@ class FiniteRepeat {
             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) {
@@ -1045,8 +1144,9 @@ class FiniteRepeat {
         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,
@@ -1063,11 +1163,13 @@ class FiniteRepeat {
                 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();
@@ -1115,9 +1217,16 @@ class FiniteRepeat {
     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;
     }
@@ -1150,6 +1259,7 @@ class InfiniteRepeat {
             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;
@@ -1171,8 +1281,9 @@ class InfiniteRepeat {
         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,
@@ -1180,6 +1291,7 @@ class InfiniteRepeat {
         };
     }
     parse(cursor) {
+        cursor.startParseWith(this);
         this._firstIndex = cursor.index;
         this._nodes = [];
         const passed = this._tryToParse(cursor);
@@ -1190,12 +1302,15 @@ class InfiniteRepeat {
                 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() {
@@ -1349,15 +1464,24 @@ class InfiniteRepeat {
                 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;
     }
@@ -1377,6 +1501,7 @@ class Repeat {
         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 });
@@ -1408,7 +1533,9 @@ class Repeat {
                 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();
@@ -1443,6 +1570,9 @@ class Repeat {
     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]+");
@@ -1457,7 +1587,11 @@ function filterOutNull(nodes) {
     return filteredNodes;
 }
 
+let idIndex$1 = 0;
 class And {
+    get id() {
+        return this._id;
+    }
     get type() {
         return this._type;
     }
@@ -1482,6 +1616,7 @@ class And {
         }
         const children = clonePatterns(sequence);
         this._assignChildrenToParent(children);
+        this._id = `and-${idIndex$1++}`;
         this._type = "and";
         this._name = name;
         this._isOptional = isOptional;
@@ -1500,8 +1635,9 @@ class And {
         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,
@@ -1509,6 +1645,7 @@ class And {
         };
     }
     parse(cursor) {
+        cursor.startParseWith(this);
         this._firstIndex = cursor.index;
         this._nodes = [];
         const passed = this.tryToParse(cursor);
@@ -1517,11 +1654,13 @@ class And {
             if (node !== null) {
                 cursor.recordMatch(this, node);
             }
+            cursor.endParse();
             return node;
         }
         if (this._isOptional) {
             cursor.resolveError();
         }
+        cursor.endParse();
         return null;
     }
     tryToParse(cursor) {
@@ -1680,7 +1819,12 @@ class And {
         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]));
     }
 }
 
@@ -1697,34 +1841,45 @@ const allSpaces = new Regex("all-spaces", "\\s+", true);
 
 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,
@@ -1733,7 +1888,6 @@ const bounds = new And("bounds", [
     comma,
     optionalSpaces$2,
     optionalInteger.clone("max"),
-    optionalSpaces$2,
     closeBracket$1
 ]);
 const exactCount = new And("exact-count", [
@@ -1750,41 +1904,67 @@ const quantifier = new Or("quantifier", [
     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")]);
 
@@ -1879,7 +2059,11 @@ const grammar = new And("grammar", [
     allSpaces
 ]);
 
+let idIndex = 0;
 class Not {
+    get id() {
+        return this._id;
+    }
     get type() {
         return this._type;
     }
@@ -1899,6 +2083,7 @@ class Not {
         return false;
     }
     constructor(name, pattern) {
+        this._id = `not-${idIndex++}`;
         this._type = "not";
         this._name = name;
         this._parent = null;
@@ -1910,15 +2095,17 @@ class Not {
         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) {
@@ -1930,10 +2117,12 @@ class Not {
             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() {
@@ -1975,6 +2164,9 @@ class Not {
     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: {} };
@@ -2179,6 +2371,16 @@ function getFurthestOptions(options) {
     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();
@@ -2223,7 +2425,7 @@ class Grammar {
             const ast = this._tryToParse(expression);
             yield this._resolveImports(ast);
             this._buildPatterns(ast);
-            return this._parseContext.patternsByName;
+            return Object.fromEntries(this._parseContext.patternsByName);
         });
     }
     parseString(expression) {
@@ -2233,7 +2435,7 @@ class Grammar {
             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);
@@ -2263,41 +2465,207 @@ class Grammar {
         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* () {
@@ -2326,7 +2694,7 @@ class Grammar {
                             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}.`);
                             }
@@ -2340,7 +2708,7 @@ class Grammar {
                             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}.`);
                             }
@@ -2371,48 +2739,11 @@ class Grammar {
                     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) {
@@ -2426,82 +2757,12 @@ class Grammar {
         }
         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) {
@@ -2518,5 +2779,29 @@ class Grammar {
     }
 }
 
-export { And, AutoComplete, Cursor, CursorHistory, Grammar, Literal, Node, Not, Or, ParseError, Reference, Regex, Repeat, grammar };
+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;
+}
+
+export { And, AutoComplete, Cursor, CursorHistory, Grammar, Literal, Node, Not, Or, ParseError, Reference, Regex, Repeat, arePatternsEqual, grammar, patterns };
 //# sourceMappingURL=index.esm.js.map