clarity-pattern-parser 11.4.0 → 11.4.2

package/dist/intellisense/AutoComplete.d.ts

@@ -42,7 +42,7 @@ export declare class AutoComplete {
    * ie. sequence pattern segments ≈ [{look}, {an example}, {phrase}]
    * fullText = "look an"
    * remove {look} segment as its already been completed by the existing text.
- */
+  */
     private _filterCompletedSubSegments;
     private _getCompositeSuggestionsForPattern;
     private _getCustomTokens;

package/dist/patterns/Cursor.d.ts

@@ -4,6 +4,8 @@ import { ParseError } from "./ParseError";
 import { Pattern } from "./Pattern";
 export declare class Cursor {
     private _text;
+    private _charSize;
+    private _charMap;
     private _index;
     private _length;
     private _history;
@@ -33,10 +35,13 @@ export declare class Cursor {
     moveToFirstChar(): void;
     moveToLastChar(): void;
     getLastIndex(): number;
-    getChars(first: number, last: number): string;
+    substring(first: number, last: number): string;
     recordMatch(pattern: Pattern, node: Node): void;
     recordErrorAt(startIndex: number, lastIndex: number, onPattern: Pattern): void;
     resolveError(): void;
     startRecording(): void;
     stopRecording(): void;
+    getCharStartIndex(index: number): number;
+    getCharEndIndex(index: number): number;
+    getCharLastIndex(index: number): number;
 }

package/dist/patterns/Literal.d.ts

@@ -8,10 +8,8 @@ export declare class Literal implements Pattern {
     private _name;
     private _parent;
     private _token;
-    private _runes;
     private _firstIndex;
     private _lastIndex;
-    private _endIndex;
     get id(): string;
     get type(): string;
     get name(): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clarity-pattern-parser",
-  "version": "11.4.0",
+  "version": "11.4.2",
   "description": "Parsing Library for Typescript and Javascript.",
   "main": "./dist/index.js",
   "module": "./dist/index.esm.js",

package/src/grammar_v2/patterns/Grammar.ts

@@ -0,0 +1,170 @@
+import { Node } from "../../ast/Node";
+import { tokens } from "../../grammar/decorators/tokens";
+import { GrammarFile } from "../../grammar/Grammar";
+import { generateErrorMessage } from "../../patterns/generate_error_message";
+import { Pattern } from "../../patterns/Pattern";
+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 = {
+    tokens: tokens
+};
+
+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 };
+    }
+
+    getImportedPatterns() {
+        return Array.from(this.importedPatternsByName.values());
+    }
+
+    getParams() {
+        return Array.from(this.paramsByName.values());
+    }
+
+}
+
+export class Grammar {
+    private _options: GrammarOptions;
+    private _parseContext: ParseContext;
+    private _resolveImportSync: (resource: string, originResource: string | null) => GrammarFile;
+
+    constructor(options: GrammarOptions) {
+        this._options = options;
+        this._parseContext = new ParseContext(options.params || [], options.decorators || {});
+        this._resolveImportSync = options.resolveImportSync == null ? defaultImportResolverSync : options.resolveImportSync;
+    }
+
+    // parse(cpat: string): Promise<Pattern> { }
+    // import(path: string): Promise<Pattern> { }
+
+    // parseString(cpat: string): Pattern {
+    //     const ast = this._tryToParse(cpat);
+
+    //     this._flattenExpressions(ast);
+
+    // }
+
+    private _resolveImportsSync(ast: Node) {
+        const importStatements = ast.findAll(n => {
+            return n.name === "importStatement" || n.name === "useParamsStatement";
+        });
+
+        for (const importStatement of importStatements) {
+            if (importStatement.name === "importStatement") {
+                this._processImportSync(importStatement);
+            } else {
+                this._processUseParams(importStatement);
+            }
+        }
+    }
+
+    private _processImportSync(importStatement: Node) {
+        const parseContext = this._parseContext;
+        const resourceNode = importStatement.find(n => n.name === "resource") as Node;
+        const params = this._getWithParams(importStatement);
+        const resource = resourceNode.value.slice(1, -1);
+        const grammarFile = this._resolveImportSync(resource, this._options.originResource || null);
+
+
+        if (resourceNode == null) {
+            throw new Error("Invalid import statement: resource is required");
+        }
+
+
+    }
+
+    private _getWithParams(importStatement: Node) {
+        const withParamsStatements = importStatement.find(n => n.name === "withParamsStatements");
+
+        if (withParamsStatements == null) {
+            return [];
+        }
+
+        const expression = withParamsStatements.toString();
+        const importedValues = this._parseContext.getImportedPatterns();
+
+        const grammar = new Grammar({
+            params: [...importedValues, ...this._parseContext.paramsByName.values()],
+            originResource: this._options.originResource,
+            resolveImport: this._options.resolveImport,
+            decorators: this._parseContext.decorators
+        });
+
+        // const patterns = grammar.parseString(expression);
+        // return Array.from(Object.values(patterns));
+        return[]
+    }
+
+
+    private _processUseParams(useParamsStatement: Node) {
+    }
+
+    private _tryToParse(cpat: string): Node {
+        const { ast, cursor } = grammar.exec(cpat, true);
+
+        if (ast == null) {
+            const message = generateErrorMessage(grammar, cursor);
+            throw new Error(`[Invalid Grammar] ${message}`);
+        }
+
+        return ast;
+    }
+
+
+    private _flattenExpressions(node: Node) {
+        switch (node.name) {
+            case "sequenceExpr":
+                return this._unwrapNode("sequenceExpr", node);
+            case "optionsExpr":
+                return this._unwrapNode("optionsExpr", node);
+            case "greedyOptionsExpr":
+                return this._unwrapNode("greedyOptionsExpr", node);
+            default:
+                return node;
+        }
+    }
+
+    private _unwrapNode(type: string, node: Node) {
+        if (node.name !== type) {
+            return 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--;
+            }
+        }
+
+        return node;
+    }
+}

package/src/grammar_v2/patterns/patterns/cpat.cpat

@@ -0,0 +1,91 @@
+# syntax
+syntax = "syntax"
+import = "import"
+useParams = "use params"
+withParams = "with params"
+from = "from"
+right = "right"
+ws = /\s+/
+ls = /[ \t]+/
+assign = "="
+bar = "|"
+concat = "+"
+colon = ":"
+openParen = "("
+closeParen = ")"
+openSquareBracket = "["
+closeSquareBracket = "]"
+openBracket = "{"
+closeBracket = "}"
+comma = /\s*[,]\s*/
+trim = "trim"
+not = "!"
+optional = "?"
+newLine = /\s*(\r\n|\r|\n)\s*/
+syntaxVersion = /\S*/
+at = "@"
+
+literal = /"(?:\\.|[^"\\])*"/
+regexLiteral = /\/(\\/|[^\n\r])*\//
+
+integer = /[1-9][0-9]*|[0]/ 
+name = /[a-zA-Z_-]+[a-zA-Z0-9_-]*/
+patternName = name
+patternIdentifier = name
+resource = literal
+
+comment = /#[^\n\r]*/
+
+# JSON
+jsonString = literal
+jsonNumber = /-?\d+(\.\d+)?/
+jsonBoolean = "true" | "false"
+jsonNull = "null"
+jsonValue = jsonString | jsonNumber | jsonBoolean | jsonNull | jsonArray | jsonObject
+jsonArrayItems = (jsonValue, comma trim)+
+jsonArray = openSquareBracket +ws? + jsonArrayItems? + ws? + closeSquareBracket
+jsonObjectPropertyName = literal
+jsonObjectProperty = jsonObjectPropertyName + ws? + colon + ws? + jsonValue
+jsonObjectProperties = (jsonObjectProperty, comma trim)+
+jsonObject = openBracket + ws? + jsonObjectProperties? + ws? + closeBracket
+
+syntaxStatement = syntax + ws? + syntaxVersion
+
+decorationName = name
+decorationStatement = at + ws? + decorationName + ws? + openParen + ws? + jsonValue? + ws? + closeParen
+
+useParamPatterns = (patternName, comma trim)+
+useParamsStatement = useParams + ls? + openBracket + ws? + useParamPatterns + ws? + closeBracket
+
+withParamStatements = (patternAssignment, newLine trim)+
+withParamsExpr = withParams + ls? + openBracket + ws? + withParamStatements + ws? + closeBracket
+
+patternNames = (patternName, comma trim)+
+importedPatterns = openBracket + ws? + patternNames + ws? + closeBracket 
+importStatement = import + ls? + importedPatterns + ls? + from + ls? + resource + ls? + withParamsExpr?
+
+notExpr = not + ls? + unaryPatternExpr
+optionalExpr = unaryPatternExpr + ls? + optional
+rightAssociationExpr = unaryPatternExpr + ls? + right
+
+unaryPatternExpr = notExpr | optionalExpr | rightAssociationExpr | patternIdentifier
+
+repeatBounds = openBracket + integer? + comma? + integer? + closeBracket
+oneOrMore = "+"
+zeroOrMore = "*"
+repeatOptions = oneOrMore | zeroOrMore | repeatBounds
+delimiter = comma + patternExpr + ws? + trim?
+repeatExpr = openParen + ws? + patternExpr + ws? + delimiter? + ws? + closeParen + repeatOptions
+
+sequenceExpr = patternExpr + ws? + "+" + ws? + patternExpr 
+optionsExpr = patternExpr + ws? + "|" + ws? + patternExpr
+greedyOptionsExpr = patternExpr + ws? + "<|>" + ws? + patternExpr
+patternGroupExpr = openParen + ws? + patternExpr + ws? + closeParen
+
+exportPattern = patternName
+patternExpr =  sequenceExpr | optionsExpr | greedyOptionsExpr |  repeatExpr | patternGroupExpr | literal | regexLiteral | unaryPatternExpr 
+patternAssignment = patternName + ws? + assign + ws? + patternExpr
+statement = useParamsStatement | importStatement  | patternAssignment | decorationStatement | exportPattern | comment 
+statements = (statement, newLine)+
+cpat = ws? + syntaxStatement? + ws? + statements?
+

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

@@ -0,0 +1,218 @@
+import fs from "fs";
+import { grammar } from "./grammar";
+import path from "path";
+import { Node } from "../../../ast/Node";
+
+const dir = path.join(__dirname, "./cpat.cpat");
+
+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("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)+");
+    });
+
+
+});

package/src/grammar_v2/patterns/patterns/grammar.ts

@@ -0,0 +1,103 @@
+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 { Sequence } from "../../../patterns/Sequence";
+
+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 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, 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 decorationStatement = new Sequence("decorationStatement", [at, optionalWS, decorationName, optionalWS, openParen, optionalWS, jsonValue, optionalWS, closeParen]);
+
+export const useParamPatterns = new Repeat("useParamPatterns", patternName, { divider: comma, trimDivider: true });
+export const useParamsStatement = new Sequence("useParamsStatement", [useParams, optionalLS, openBracket, optionalWS, useParamPatterns, optionalWS, closeBracket]);
+
+export const withParamStatements = new Repeat("withParamStatements", new Reference("patternAssignment"), { divider: newLine, trimDivider: true });
+export const withParamsExpr = new Sequence("withParamsExpr", [withParams, optionalLS, openBracket, optionalWS, withParamStatements, optionalWS, closeBracket]);
+
+export const patternNames = new Repeat("patternNames", patternName, { 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 notExpr = new Sequence("notExpr", [not, optionalLS, new Reference("unaryPatternExpr")]);
+export const optionalExpr = new Sequence("optionalExpr", [new Reference("unaryPatternExpr"), optionalLS, optional]);
+export const rightAssociationExpr = new Sequence("rightAssociationExpr", [new Reference("unaryPatternExpr"), optionalLS, right]);
+export const unaryPatternExpr = new Expression("unaryPatternExpr", [notExpr, optionalExpr, rightAssociationExpr, patternIdentifier]);
+
+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 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 exportPattern = patternName.clone("exportPattern");
+export const patternExpr = new Expression("patternExpr", [sequenceExpr, optionsExpr, greedyOptionsExpr, repeatExpr, patternGroupExpr, literal, regex, unaryPatternExpr]);
+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/intellisense/AutoComplete.test.ts

@@ -194,7 +194,7 @@ describe("AutoComplete", () => {
 
         expect(result.ast).toBeNull();
         optionsMatchExpected(result.options, expectedOptions);
-        expect(result.errorAtIndex).toBe(text.length);
+        expect(result.errorAtIndex).toBe(text.length - 1);
         expect(result.isComplete).toBeFalsy();
         expect(result.cursor).not.toBeNull();
     });
@@ -313,7 +313,7 @@ describe("AutoComplete", () => {
 
         expect(result.ast).toBeNull();
         optionsMatchExpected(result.options, expectedOptions);
-        expect(result.errorAtIndex).toBe(2);
+        expect(result.errorAtIndex).toBe(1);
         expect(result.isComplete).toBeFalsy();
         expect(result.cursor).not.toBeNull();
     });
@@ -944,7 +944,7 @@ describe("AutoComplete", () => {
 
         optionsMatchExpected(suggestion.options, expected);
 
-        expect(suggestion.error?.lastIndex).toBe(2);
+        expect(suggestion.error?.lastIndex).toBe(1);
     });
 
     test("Recursion With And", () => {