clarity-pattern-parser 11.5.4 → 11.6.0

package/src/grammar/Grammar.ts

@@ -1,85 +1,96 @@
 import { Node } from "../ast/Node";
+import { tokens } from "./decorators/tokens";
+import { generateErrorMessage } from "../patterns/generate_error_message";
+
+export interface GrammarFile {
+    resource: string;
+    expression: string;
+}
+import { Context } from "../patterns/Context";
+import { Expression } from "../patterns/Expression";
 import { Literal } from "../patterns/Literal";
+import { Not } from "../patterns/Not";
+import { Optional } from "../patterns/Optional";
+import { Options } from "../patterns/Options";
 import { Pattern } from "../patterns/Pattern";
-import { Regex } from "../patterns/Regex";
 import { Reference } from "../patterns/Reference";
-import { grammar } from "./patterns/grammar";
-import { Options } from "../patterns/Options";
-import { Not } from "../patterns/Not";
-import { Sequence } from "../patterns/Sequence";
+import { Regex } from "../patterns/Regex";
 import { Repeat, RepeatOptions } from "../patterns/Repeat";
-import { Optional } from "../patterns/Optional";
-import { Context } from "../patterns/Context";
-import { Expression } from "../patterns/Expression";
-import { TakeUntil } from "../patterns/TakeUntil";
 import { RightAssociated } from "../patterns/RightAssociated";
-import { generateErrorMessage } from "../patterns/generate_error_message";
-import { tokens } from "./decorators/tokens";
+import { Sequence } from "../patterns/Sequence";
+import { TakeUntil } from "../patterns/TakeUntil";
+import { grammar } from "./patterns/grammar"
 
 let anonymousIndexId = 0;
 
+function defaultImportResolver(_path: string, _basePath: string | null): Promise<GrammarFile> {
+    throw new Error("No import resolver supplied.");
+}
+
+function defaultImportResolverSync(_path: string, _basePath: string | null): GrammarFile {
+    throw new Error("No import resolver supplied.");
+}
+
 export type Decorator = (pattern: Pattern, arg?: string | boolean | number | null | Record<string, any> | any[]) => void;
 
-const defaultDecorators = {
+const defaultDecorators: Record<string, Decorator> = {
     tokens: tokens
 };
 
-const patternNodes: Record<string, boolean> = {
-    "literal": true,
-    "regex-literal": true,
-    "options-literal": true,
-    "sequence-literal": true,
-    "repeat-literal": true,
-    "alias-literal": true,
-    "take-until-literal": true,
-    "configurable-anonymous-pattern": true
+// Node names that are operators/whitespace and should be filtered during building
+const skipNodes: Record<string, boolean> = {
+    "+": true,
+    "|": true,
+    "<|>": true,
+    "optionalWS": true,
+    "optionalLS": true,
+    "ws": true,
+    "ls": true,
 };
 
+export interface GrammarOptions {
+    resolveImport?: (resource: string, originResource: string | null) => Promise<GrammarFile>;
+    resolveImportSync?: (resource: string, originResource: string | null) => GrammarFile;
+    originResource?: string | null;
+    params?: Pattern[];
+    decorators?: Record<string, Decorator>;
+}
+
 class ParseContext {
     patternsByName = new Map<string, Pattern>();
     importedPatternsByName = new Map<string, Pattern>();
     paramsByName = new Map<string, Pattern>();
     decorators: Record<string, Decorator>;
+
     constructor(params: Pattern[], decorators: Record<string, Decorator> = {}) {
         params.forEach(p => this.paramsByName.set(p.name, p));
         this.decorators = { ...decorators, ...defaultDecorators };
     }
-}
-
-function defaultImportResolver(_path: string, _basePath: string | null): Promise<GrammarFile> {
-    throw new Error("No import resolver supplied.");
-}
-
-function defaultImportResolverSync(_path: string, _basePath: string | null): GrammarFile {
-    throw new Error("No import resolver supplied.");
-}
 
-export interface GrammarFile {
-    resource: string;
-    expression: string;
-}
+    getImportedPatterns() {
+        return Array.from(this.importedPatternsByName.values());
+    }
 
-export interface GrammarOptions {
-    resolveImport?: (resource: string, originResource: string | null) => Promise<GrammarFile>;
-    resolveImportSync?: (resource: string, originResource: string | null) => GrammarFile;
-    originResource?: string | null;
-    params?: Pattern[];
-    decorators?: Record<string, Decorator>;
+    getParams() {
+        return Array.from(this.paramsByName.values());
+    }
 }
 
 export class Grammar {
+    private _options: GrammarOptions;
+    private _parseContext: ParseContext;
     private _params: Pattern[];
     private _originResource?: string | null;
     private _resolveImport: (resource: string, originResource: string | null) => Promise<GrammarFile>;
     private _resolveImportSync: (resource: string, originResource: string | null) => GrammarFile;
-    private _parseContext: ParseContext;
 
     constructor(options: GrammarOptions = {}) {
-        this._params = options?.params == null ? [] : options.params;
-        this._originResource = options?.originResource == null ? null : options.originResource;
+        this._options = options;
+        this._params = options.params || [];
+        this._originResource = options.originResource || null;
+        this._parseContext = new ParseContext(this._params, options.decorators || {});
         this._resolveImport = options.resolveImport == null ? defaultImportResolver : options.resolveImport;
         this._resolveImportSync = options.resolveImportSync == null ? defaultImportResolverSync : options.resolveImportSync;
-        this._parseContext = new ParseContext(this._params, options.decorators || {});
     }
 
     async import(path: string) {
@@ -114,19 +125,27 @@ export class Grammar {
         return this._buildPatternRecord();
     }
 
-    private _buildPatternRecord() {
-        const patterns: Record<string, Pattern> = {};
-        const allPatterns = Array.from(this._parseContext.patternsByName.values());
+    // --- Static convenience methods ---
 
-        allPatterns.forEach(p => {
-            patterns[p.name] = new Context(p.name, p, allPatterns.filter(o => o !== p));
-        });
+    static parse(expression: string, options?: GrammarOptions) {
+        const g = new Grammar(options);
+        return g.parse(expression);
+    }
 
-        return patterns;
+    static import(path: string, options?: GrammarOptions) {
+        const g = new Grammar(options);
+        return g.import(path);
+    }
+
+    static parseString(expression: string, options?: GrammarOptions) {
+        const g = new Grammar(options);
+        return g.parseString(expression);
     }
 
-    private _tryToParse(expression: string): Node {
-        const { ast, cursor } = grammar.exec(expression, true);
+    // --- Parsing ---
+
+    private _tryToParse(cpat: string): Node {
+        const { ast, cursor } = grammar.exec(cpat, true);
 
         if (ast == null) {
             const message = generateErrorMessage(grammar, cursor);
@@ -136,112 +155,137 @@ export class Grammar {
         return ast;
     }
 
-    private _hasImports(ast: Node) {
-        const importBlock = ast.find(n => n.name === "import-block");
-        if (importBlock == null) {
-            return false;
+    // --- Expression Flattening (Phase 2) ---
+
+    private _flattenExpressionsRecursive(node: Node) {
+        // Process children first (bottom-up)
+        for (const child of node.children) {
+            this._flattenExpressionsRecursive(child);
+        }
+
+        switch (node.name) {
+            case "sequenceExpr":
+            case "optionsExpr":
+            case "greedyOptionsExpr":
+                this._unwrapNode(node.name, node);
+                break;
+        }
+    }
+
+    private _unwrapNode(type: string, node: Node) {
+        for (let x = 0; x < node.children.length; x++) {
+            const child = node.children[x];
+
+            if (child.name === type) {
+                node.spliceChildren(x, 1, ...child.children);
+                x--;
+            }
         }
+    }
+
+    // --- Pattern Record ---
+
+    private _buildPatternRecord() {
+        const patterns: Record<string, Pattern> = {};
+        const allPatterns = Array.from(this._parseContext.patternsByName.values());
 
-        return importBlock && importBlock.children.length > 0;
+        this._parseContext.patternsByName.forEach((p, name) => {
+            patterns[name] = new Context(name, p, allPatterns.filter(o => o !== p));
+        });
+
+        return patterns;
     }
 
+    // --- Pattern Building (Phase 3) ---
+
     private _buildPatterns(ast: Node) {
-        const body = ast.find(n => n.name === "body" && n.findAncestor(n => n.name === "head") == null);
+        const statementsNode = ast.find(n => n.name === "statements");
 
-        if (body == null) {
+        if (statementsNode == null) {
             return;
         }
 
-        const statements = body.findAll(n => n.name === "assign-statement");
+        const allStatements = statementsNode.children;
 
-        statements.forEach((n) => {
-            const patternNode = n.children.find(n => patternNodes[n.name] != null);
+        // First pass: build pattern assignments
+        for (let i = 0; i < allStatements.length; i++) {
+            const statementNode = allStatements[i];
 
-            if (patternNode == null) {
-                return;
-            }
+            if (statementNode.name === "patternAssignment") {
+                const nameNode = statementNode.find(n => n.name === "patternName") as Node;
+                const name = nameNode.value;
 
-            switch (patternNode.name) {
-                case "literal": {
-                    this._saveLiteral(n);
-                    break;
-                }
-                case "regex-literal": {
-                    this._saveRegex(n);
-                    break;
-                }
-                case "options-literal": {
-                    this._saveOptions(n);
-                    break;
-                }
-                case "sequence-literal": {
-                    this._saveSequence(n);
-                    break;
-                }
-                case "repeat-literal": {
-                    this._saveRepeat(n);
-                    break;
-                }
-                case "alias-literal": {
-                    this._saveAlias(n);
-                    break;
-                }
-                case "take-until-literal": {
-                    this._saveTakeUntil(n);
-                    break;
-                }
-                case "configurable-anonymous-pattern": {
-                    this._saveConfigurableAnonymous(n);
-                    break;
-                }
-                default: {
-                    break;
+                // Find the pattern expression (the RHS of the assignment)
+                const patternExprNode = statementNode.children.find(n =>
+                    n.name !== "patternName" && !skipNodes[n.name] && n.name !== "assign"
+                );
+
+                if (patternExprNode == null) {
+                    continue;
                 }
-            }
-        });
 
-        body.findAll(n => n.name === "export-name").forEach((n) => {
-            const pattern = this._getPattern(n.value).clone();
-            this._parseContext.patternsByName.set(n.value, pattern);
-        });
-    }
+                // Flatten nested binary expressions
+                this._flattenExpressionsRecursive(patternExprNode);
 
+                let pattern = this._buildPattern(name, patternExprNode);
 
-    private _saveLiteral(statementNode: Node) {
-        const nameNode = statementNode.find(n => n.name === "name") as Node;
-        const literalNode = statementNode.find(n => n.name === "literal") as Node;
-        const name = nameNode.value;
-        const literal = this._buildLiteral(name, literalNode);
+                // For alias assignments (RHS is just a patternIdentifier), rename to the assignment name
+                if (patternExprNode.name === "patternIdentifier" && pattern.name !== name) {
+                    pattern = pattern.clone(name);
+                }
 
-        this._applyDecorators(statementNode, literal);
-        this._parseContext.patternsByName.set(name, literal);
+                this._applyDecorators(i, allStatements, pattern);
+                this._parseContext.patternsByName.set(name, pattern);
+            } else if (statementNode.name === "exportPattern") {
+                const exportName = statementNode.value;
+                const pattern = this._getPattern(exportName).clone();
+                this._parseContext.patternsByName.set(exportName, pattern);
+            }
+        }
     }
 
-    private _buildLiteral(name: string, node: Node) {
-        return new Literal(name, this._resolveStringValue(node.value));
-    }
+    private _buildPattern(name: string, node: Node): Pattern {
+        switch (node.name) {
+            case "literal": {
+                // Use the literal's content as the name when in anonymous position
+                const litName = name.startsWith("anonymous-pattern-") ? this._resolveStringValue(node.value) : name;
+                return this._buildLiteral(litName, node);
+            }
+            case "regex": {
+                // Use the regex's content as the name when in anonymous position
+                const regName = name.startsWith("anonymous-pattern-") ? node.value.slice(1, -1) : name;
+                return this._buildRegex(regName, node);
+            }
+            case "sequenceExpr":
+                return this._buildSequence(name, node);
+            case "optionsExpr":
+                return this._buildOptions(name, node);
+            case "greedyOptionsExpr":
+                return this._buildGreedyOptions(name, node);
+            case "repeatExpr":
+                return this._buildRepeat(name, node);
+            case "patternGroupExpr":
+                return this._buildPatternGroup(name, node);
+            case "notExpr":
+                return this._buildNot(name, node);
+            case "optionalExpr":
+                return this._buildOptional(name, node);
+            case "rightAssociationExpr":
+                return this._buildRightAssociation(node);
+            case "patternIdentifier": {
+                // Use the pattern's own name for references (important for Expression recursion detection)
+                // The caller (_buildPatterns) renames for alias assignments
+                return this._getPattern(node.value).clone();
+            }
+            case "takeUntilExpr":
+                return this._buildTakeUntil(name, node);
+        }
 
-    private _resolveStringValue(value: string) {
-        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);
+        throw new Error(`Couldn't build node: ${node.name}.`);
     }
 
-    private _saveRegex(statementNode: Node) {
-        const nameNode = statementNode.find(n => n.name === "name") as Node;
-        const regexNode = statementNode.find(n => n.name === "regex-literal") as Node;
-        const name = nameNode.value;
-        const regex = this._buildRegex(name, regexNode);
-
-        this._applyDecorators(statementNode, regex);
-        this._parseContext.patternsByName.set(name, regex);
+    private _buildLiteral(name: string, node: Node) {
+        return new Literal(name, this._resolveStringValue(node.value));
     }
 
     private _buildRegex(name: string, node: Node) {
@@ -249,237 +293,288 @@ export class Grammar {
         return new Regex(name, value);
     }
 
-    private _saveOptions(statementNode: Node) {
-        const nameNode = statementNode.find(n => n.name === "name") as Node;
-        const name = nameNode.value;
-        const optionsNode = statementNode.find(n => n.name === "options-literal") as Node;
-        const options = this._buildOptions(name, optionsNode);
-
-        this._applyDecorators(statementNode, options);
-        this._parseContext.patternsByName.set(name, options);
+    private _buildSequence(name: string, node: Node) {
+        const patternChildren = node.children.filter(n => !skipNodes[n.name]);
+        const patterns = patternChildren.map(n => this._buildPattern(`anonymous-pattern-${anonymousIndexId++}`, n));
+        return new Sequence(name, patterns);
     }
 
     private _buildOptions(name: string, node: 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 => {
-            const rightAssociated = n.find(n => n.name === "right-associated");
-            if (rightAssociated != null) {
-                return new RightAssociated(this._buildPattern(n.children[0]));
-            } else {
-                return this._buildPattern(n.children[0]);
-            }
-
+        const patternChildren = node.children.filter(n => !skipNodes[n.name]);
+        const patterns = patternChildren.map(n => {
+            return this._buildPattern(`anonymous-pattern-${anonymousIndexId++}`, n);
         });
 
         const hasRecursivePattern = patterns.some(p => this._isRecursive(name, p));
-        if (hasRecursivePattern && !isGreedy) {
+        if (hasRecursivePattern) {
             try {
-                const expression = new Expression(name, patterns);
-                return expression;
+                return new Expression(name, patterns);
             } catch { }
         }
 
-        const options = new Options(name, patterns, isGreedy);
-        return options;
+        return new Options(name, patterns);
     }
 
-    private _isRecursive(name: string, pattern: Pattern) {
-        if (pattern.type === "right-associated") {
-            pattern = pattern.children[0];
+    private _buildGreedyOptions(name: string, node: Node) {
+        const patternChildren = node.children.filter(n => !skipNodes[n.name]);
+        const patterns = patternChildren.map(n => this._buildPattern(`anonymous-pattern-${anonymousIndexId++}`, n));
+        return new Options(name, patterns, true);
+    }
+
+    private _buildRepeat(name: string, node: Node) {
+        let isOptional = false;
+
+        // Find the main pattern (first non-structural child inside parens)
+        const patternNode = node.children.find(n =>
+            !skipNodes[n.name] && n.name !== "(" && n.name !== ")" &&
+            n.name !== "repeatOptions" && n.name !== "optionalDelimiter" &&
+            n.name !== "delimiter" && n.name !== "oneOrMore" &&
+            n.name !== "zeroOrMore" && n.name !== "repeatBounds"
+        );
+
+        if (patternNode == null) {
+            throw new Error(`Repeat pattern missing inner pattern.`);
         }
 
-        return this._isRecursivePattern(name, pattern);
-    }
+        const pattern = this._buildPattern(`anonymous-pattern-${anonymousIndexId++}`, patternNode);
 
-    private _isRecursivePattern(name: string, pattern: Pattern) {
-        // Because we don't know if the pattern is a sequence with a reference we have to just assume it is.
-        // The better solution here would be to not have options at all and just use expresssion pattern instead.
-        if (pattern.type === "reference") {
-            return true;
+        const options: RepeatOptions = {
+            min: 1,
+            max: Infinity
+        };
+
+        // Handle delimiter
+        const delimiterNode = node.find(n => n.name === "delimiter");
+        if (delimiterNode != null) {
+            const delimPatternNode = delimiterNode.children.find(n =>
+                !skipNodes[n.name] && n.name !== "," && n.name !== "optionalTrim" && n.name !== "trim"
+            );
+            if (delimPatternNode != null) {
+                options.divider = this._buildPattern(`anonymous-pattern-${anonymousIndexId++}`, delimPatternNode);
+            }
+
+            const trimFlag = delimiterNode.find(n => n.name === "trim");
+            if (trimFlag != null) {
+                options.trimDivider = true;
+            }
         }
 
-        if (pattern.children.length === 0) {
-            return false;
+        // Handle quantifier / bounds
+        const repeatOptionsNode = node.find(n => n.name === "oneOrMore" || n.name === "zeroOrMore" || n.name === "repeatBounds");
+
+        if (repeatOptionsNode != null) {
+            if (repeatOptionsNode.name === "oneOrMore") {
+                options.min = 1;
+                options.max = Infinity;
+            } else if (repeatOptionsNode.name === "zeroOrMore") {
+                isOptional = true;
+                options.min = 0;
+                options.max = Infinity;
+            } else if (repeatOptionsNode.name === "repeatBounds") {
+                const integers = repeatOptionsNode.findAll(n => n.name === "integer");
+                const hasComma = repeatOptionsNode.find(n => n.name === ",") != null;
+
+                if (integers.length === 2) {
+                    // {min, max}
+                    options.min = Number(integers[0].value);
+                    options.max = Number(integers[1].value);
+                } else if (integers.length === 1 && hasComma) {
+                    // Check position to determine {min,} or {,max}
+                    const commaNode = repeatOptionsNode.find(n => n.name === ",") as Node;
+                    const intNode = integers[0];
+                    if (intNode.startIndex < commaNode.startIndex) {
+                        // {min,}
+                        options.min = Number(intNode.value);
+                        options.max = Infinity;
+                    } else {
+                        // {,max}
+                        options.min = 0;
+                        options.max = Number(intNode.value);
+                    }
+                } else if (integers.length === 1 && !hasComma) {
+                    // {exact}
+                    const count = Number(integers[0].value);
+                    options.min = count;
+                    options.max = count;
+                }
+            }
         }
 
-        const firstChild = pattern.children[0];
-        const lastChild = pattern.children[pattern.children.length - 1];
-        const isLongEnough = pattern.children.length >= 2;
+        if (isOptional) {
+            return new Optional(name, new Repeat(`inner-optional-${name}`, pattern, options));
+        }
 
-        return pattern.type === "sequence" && isLongEnough &&
-            (firstChild.name === name ||
-                lastChild.name === name);
+        return new Repeat(name, pattern, options);
     }
 
-    private _buildPattern(node: Node): Pattern {
-        const type = node.name;
-        const name = `anonymous-pattern-${anonymousIndexId++}`;
+    private _buildPatternGroup(_name: string, node: Node) {
+        const innerNode = node.children.find(n =>
+            !skipNodes[n.name] && n.name !== "(" && n.name !== ")"
+        );
 
-        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 "options-literal": {
-                return this._buildOptions(name, node);
-            }
-            case "sequence-literal": {
-                return this._buildSequence(name, node);
-            }
-            case "take-until-literal": {
-                return this._buildTakeUntil(name, node);
-            }
-            case "complex-anonymous-pattern": {
-                return this._buildComplexAnonymousPattern(node);
-            }
+        if (innerNode == null) {
+            throw new Error("Empty pattern group.");
         }
 
-        throw new Error(`Couldn't build node: ${node.name}.`);
+        return this._buildPattern(`anonymous-pattern-${anonymousIndexId++}`, innerNode);
     }
 
-    private _saveSequence(statementNode: Node) {
-        const nameNode = statementNode.find(n => n.name === "name") as Node;
-        const name = nameNode.value;
-        const sequenceNode = statementNode.find(n => n.name === "sequence-literal") as Node;
-        const sequence = this._buildSequence(name, sequenceNode);
+    private _buildNot(_name: string, node: Node) {
+        const innerNode = node.children.find(n => !skipNodes[n.name] && n.name !== "not");
+
+        if (innerNode == null) {
+            throw new Error("Not pattern missing inner pattern.");
+        }
 
-        this._applyDecorators(statementNode, sequence);
-        this._parseContext.patternsByName.set(name, sequence);
+        const inner = this._buildPattern(`anonymous-pattern-${anonymousIndexId++}`, innerNode);
+        return new Not(`not-${inner.name}`, inner);
     }
 
-    private _buildSequence(name: string, node: Node) {
-        const patternNodes = node.children.filter(n => n.name !== "sequence-divider");
+    private _buildOptional(_name: string, node: Node) {
+        const innerNode = node.children.find(n => !skipNodes[n.name] && n.name !== "?");
 
-        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);
-            const finalPattern = isOptional ? new Optional(`optional-${pattern.name}`, pattern) : pattern;
+        if (innerNode == null) {
+            throw new Error("Optional pattern missing inner pattern.");
+        }
 
-            if (isNot) {
-                return new Not(`not-${finalPattern.name}`, finalPattern);
-            }
+        const inner = this._buildPattern(`anonymous-pattern-${anonymousIndexId++}`, innerNode);
+        return new Optional(`optional-${inner.name}`, inner);
+    }
 
-            return finalPattern;
-        });
+    private _buildRightAssociation(node: Node) {
+        const innerNode = node.children.find(n => !skipNodes[n.name] && n.name !== "right");
 
-        return new Sequence(name, patterns);
+        if (innerNode == null) {
+            throw new Error("RightAssociation pattern missing inner pattern.");
+        }
+
+        return new RightAssociated(this._buildPattern(`anonymous-pattern-${anonymousIndexId++}`, innerNode));
     }
 
-    private _saveRepeat(statementNode: Node) {
-        const nameNode = statementNode.find(n => n.name === "name") as Node;
-        const name = nameNode.value;
-        const repeatNode = statementNode.find(n => n.name === "repeat-literal") as Node;
-        const repeat = this._buildRepeat(name, repeatNode);
+    private _buildTakeUntil(name: string, node: Node) {
+        // The last meaningful child is the until pattern
+        const patternChildren = node.children.filter(n =>
+            !skipNodes[n.name] && n.name !== "anyChar" && n.name !== "upTo" && n.name !== "wall"
+        );
+
+        const untilPatternNode = patternChildren[patternChildren.length - 1];
 
-        this._applyDecorators(statementNode, repeat);
-        this._parseContext.patternsByName.set(name, repeat);
+        if (untilPatternNode == null) {
+            throw new Error("TakeUntil pattern missing terminator pattern.");
+        }
+
+        const untilPattern = this._buildPattern(`anonymous-pattern-${anonymousIndexId++}`, untilPatternNode);
+        return new TakeUntil(name, untilPattern);
     }
 
-    private _buildRepeat(name: string, repeatNode: Node) {
-        let isOptional = false;
-        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 === "spaces" ? repeatNode.children[2] : repeatNode.children[1];
-        const pattern = this._buildPattern(patterNode);
-        const dividerSectionNode = repeatNode.find(n => n.name === "repeat-divider-section");
+    // --- Helpers ---
 
-        const options: RepeatOptions = {
-            min: 1,
-            max: Infinity
-        };
+    private _resolveStringValue(value: string) {
+        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) => String.fromCharCode(parseInt(hex, 16)))
+            .replace(/\\u([0-9A-Fa-f]{4})/g, (_, hex: string) => String.fromCharCode(parseInt(hex, 16)))
+            .replace(/\\(.)/g, '$1').slice(1, -1);
+    }
+
+    private _getPattern(name: string) {
+        let pattern = this._parseContext.patternsByName.get(name);
 
-        if (trimDivider) {
-            options.trimDivider = trimDivider;
+        if (pattern == null) {
+            pattern = this._parseContext.importedPatternsByName.get(name);
         }
 
-        if (dividerSectionNode != null) {
-            const dividerNode = dividerSectionNode.children[1];
-            options.divider = this._buildPattern(dividerNode);
+        if (pattern == null) {
+            pattern = this._parseContext.paramsByName.get(name);
         }
 
-        if (bounds != null) {
-            const minNode = bounds.find(p => p.name === "min");
-            const maxNode = bounds.find(p => p.name === "max");
+        if (pattern == null) {
+            return new Reference(name);
+        }
 
-            const min = minNode == null ? 0 : Number(minNode.value);
-            const max = maxNode == null ? Infinity : Number(maxNode.value);
+        return pattern;
+    }
 
-            options.min = min;
-            options.max = max;
-        } else if (exactCount != null) {
-            const integerNode = exactCount.find(p => p.name === "integer") as Node;
-            const integer = Number(integerNode.value);
+    private _isRecursive(name: string, pattern: Pattern) {
+        if (pattern.type === "right-associated") {
+            pattern = pattern.children[0];
+        }
+        return this._isRecursivePattern(name, pattern);
+    }
 
-            options.min = integer;
-            options.max = integer;
-        } else if (quantifier != null) {
-            const type = quantifier.value;
-            if (type === "+") {
-                options.min = 1;
-                options.max = Infinity;
-            } else {
-                isOptional = true;
-            }
+    private _isRecursivePattern(name: string, pattern: Pattern) {
+        if (pattern.type === "reference") {
+            return true;
         }
 
-        return isOptional ? new Optional(name, new Repeat(`inner-optional-${name}`, pattern, options)) : new Repeat(name, pattern, options);
-    }
+        if (pattern.children.length === 0) {
+            return false;
+        }
 
-    private _saveTakeUntil(statementNode: Node) {
-        const nameNode = statementNode.find(n => n.name === "name") as Node;
-        const name = nameNode.value;
-        const takeUntilNode = statementNode.find(n => n.name === "take-until-literal") as Node;
-        const takeUntil = this._buildTakeUntil(name, takeUntilNode);
+        const firstChild = pattern.children[0];
+        const lastChild = pattern.children[pattern.children.length - 1];
+        const isLongEnough = pattern.children.length >= 2;
 
-        this._applyDecorators(statementNode, takeUntil);
-        this._parseContext.patternsByName.set(name, takeUntil);
+        return pattern.type === "sequence" && isLongEnough &&
+            (firstChild.name === name || lastChild.name === name);
     }
 
+    // --- Decorators ---
 
-    private _buildTakeUntil(name: string, takeUntilNode: Node) {
-        const patternNode = takeUntilNode.children[takeUntilNode.children.length - 1];
-        const untilPattern = this._buildPattern(patternNode);
+    private _applyDecorators(statementIndex: number, allStatements: readonly Node[], pattern: Pattern) {
+        const decorators = this._parseContext.decorators;
+        let decoratorNodes: Node[] = [];
 
-        return new TakeUntil(name, untilPattern);
-    }
+        // Walk backwards from the statement to find preceding decorator statements
+        // Note: statements Repeat includes newLine divider nodes between statements
+        for (let i = statementIndex - 1; i >= 0; i--) {
+            const prev = allStatements[i];
+            if (prev.name === "decorationStatement" || prev.name === "methodDecorationStatement" || prev.name === "nameDecorationStatement") {
+                decoratorNodes.push(prev);
+            } else if (prev.name === "comment" || prev.name === "newLine") {
+                // Comments and newline dividers can appear between decorators and the statement
+                continue;
+            } else {
+                break;
+            }
+        }
 
-    private _saveConfigurableAnonymous(node: Node) {
-        const nameNode = node.find(n => n.name === "name") as Node;
-        const name = nameNode.value;
-        const anonymousNode = node.find(n => n.name === "configurable-anonymous-pattern") as Node;
-        const isOptional = node.children[1] != null;
+        for (const d of decoratorNodes) {
+            const actualDecorator = d.name === "decorationStatement" ? d.children[0] : d;
+            const nameNode = actualDecorator.find(n => n.name === "decorationName");
 
-        const anonymous = isOptional ? new Optional(name, this._buildPattern(anonymousNode.children[0])) : this._buildPattern(anonymousNode.children[0]);
+            if (nameNode == null || decorators[nameNode.value] == null) {
+                continue;
+            }
 
-        this._applyDecorators(node, anonymous);
-        this._parseContext.patternsByName.set(name, anonymous);
-    }
+            if (actualDecorator.name === "nameDecorationStatement") {
+                decorators[nameNode.value](pattern);
+            } else if (actualDecorator.name === "methodDecorationStatement") {
+                const jsonValueNode = actualDecorator.find(n => n.name === "jsonArray" || n.name === "jsonObject" || n.name === "jsonString" || n.name === "jsonNumber" || n.name === "jsonBoolean" || n.name === "jsonNull");
 
-    private _buildComplexAnonymousPattern(node: Node) {
-        const wrappedNode = node.children[1].name === "line-spaces" ? node.children[2] : node.children[1];
-        return this._buildPattern(wrappedNode);
+                if (jsonValueNode == null) {
+                    decorators[nameNode.value](pattern);
+                } else {
+                    decorators[nameNode.value](pattern, JSON.parse(jsonValueNode.value));
+                }
+            }
+        }
     }
 
+    // --- Import Handling ---
+
     private async _resolveImports(ast: Node) {
         const importStatements = ast.findAll(n => {
-            return n.name === "import-from" || n.name === "param-name-with-default-value";
+            return n.name === "importStatement" || n.name === "useParamsStatement";
         });
 
         for (const statement of importStatements) {
-            if (statement.name === "import-from") {
+            if (statement.name === "importStatement") {
                 await this._processImport(statement);
             } else {
                 this._processUseParams(statement);
@@ -489,11 +584,11 @@ export class Grammar {
 
     private _resolveImportsSync(ast: Node) {
         const importStatements = ast.findAll(n => {
-            return n.name === "import-from" || n.name === "param-name-with-default-value";
+            return n.name === "importStatement" || n.name === "useParamsStatement";
         });
 
         for (const statement of importStatements) {
-            if (statement.name === "import-from") {
+            if (statement.name === "importStatement") {
                 this._processImportSync(statement);
             } else {
                 this._processUseParams(statement);
@@ -504,10 +599,15 @@ export class Grammar {
     private _processImportSync(importStatement: Node) {
         const parseContext = this._parseContext;
         const resourceNode = importStatement.find(n => n.name === "resource") as Node;
-        const params = this._getParams(importStatement);
+
+        if (resourceNode == null) {
+            throw new Error("Invalid import statement: resource is required");
+        }
+
+        const params = this._getWithParams(importStatement);
         const resource = resourceNode.value.slice(1, -1);
         const grammarFile = this._resolveImportSync(resource, this._originResource || null);
-        const grammar = new Grammar({
+        const g = new Grammar({
             resolveImport: this._resolveImport,
             resolveImportSync: this._resolveImportSync,
             originResource: grammarFile.resource,
@@ -516,59 +616,25 @@ export class Grammar {
         });
 
         try {
-            const patterns = grammar.parseString(grammarFile.expression);
-            const importStatements = importStatement.findAll(n => n.name === "import-name" || n.name === "import-alias");
-
-            importStatements.forEach((node) => {
-                if (node.name === "import-name" && node.parent?.name === "import-alias") {
-                    return;
-                }
-
-                if (node.name === "import-name" && node.parent?.name !== "import-alias") {
-                    const importName = node.value;
-
-                    if (parseContext.importedPatternsByName.has(importName)) {
-                        throw new Error(`'${importName}' was already used within another import.`);
-                    }
-
-                    const pattern = patterns[importName];
-                    if (pattern == null) {
-                        throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
-                    }
-
-                    parseContext.importedPatternsByName.set(importName, pattern);
-                } else {
-                    const importNameNode = node.find(n => n.name === "import-name") as Node;
-                    const importName = importNameNode.value;
-                    const aliasNode = node.find(n => n.name === "import-name-alias") as Node;
-                    const alias = aliasNode.value;
-
-                    if (parseContext.importedPatternsByName.has(alias)) {
-                        throw new Error(`'${alias}' was already used within another import.`);
-                    }
-
-                    const pattern = patterns[importName];
-                    if (pattern == null) {
-                        throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
-                    }
-
-                    parseContext.importedPatternsByName.set(alias, pattern.clone(alias));
-                }
-            });
-
+            const patterns = g.parseString(grammarFile.expression);
+            this._processImportNames(importStatement, patterns, parseContext, resource);
         } catch (e: any) {
             throw new Error(`Failed loading expression from: "${resource}". Error details: "${e.message}"`);
         }
-
     }
 
     private async _processImport(importStatement: Node) {
         const parseContext = this._parseContext;
         const resourceNode = importStatement.find(n => n.name === "resource") as Node;
-        const params = this._getParams(importStatement);
+
+        if (resourceNode == null) {
+            throw new Error("Invalid import statement: resource is required");
+        }
+
+        const params = this._getWithParams(importStatement);
         const resource = resourceNode.value.slice(1, -1);
         const grammarFile = await this._resolveImport(resource, this._originResource || null);
-        const grammar = new Grammar({
+        const g = new Grammar({
             resolveImport: this._resolveImport,
             originResource: grammarFile.resource,
             params,
@@ -576,157 +642,76 @@ export class Grammar {
         });
 
         try {
-            const patterns = await grammar.parse(grammarFile.expression);
-            const importStatements = importStatement.findAll(n => n.name === "import-name" || n.name === "import-alias");
-
-            importStatements.forEach((node) => {
-                if (node.name === "import-name" && node.parent?.name === "import-alias") {
-                    return;
-                }
-
-                if (node.name === "import-name" && node.parent?.name !== "import-alias") {
-                    const importName = node.value;
-
-                    if (parseContext.importedPatternsByName.has(importName)) {
-                        throw new Error(`'${importName}' was already used within another import.`);
-                    }
-
-                    const pattern = patterns[importName];
-                    if (pattern == null) {
-                        throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
-                    }
-
-                    parseContext.importedPatternsByName.set(importName, pattern);
-                } else {
-                    const importNameNode = node.find(n => n.name === "import-name") as Node;
-                    const importName = importNameNode.value;
-                    const aliasNode = node.find(n => n.name === "import-name-alias") as Node;
-                    const alias = aliasNode.value;
-
-                    if (parseContext.importedPatternsByName.has(alias)) {
-                        throw new Error(`'${alias}' was already used within another import.`);
-                    }
-
-                    const pattern = patterns[importName];
-                    if (pattern == null) {
-                        throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
-                    }
-
-                    parseContext.importedPatternsByName.set(alias, pattern.clone(alias));
-                }
-            });
-
+            const patterns = await g.parse(grammarFile.expression);
+            this._processImportNames(importStatement, patterns, parseContext, resource);
         } catch (e: any) {
             throw new Error(`Failed loading expression from: "${resource}". Error details: "${e.message}"`);
         }
-
     }
 
-    private _processUseParams(paramName: Node) {
-        const defaultValueNode = paramName.find(n => n.name === "param-default");
-        if (defaultValueNode === null) {
-            return;
-        }
-
-        const nameNode = paramName.find(n => n.name === "param-name");
-        const defaultNameNode = defaultValueNode.find(n => n.name === "default-param-name");
-
-        if (nameNode == null || defaultNameNode == null) {
-            return;
-        }
-
-        const name = nameNode.value;
-        const defaultName = defaultNameNode.value;
+    private _processImportNames(importStatement: Node, patterns: Record<string, Pattern>, parseContext: ParseContext, resource: string) {
+        // Find all imported names (could be aliases or plain names)
+        const importedPatternsNode = importStatement.find(n => n.name === "importedPatterns");
+        if (importedPatternsNode == null) return;
 
-        if (this._parseContext.paramsByName.has(name)) {
-            return;
-        }
+        const patternNamesNode = importedPatternsNode.find(n => n.name === "patternNames");
+        if (patternNamesNode == null) return;
 
-        let pattern = this._parseContext.importedPatternsByName.get(defaultName);
+        for (const child of patternNamesNode.children) {
+            if (child.name === "importAlias") {
+                const nameNode = child.find(n => n.name === "patternName") as Node;
+                const aliasNode = child.find(n => n.name === "importNameAlias") as Node;
+                const importName = nameNode.value;
+                const alias = aliasNode.value;
 
-        if (pattern == null) {
-            pattern = new Reference(defaultName);
-        }
+                if (parseContext.importedPatternsByName.has(alias)) {
+                    throw new Error(`'${alias}' was already used within another import.`);
+                }
 
-        this._parseContext.importedPatternsByName.set(name, pattern);
-    }
+                const pattern = patterns[importName];
+                if (pattern == null) {
+                    throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
+                }
 
-    private _applyDecorators(statementNode: Node, pattern: Pattern) {
-        const decorators = this._parseContext.decorators;
-        const bodyLine = statementNode.parent;
+                parseContext.importedPatternsByName.set(alias, pattern.clone(alias));
+            } else if (child.name === "patternName") {
+                const importName = child.value;
 
-        if (bodyLine == null) {
-            return;
-        }
+                if (parseContext.importedPatternsByName.has(importName)) {
+                    throw new Error(`'${importName}' was already used within another import.`);
+                }
 
-        let prevSibling = bodyLine.previousSibling();
-        let decoratorNodes: Node[] = [];
+                const pattern = patterns[importName];
+                if (pattern == null) {
+                    throw new Error(`Couldn't find pattern with name: ${importName}, from import: ${resource}.`);
+                }
 
-        while (prevSibling != null) {
-            if (prevSibling.find(n => n.name === "assign-statement")) {
-                break;
+                parseContext.importedPatternsByName.set(importName, pattern);
             }
-            decoratorNodes.push(prevSibling);
-            prevSibling = prevSibling.previousSibling();
+            // Skip comma divider nodes
         }
-
-        decoratorNodes = decoratorNodes.filter(n => n.find(n => n.name.includes("decorator")) != null);
-
-        decoratorNodes.forEach((d) => {
-            const nameNode = d.find(n => n.name === "decorator-name");
-
-            if (nameNode == null || decorators[nameNode.value] == null) {
-                return;
-            }
-
-            const nameDocorator = d.find(n => n.name === "name-decorator");
-
-            if (nameDocorator != null) {
-                decorators[nameNode.value](pattern);
-                return;
-            }
-
-            const methodDecorator = d.find(n => n.name === "method-decorator");
-
-            if (methodDecorator == null) {
-                return;
-            }
-
-            methodDecorator.findAll(n => n.name.includes("space")).forEach(n => n.remove());
-            const argsNode = methodDecorator.children[3];
-
-            if (argsNode == null || argsNode.name === "close-paren") {
-                decorators[nameNode.value](pattern);
-            } else {
-                decorators[nameNode.value](pattern, JSON.parse(argsNode.value));
-            }
-        });
-
     }
 
-    private _getParams(importStatement: Node) {
+    private _getWithParams(importStatement: Node) {
         let params: Pattern[] = [];
-        const paramsStatement = importStatement.find(n => n.name === "with-params-statement");
+        const withParamsNode = importStatement.find(n => n.name === "withParamsExpr");
 
-        if (paramsStatement != null) {
-            const statements = paramsStatement.find(n => n.name === "body");
+        if (withParamsNode != null) {
+            const statementsNode = withParamsNode.find(n => n.name === "withParamStatements");
 
-            if (statements != null) {
-                const expression = statements.toString();
-                const importedValues = Array.from(this
-                    ._parseContext
-                    .importedPatternsByName
-                    .values()
-                );
+            if (statementsNode != null) {
+                const expression = statementsNode.value;
+                const importedValues = this._parseContext.getImportedPatterns();
 
-                const grammar = new Grammar({
+                const g = new Grammar({
                     params: [...importedValues, ...this._parseContext.paramsByName.values()],
                     originResource: this._originResource,
                     resolveImport: this._resolveImport,
+                    resolveImportSync: this._resolveImportSync,
                     decorators: this._parseContext.decorators
                 });
 
-                const patterns = grammar.parseString(expression);
+                const patterns = g.parseString(expression);
                 params = Array.from(Object.values(patterns));
             }
         }
@@ -734,57 +719,40 @@ export class Grammar {
         return params;
     }
 
-    private _getPattern(name: string) {
-        let pattern = this._parseContext.patternsByName.get(name);
-
-        if (pattern == null) {
-            pattern = this._parseContext.importedPatternsByName.get(name);
-        }
+    private _processUseParams(useParamsStatement: Node) {
+        const patternsNode = useParamsStatement.find(n => n.name === "useParamPatterns");
 
-        if (pattern == null) {
-            pattern = this._parseContext.paramsByName.get(name);
+        if (patternsNode == null) {
+            return;
         }
 
-        if (pattern == null) {
-            return new Reference(name);
-        }
+        // Each child is a paramNameWithDefault: patternName + optionalParamDefault
+        const paramNodes = patternsNode.findAll(n => n.name === "paramNameWithDefault");
 
-        return pattern;
-    }
+        for (const paramNode of paramNodes) {
+            const nameNode = paramNode.find(n => n.name === "patternName");
+            if (nameNode == null) continue;
 
-    private _saveAlias(statementNode: Node) {
-        const nameNode = statementNode.find(n => n.name === "name") as Node;
-        const aliasNode = statementNode.find(n => n.name === "alias-literal") as Node;
-        const aliasName = aliasNode.value;
-        const name = nameNode.value;
-        const aliasPattern = this._getPattern(aliasName);
+            const name = nameNode.value;
 
-        // This solves the problem for an alias pointing to a reference.
-        if (aliasPattern.type === "reference") {
-            const reference = aliasPattern.clone(name);
-            this._applyDecorators(statementNode, reference);
-            this._parseContext.patternsByName.set(name, reference);
-        } else {
-            const alias = aliasPattern.clone(name);
-            this._applyDecorators(statementNode, alias);
-            this._parseContext.patternsByName.set(name, alias);
-        }
+            // If already provided via params option, skip
+            if (this._parseContext.paramsByName.has(name)) {
+                continue;
+            }
 
-    }
+            // Check for default value: use params { value = default-value }
+            const defaultNode = paramNode.find(n => n.name === "defaultParamName");
 
-    static parse(expression: string, options?: GrammarOptions) {
-        const grammar = new Grammar(options);
-        return grammar.parse(expression);
-    }
+            if (defaultNode != null) {
+                const defaultName = defaultNode.value;
+                let pattern = this._parseContext.importedPatternsByName.get(defaultName);
 
-    static import(path: string, options?: GrammarOptions) {
-        const grammar = new Grammar(options);
-        return grammar.import(path);
-    }
+                if (pattern == null) {
+                    pattern = new Reference(defaultName);
+                }
 
-    static parseString(expression: string, options?: GrammarOptions) {
-        const grammar = new Grammar(options);
-        return grammar.parseString(expression);
+                this._parseContext.importedPatternsByName.set(name, pattern);
+            }
+        }
     }
-
-}
+}