clarity-pattern-parser 11.5.4 → 11.6.0

package/src/grammar/patterns/grammar.test.ts

@@ -0,0 +1,276 @@
+import { grammar } from "./grammar";
+import { Node } from "../../ast/Node";
+
+describe("grammar", () => {
+    test("syntax version", () => {
+        const { ast } = grammar.exec("syntax 1.0");
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "syntax")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "syntax")?.value).toBe("syntax");
+        expect(ast?.find((p: Node) => p.name === "syntaxVersion")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "syntaxVersion")?.value).toBe("1.0");
+    });
+
+    test("import", () => {
+        const { ast } = grammar.exec('import {pattern} from "resource"');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "importStatement")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "import")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "import")?.value).toBe("import");
+        expect(ast?.find((p: Node) => p.name === "patternName")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternName")?.value).toBe("pattern");
+        expect(ast?.find((p: Node) => p.name === "from")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "from")?.value).toBe("from");
+        expect(ast?.find((p: Node) => p.name === "resource")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "resource")?.value).toBe('"resource"');
+    });
+
+    test("import with params", () => {
+        const { ast } = grammar.exec('import {pattern} from "resource" with params {param = "value"}');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "importStatement")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "import")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "import")?.value).toBe("import");
+        expect(ast?.find((p: Node) => p.name === "patternName")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternName")?.value).toBe("pattern");
+        expect(ast?.find((p: Node) => p.name === "from")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "from")?.value).toBe("from");
+        expect(ast?.find((p: Node) => p.name === "resource")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "resource")?.value).toBe('"resource"');
+        expect(ast?.find((p: Node) => p.name === "withParamsExpr")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "withParamsExpr")?.value).toBe("with params {param = \"value\"}");
+        expect(ast?.find((p: Node) => p.name === "statements")?.find((p: Node) => p.name === "param = \"value\"")).toBeDefined();
+    });
+
+    test("use params", () => {
+        const { ast } = grammar.exec('use params { param }');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "useParamsStatement")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "useParamsStatement")?.value).toBe("use params { param }");
+        expect(ast?.find((p: Node) => p.name === "useParams")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "useParams")?.value).toBe("use params");
+        expect(ast?.find((p: Node) => p.name === "useParamPatterns")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "useParamPatterns")?.value).toBe("param");
+    });
+
+    test("literal", () => {
+        const { ast } = grammar.exec('literal = "Hello, world!"');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")?.value).toBe("literal = \"Hello, world!\"");
+        expect(ast?.find((p: Node) => p.name === "patternName")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternName")?.value).toBe("literal");
+        expect(ast?.find((p: Node) => p.name === "literal")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "literal")?.value).toBe("\"Hello, world!\"");
+    });
+
+
+    test("regex", () => {
+        const { ast } = grammar.exec('regex = /Hello, world!/');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")?.value).toBe("regex = /Hello, world!/");
+        expect(ast?.find((p: Node) => p.name === "patternName")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternName")?.value).toBe("regex");
+        expect(ast?.find((p: Node) => p.name === "regex")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "regex")?.value).toBe("/Hello, world!/");
+    });
+
+    test("regex stops at first unescaped slash", () => {
+        const { ast } = grammar.exec('expr = /regex/ + ("Text" <|> /regex/)');
+
+        expect(ast).toBeDefined();
+        const regexNodes = ast?.findAll((p: Node) => p.name === "regex");
+        expect(regexNodes?.length).toBe(2);
+        expect(regexNodes?.[0].value).toBe("/regex/");
+        expect(regexNodes?.[1].value).toBe("/regex/");
+    });
+
+    test("regex allows escaped slashes", () => {
+        const { ast } = grammar.exec('pattern = /a\\/b/');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "regex")?.value).toBe('/a\\/b/');
+    });
+
+    test("comment", () => {
+        const { ast } = grammar.exec('# Comment');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "comment")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "comment")?.value).toBe("# Comment");
+    });
+
+    test("sequence", () => {
+        const { ast } = grammar.exec('sequence = "Hello" + "world"');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")?.value).toBe("sequence = \"Hello\" + \"world\"");
+        expect(ast?.find((p: Node) => p.name === "patternName")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternName")?.value).toBe("sequence");
+        expect(ast?.find((p: Node) => p.name === "sequenceExpr")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "sequenceExpr")?.value).toBe("\"Hello\" + \"world\"");
+    });
+
+    test("options", () => {
+        const { ast } = grammar.exec('options = "Hello" | "world"');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")?.value).toBe("options = \"Hello\" | \"world\"");
+        expect(ast?.find((p: Node) => p.name === "patternName")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternName")?.value).toBe("options");
+        expect(ast?.find((p: Node) => p.name === "optionsExpr")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "optionsExpr")?.value).toBe("\"Hello\" | \"world\"");
+    });
+
+    test("greedy options", () => {
+        const { ast } = grammar.exec('greedyOptions = "Hello" <|> "world"');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")?.value).toBe("greedyOptions = \"Hello\" <|> \"world\"");
+        expect(ast?.find((p: Node) => p.name === "patternName")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternName")?.value).toBe("greedyOptions");
+        expect(ast?.find((p: Node) => p.name === "greedyOptionsExpr")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "greedyOptionsExpr")?.value).toBe("\"Hello\" <|> \"world\"");
+    });
+
+    test("repeat", () => {
+        const { ast } = grammar.exec('repeat = (Hello)+');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")?.value).toBe("repeat = (Hello)+");
+        expect(ast?.find((p: Node) => p.name === "patternName")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternName")?.value).toBe("repeat");
+        expect(ast?.find((p: Node) => p.name === "repeatExpr")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "repeatExpr")?.value).toBe("(Hello)+");
+    });
+
+    test("repeat zero or more", () => {
+        const { ast } = grammar.exec('repeat = (Hello)*');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")?.value).toBe("repeat = (Hello)*");
+        expect(ast?.find((p: Node) => p.name === "patternName")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternName")?.value).toBe("repeat");
+        expect(ast?.find((p: Node) => p.name === "repeatExpr")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "repeatExpr")?.value).toBe("(Hello)*");
+    });
+
+    test("repeat with bounds", () => {
+        const { ast } = grammar.exec('repeat = (Hello){2, 4}');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")?.value).toBe("repeat = (Hello){2, 4}");
+        expect(ast?.find((p: Node) => p.name === "patternName")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternName")?.value).toBe("repeat");
+        expect(ast?.find((p: Node) => p.name === "repeatExpr")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "repeatExpr")?.value).toBe("(Hello){2, 4}");
+    });
+
+    test("repeat with upper limit", () => {
+        const { ast } = grammar.exec('repeat = (Hello){, 4}');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")?.value).toBe("repeat = (Hello){, 4}");
+        expect(ast?.find((p: Node) => p.name === "patternName")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternName")?.value).toBe("repeat");
+        expect(ast?.find((p: Node) => p.name === "repeatExpr")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "repeatExpr")?.value).toBe("(Hello){, 4}");
+    });
+
+    test("repeat with lower limit", () => {
+        const { ast } = grammar.exec('repeat = (Hello){1,}');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")?.value).toBe("repeat = (Hello){1,}");
+        expect(ast?.find((p: Node) => p.name === "patternName")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternName")?.value).toBe("repeat");
+        expect(ast?.find((p: Node) => p.name === "repeatExpr")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "repeatExpr")?.value).toBe("(Hello){1,}");
+    });
+
+    test("repeat with delimiter", () => {
+        const { ast } = grammar.exec('repeat = (Hello, "world")+');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")?.value).toBe("repeat = (Hello, \"world\")+");
+        expect(ast?.find((p: Node) => p.name === "patternName")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternName")?.value).toBe("repeat");
+        expect(ast?.find((p: Node) => p.name === "repeatExpr")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "repeatExpr")?.value).toBe("(Hello, \"world\")+");
+    });
+
+    test("repeat with trim delimiter", () => {
+        const { ast } = grammar.exec('repeat = (Hello, "world" trim)+');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternAssignment")?.value).toBe("repeat = (Hello, \"world\" trim)+");
+        expect(ast?.find((p: Node) => p.name === "patternName")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternName")?.value).toBe("repeat");
+        expect(ast?.find((p: Node) => p.name === "repeatExpr")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "repeatExpr")?.value).toBe("(Hello, \"world\" trim)+");
+    });
+
+    test("take until", () => {
+        const { ast } = grammar.exec('script-text = ?->| "</script"');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "takeUntilExpr")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "takeUntilExpr")?.value).toBe('?->| "</script"');
+        expect(ast?.find((p: Node) => p.name === "anyChar")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "upTo")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "wall")).toBeDefined();
+    });
+
+    test("import alias", () => {
+        const { ast } = grammar.exec('import {value as alias} from "resource"');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "importAlias")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "patternName")?.value).toBe("value");
+        expect(ast?.find((p: Node) => p.name === "as")?.value).toBe("as");
+        expect(ast?.find((p: Node) => p.name === "importNameAlias")?.value).toBe("alias");
+    });
+
+    test("decorator without parens", () => {
+        const { ast } = grammar.exec('@record\nspaces = /\\s+/');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "nameDecorationStatement")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "decorationName")?.value).toBe("record");
+    });
+
+    test("decorator with empty args", () => {
+        const { ast } = grammar.exec('@tokens()\nspaces = /\\s+/');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "methodDecorationStatement")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "decorationName")?.value).toBe("tokens");
+    });
+
+    test("decorator with args", () => {
+        const { ast } = grammar.exec('@tokens([" "])\nspaces = /\\s+/');
+
+        expect(ast).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "methodDecorationStatement")).toBeDefined();
+        expect(ast?.find((p: Node) => p.name === "decorationName")?.value).toBe("tokens");
+        expect(ast?.find((p: Node) => p.name === "jsonArray")).toBeDefined();
+    });
+
+});

package/src/grammar/patterns/grammar.ts

@@ -1,42 +1,118 @@
+import { Expression } from "../../patterns/Expression";
+import { Literal } from "../../patterns/Literal";
+import { Optional } from "../../patterns/Optional";
 import { Options } from "../../patterns/Options";
+import { Reference } from "../../patterns/Reference";
 import { Regex } from "../../patterns/Regex";
 import { Repeat } from "../../patterns/Repeat";
-import { comment } from "./comment";
-import { importStatement } from './import';
 import { Sequence } from "../../patterns/Sequence";
-import { allSpaces } from "./spaces";
-import { body } from "./body";
-import { Optional } from "../../patterns/Optional";
 
-const tabs = new Regex("tabs", "\\t+");
-const spaces = new Regex("spaces", "[ ]+");
-const newLine = new Regex("new-line", "(\\r?\\n)+");
-
-spaces.setTokens([" "]);
-tabs.setTokens(["\t"]);
-newLine.setTokens(["\n"]);
-
-const lineSpaces = new Repeat("line-spaces", new Options("line-space", [tabs, spaces]));
-const optionalLineSpaces = new Optional("optional-line-spaces", lineSpaces);
-
-const headLineContent = new Options("head-line-content", [
-    comment,
-    importStatement
-]);
-
-const headLine = new Sequence("head-line-content", [
-    optionalLineSpaces,
-    headLineContent,
-    optionalLineSpaces,
-]);
-
-const head = new Optional("optional-head", new Repeat("head", headLine, { divider: newLine }));
-const optionalSpaces = new Optional("optional-spaces", allSpaces);
-
-export const grammar = new Sequence("grammar", [
-    optionalSpaces,
-    head,
-    optionalSpaces,
-    body,
-    optionalSpaces
-]);
+export const syntax = new Literal("syntax", "syntax");
+export const imprt = new Literal("import", "import");
+export const useParams = new Literal("useParams", "use params");
+export const withParams = new Literal("withParams", "with params");
+export const from = new Literal("from", "from");
+export const right = new Literal("right", "right");
+export const ws = new Regex("ws", "\\s+");
+export const ls = new Regex("ls", "[ \\t]+");
+export const assign = new Literal("assign", "=");
+export const bar = new Literal("|", "|");
+export const greedyBar = new Literal("<|>", "<|>");
+export const concat = new Literal("+", "+");
+export const colon = new Literal(":", ":");
+export const openParen = new Literal("(", "(");
+export const closeParen = new Literal(")", ")");
+export const openSquareBracket = new Literal("[", "[");
+export const closeSquareBracket = new Literal("]", "]");
+export const openBracket = new Literal("{", "{");
+export const closeBracket = new Literal("}", "}");
+export const comma = new Regex(",", "\\s*[,]\\s*");
+export const trim = new Literal("trim", "trim");
+export const not = new Literal("not", "!");
+export const optional = new Literal("?", "?");
+export const anyChar = new Literal("anyChar", "?");
+export const upTo = new Literal("upTo", "->");
+export const wall = new Literal("wall", "|");
+export const asKeyword = new Literal("as", "as");
+export const newLine = new Regex("newLine", "\\s*(\\r\\n|\\r|\\n)\\s*");
+export const syntaxVersion = new Regex("syntaxVersion", "\\S*");
+export const at = new Literal("@", "@");
+export const optionalWS = new Optional("optionalWS", ws);
+export const optionalLS = new Optional("optionalLS", ls);
+
+export const literal = new Regex("literal", '"(?:\\\\.|[^"\\\\])*"');
+export const regex = new Regex("regex", "\\/(?:\\\\.|[^\\/\\n\\r])*\\/");
+
+export const integer = new Regex("integer", "[1-9][0-9]*|[0]");
+export const name = new Regex("name", "[a-zA-Z_-]+[a-zA-Z0-9_-]*");
+export const patternName = name.clone("patternName");
+export const patternIdentifier = name.clone("patternIdentifier");
+export const resource = literal.clone("resource");
+
+export const comment = new Regex("comment", "#[^\\n\\r]*");
+
+export const jsonString = literal.clone("jsonString");
+export const jsonNumber = new Regex("jsonNumber", "-?\\d+(\\.\\d+)?");
+export const trueLiteral = new Literal("trueLiteral", "true");
+export const falseLiteral = new Literal("falseLiteral", "false");
+export const jsonBoolean = new Options("jsonBoolean", [trueLiteral, falseLiteral]);
+export const jsonNull = new Literal("jsonNull", "null");
+export const jsonArrayItems = new Repeat("jsonArrayItems", new Reference("jsonValue"), { divider: comma, trimDivider: true });
+export const jsonArray = new Sequence("jsonArray", [openSquareBracket, optionalWS, jsonArrayItems, optionalWS, closeSquareBracket]);
+export const jsonObjectPropertyName = literal.clone("jsonObjectPropertyName");
+export const jsonObjectProperty = new Sequence("jsonObjectProperty", [jsonObjectPropertyName, optionalWS, colon, optionalWS, new Reference("jsonValue")]);
+export const jsonObjectProperties = new Repeat("jsonObjectProperties", jsonObjectProperty, { divider: comma, trimDivider: true });
+export const jsonObject = new Sequence("jsonObject", [openBracket, optionalWS, new Optional("optionalJsonObjectProperties", jsonObjectProperties), optionalWS, closeBracket]);
+export const jsonValue = new Options("jsonValue", [jsonString, jsonNumber, jsonBoolean, jsonNull, jsonArray, jsonObject]);
+
+export const syntaxStatement = new Sequence("syntaxStatement", [syntax, optionalWS, syntaxVersion]);
+
+export const decorationName = name.clone("decorationName");
+export const methodDecorationStatement = new Sequence("methodDecorationStatement", [at, optionalWS, decorationName, optionalWS, openParen, optionalWS, new Optional("optionalJsonValue", jsonValue), optionalWS, closeParen]);
+export const nameDecorationStatement = new Sequence("nameDecorationStatement", [at, optionalWS, decorationName]);
+export const decorationStatement = new Options("decorationStatement", [methodDecorationStatement, nameDecorationStatement]);
+
+export const defaultParamName = name.clone("defaultParamName");
+export const paramDefault = new Sequence("paramDefault", [optionalLS, assign, optionalLS, defaultParamName]);
+export const paramNameWithDefault = new Sequence("paramNameWithDefault", [patternName, new Optional("optionalParamDefault", paramDefault)]);
+export const useParamPatterns = new Repeat("useParamPatterns", paramNameWithDefault, { divider: comma, trimDivider: true });
+export const useParamsStatement = new Sequence("useParamsStatement", [useParams, optionalLS, openBracket, optionalWS, useParamPatterns, optionalWS, closeBracket]);
+
+export const withParamExportPattern = patternName.clone("withParamExportPattern");
+export const withParamStatement = new Options("withParamStatement", [new Reference("patternAssignment"), withParamExportPattern]);
+export const withParamStatements = new Repeat("withParamStatements", withParamStatement, { divider: newLine, trimDivider: true });
+export const withParamsExpr = new Sequence("withParamsExpr", [withParams, optionalLS, openBracket, optionalWS, withParamStatements, optionalWS, closeBracket]);
+
+export const importNameAlias = name.clone("importNameAlias");
+export const importAlias = new Sequence("importAlias", [patternName, ls, asKeyword, ls, importNameAlias]);
+export const importNameOrAlias = new Options("importNameOrAlias", [importAlias, patternName]);
+export const patternNames = new Repeat("patternNames", importNameOrAlias, { divider: comma, trimDivider: true });
+export const importedPatterns = new Sequence("importedPatterns", [openBracket, optionalWS, patternNames, optionalWS, closeBracket]);
+export const importStatement = new Sequence("importStatement", [imprt, optionalLS, importedPatterns, optionalLS, from, optionalLS, resource, optionalLS, new Optional("optionalWithParamsExpr", withParamsExpr)]);
+
+export const repeatBounds = new Sequence("repeatBounds", [openBracket, optionalWS, new Optional("optionalInteger", integer), optionalWS, new Optional("optionalComma", comma), optionalWS, new Optional("optionalInteger", integer), optionalWS, closeBracket]);
+export const oneOrMore = new Literal("oneOrMore", "+");
+export const zeroOrMore = new Literal("zeroOrMore", "*");
+export const repeatOptions = new Options("repeatOptions", [oneOrMore, zeroOrMore, repeatBounds]);
+export const delimiter = new Sequence("delimiter", [comma, new Reference("patternExpr"), optionalWS, new Optional("optionalTrim", trim)]);
+export const repeatExpr = new Sequence("repeatExpr", [openParen, optionalWS, new Reference("patternExpr"), optionalWS, new Optional("optionalDelimiter", delimiter), optionalWS, closeParen, repeatOptions]);
+
+export const takeUntilExpr = new Sequence("takeUntilExpr", [anyChar, optionalLS, upTo, optionalLS, wall, optionalLS, new Reference("patternExpr")]);
+
+export const sequenceExpr = new Sequence("sequenceExpr", [new Reference("patternExpr"), optionalWS, concat, optionalWS, new Reference("patternExpr")]);
+export const optionsExpr = new Sequence("optionsExpr", [new Reference("patternExpr"), optionalWS, bar, optionalWS, new Reference("patternExpr")]);
+export const greedyOptionsExpr = new Sequence("greedyOptionsExpr", [new Reference("patternExpr"), optionalWS, greedyBar, optionalWS, new Reference("patternExpr")]);
+export const patternGroupExpr = new Sequence("patternGroupExpr", [openParen, optionalWS, new Reference("patternExpr"), optionalWS, closeParen]);
+
+export const notExpr = new Sequence("notExpr", [not, optionalLS, new Reference("patternExpr")]);
+export const optionalExpr = new Sequence("optionalExpr", [new Reference("patternExpr"), optionalLS, optional]);
+export const rightAssociationExpr = new Sequence("rightAssociationExpr", [new Reference("patternExpr"), optionalLS, right]);
+
+export const exportPattern = patternName.clone("exportPattern");
+export const patternExpr = new Expression("patternExpr", [notExpr, optionalExpr, rightAssociationExpr, sequenceExpr, optionsExpr, greedyOptionsExpr, repeatExpr, patternGroupExpr, takeUntilExpr, literal, regex, patternIdentifier]);
+export const patternAssignment = new Sequence("patternAssignment", [patternName, optionalWS, assign, optionalWS, patternExpr]);
+export const statement = new Options("statement", [useParamsStatement, importStatement, patternAssignment, decorationStatement, exportPattern, comment]);
+export const statements = new Repeat("statements", statement, { divider: newLine });
+export const cpat = new Sequence("cpat", [optionalWS, new Optional("optionalSyntaxStatement", syntaxStatement), optionalWS, new Optional("optionalStatements", statements)]);
+
+export const grammar = cpat;

package/src/grammar/patterns.ts

@@ -1,7 +1,7 @@
 import { Pattern } from "../patterns/Pattern";
 import { Grammar, GrammarOptions } from "./Grammar";
 
-const kebabRegex = /-([a-z])/g; // Define the regex once
+const kebabRegex = /-([a-z])/g;
 
 function kebabToCamelCase(str: string) {
     return str.replace(kebabRegex, (_, char) => char.toUpperCase());
@@ -23,20 +23,20 @@ export function patterns(strings: TemplateStringsArray, ...values: any) {
     return result;
 }
 
-export function createPatternsTemplate(options: GrammarOptions){
+export function createPatternsTemplate(options: GrammarOptions) {
     return function patterns(strings: TemplateStringsArray, ...values: any) {
         const combinedString = strings.reduce(
             (result, str, i) => result + str + (values[i] || ''),
             ''
         );
-    
+
         const result: Record<string, Pattern> = {};
         const patterns = Grammar.parseString(combinedString, options);
-    
+
         Object.keys(patterns).forEach(k => {
             result[kebabToCamelCase(k)] = patterns[k];
         });
-    
+
         return result;
     };
-}
+}

package/src/grammar/patterns/anonymousPattern.ts

@@ -1,23 +0,0 @@
-import { Literal } from "../../patterns/Literal";
-import { Sequence } from "../../patterns/Sequence";
-import { lineSpaces } from "./spaces";
-import { anonymousLiterals, anonymousWrappedLiterals } from './literals';
-import { Options } from "../../patterns/Options";
-import { Optional } from "../../patterns/Optional";
-
-const inlinePatternOpenParen = new Literal("anonymous-pattern-open-paren", "(");
-const inlinePatternCloseParen = new Literal("anonymous-pattern-close-paren", ")");
-const optionalLineSpaces = new Optional("optional-line-spaces", lineSpaces);
-
-const complexAnonymousPattern = new Sequence("complex-anonymous-pattern", [
-    inlinePatternOpenParen,
-    optionalLineSpaces,
-    anonymousWrappedLiterals,
-    optionalLineSpaces,
-    inlinePatternCloseParen,
-]);
-
-export const anonymousPattern = new Options("anonymous-pattern", [
-    anonymousLiterals,
-    complexAnonymousPattern
-]);

package/src/grammar/patterns/body.ts

@@ -1,22 +0,0 @@
-import { Sequence } from "../../patterns/Sequence";
-import { Options } from "../../patterns/Options";
-import { Repeat } from "../../patterns/Repeat";
-import { comment } from "./comment";
-import { lineSpaces, newLine } from "./spaces";
-import { statement } from "./statement";
-import { Optional } from "../../patterns/Optional";
-
-const bodyLineContent = new Options("body-line-content", [
-    comment,
-    statement
-]);
-
-const optionalLineSpaces = new Optional("optional-line-spaces", lineSpaces);
-
-const bodyLine = new Sequence("body-line", [
-    optionalLineSpaces,
-    new Optional("optional-body-line-content", bodyLineContent),
-    optionalLineSpaces,
-]);
-
-export const body = new Optional("optional-body", new Repeat("body", bodyLine, { divider: newLine }));

package/src/grammar/patterns/comment.ts

@@ -1,4 +0,0 @@
-import { Regex } from "../../patterns/Regex";
-
-export const comment = new Regex("comment", "#[^\r\n]+");
-comment.setTokens(["# "]);

package/src/grammar/patterns/decoratorStatement.ts

@@ -1,85 +0,0 @@
-import { Literal } from "../../patterns/Literal";
-import { Optional } from "../../patterns/Optional";
-import { Options } from "../../patterns/Options";
-import { Reference } from "../../patterns/Reference";
-import { Regex } from "../../patterns/Regex";
-import { Repeat } from "../../patterns/Repeat";
-import { Sequence } from "../../patterns/Sequence";
-import { name } from "./name";
-import { allSpaces } from "./spaces";
-
-const colon = new Literal("colon", ":");
-const comma = new Regex("comma", "\\s*,\\s*");
-const openBracket = new Literal("open-bracket", "{");
-const closeBracket = new Literal("close-bracket", "}");
-const openSquareBracket = new Literal("open-square-bracket", "[");
-const closeSquareBracket = new Literal("close-square-bracket", "]");
-const optionalAllSpaces = new Optional("optional-all-spaces", allSpaces);
-
-const stringLiteral = new Regex("string-literal", '"(?:\\\\.|[^"\\\\])*"');
-const numberLiteral = new Regex("number-literal", '[+-]?\\d+(\\.\\d+)?([eE][+-]?\\d+)?');
-const nullLiteral = new Literal("null-literal", "null");
-const trueLiteral = new Literal("true-literal", "true");
-const falseLiteral = new Literal("false-literal", "false");
-const booleanLiteral = new Options("", [trueLiteral, falseLiteral]);
-
-const objectKey = stringLiteral.clone("object-key");
-const objectProperty = new Sequence("object-property", [
-    objectKey,
-    optionalAllSpaces,
-    colon,
-    optionalAllSpaces,
-    new Reference("literal"),
-]);
-const objectProperies = new Repeat("object-properties", objectProperty, { divider: comma });
-const objectLiteral = new Sequence("object-literal", [
-    openBracket,
-    optionalAllSpaces,
-    new Optional("optional-object-properties", objectProperies),
-    optionalAllSpaces,
-    closeBracket
-]);
-
-const arrayItems = new Repeat("array-items", new Reference("literal"), { divider: comma });
-const arrayLiteral = new Sequence("array-literal", [
-    openSquareBracket,
-    optionalAllSpaces,
-    new Optional("optional-array-items", arrayItems),
-    optionalAllSpaces,
-    closeSquareBracket,
-]);
-
-const literal = new Options("literal", [
-    objectLiteral,
-    arrayLiteral,
-    stringLiteral,
-    booleanLiteral,
-    nullLiteral,
-    numberLiteral,
-]);
-
-const decoratorPrefix = new Literal("decorator-prefix", "@");
-const decoratorName = name.clone("decorator-name");
-const openParen = new Literal("open-paren", "(");
-const closeParen = new Literal("close-paren", ")");
-
-const methodDecoration = new Sequence("method-decorator", [
-    decoratorPrefix,
-    decoratorName,
-    optionalAllSpaces,
-    openParen,
-    optionalAllSpaces,
-    new Optional("optional-args", literal),
-    optionalAllSpaces,
-    closeParen
-]);
-
-const nameDecoration = new Sequence("name-decorator", [
-    decoratorPrefix,
-    decoratorName,
-]);
-
-export const decoratorStatement = new Options("decorator-statement", [
-    methodDecoration,
-    nameDecoration,
-]);