grammar-well 1.3.2 → 2.0.0

package/build/generator/builtin/json.js

@@ -0,0 +1,124 @@
+function extractPair(kv, output) {
+    if (kv[0]) {
+        output[kv[0]] = kv[1];
+    }
+}
+function extractObject({ data }) {
+    let output = {};
+    extractPair(data[2], output);
+    for (let i in data[3]) {
+        extractPair(data[3][i][3], output);
+    }
+    return output;
+}
+function extractArray({ data }) {
+    let output = [data[2]];
+    for (let i in data[3]) {
+        output.push(data[3][i][3]);
+    }
+    return output;
+}
+class grammar {
+    artifacts = {
+        grammar: {
+            rules: {
+                _: [
+                    { name: "_", postprocess: ({ data }) => { return (null); }, symbols: ["_$RPT01x1"] }
+                ],
+                _$RPT01x1: [
+                    { name: "_$RPT01x1", postprocess: ({ data }) => data[0], symbols: [{ token: "whitespace" }] },
+                    { name: "_$RPT01x1", postprocess: () => null, symbols: [] }
+                ],
+                __: [
+                    { name: "__", postprocess: ({ data }) => { return (null); }, symbols: ["__$RPT1Nx1"] }
+                ],
+                __$RPT1Nx1: [
+                    { name: "__$RPT1Nx1", symbols: [{ token: "whitespace" }] },
+                    { name: "__$RPT1Nx1", postprocess: ({ data }) => data[0].concat([data[1]]), symbols: ["__$RPT1Nx1", { token: "whitespace" }] }
+                ],
+                array: [
+                    { name: "array", postprocess: ({ data }) => { return ([]); }, symbols: [{ literal: "[" }, "_", { literal: "]" }] },
+                    { name: "array", postprocess: extractArray, symbols: [{ literal: "[" }, "_", "value", "array$RPT0Nx1", "_", { literal: "]" }] }
+                ],
+                array$RPT0Nx1: [
+                    { name: "array$RPT0Nx1", symbols: [] },
+                    { name: "array$RPT0Nx1", postprocess: ({ data }) => data[0].concat([data[1]]), symbols: ["array$RPT0Nx1", "array$RPT0Nx1$SUBx1"] }
+                ],
+                array$RPT0Nx1$SUBx1: [
+                    { name: "array$RPT0Nx1$SUBx1", symbols: ["_", { literal: "," }, "_", "value"] }
+                ],
+                json: [
+                    { name: "json", postprocess: ({ data }) => { return (data[1][0]); }, symbols: ["_", "json$SUBx1", "_"] }
+                ],
+                json$SUBx1: [
+                    { name: "json$SUBx1", symbols: ["object"] },
+                    { name: "json$SUBx1", symbols: ["array"] }
+                ],
+                key: [
+                    { name: "key", postprocess: ({ data }) => { return (data[0]); }, symbols: ["string"] }
+                ],
+                number: [
+                    { name: "number", postprocess: ({ data }) => { return (parseFloat(data[0].value)); }, symbols: [{ token: "number" }] }
+                ],
+                object: [
+                    { name: "object", postprocess: ({ data }) => { return ({}); }, symbols: [{ literal: "{" }, "_", { literal: "}" }] },
+                    { name: "object", postprocess: extractObject, symbols: [{ literal: "{" }, "_", "pair", "object$RPT0Nx1", "_", { literal: "}" }] }
+                ],
+                object$RPT0Nx1: [
+                    { name: "object$RPT0Nx1", symbols: [] },
+                    { name: "object$RPT0Nx1", postprocess: ({ data }) => data[0].concat([data[1]]), symbols: ["object$RPT0Nx1", "object$RPT0Nx1$SUBx1"] }
+                ],
+                object$RPT0Nx1$SUBx1: [
+                    { name: "object$RPT0Nx1$SUBx1", symbols: ["_", { literal: "," }, "_", "pair"] }
+                ],
+                pair: [
+                    { name: "pair", postprocess: ({ data }) => { return ([data[0], data[4]]); }, symbols: ["key", "_", { literal: ":" }, "_", "value"] }
+                ],
+                string: [
+                    { name: "string", postprocess: ({ data }) => { return (JSON.parse(data[0].value)); }, symbols: [{ token: "string" }] }
+                ],
+                value: [
+                    { name: "value", postprocess: ({ data }) => { return (data[0]); }, symbols: ["object"] },
+                    { name: "value", postprocess: ({ data }) => { return (data[0]); }, symbols: ["array"] },
+                    { name: "value", postprocess: ({ data }) => { return (data[0]); }, symbols: ["number"] },
+                    { name: "value", postprocess: ({ data }) => { return (data[0]); }, symbols: ["string"] },
+                    { name: "value", postprocess: ({ data }) => { return (true); }, symbols: [{ literal: "true" }] },
+                    { name: "value", postprocess: ({ data }) => { return (false); }, symbols: [{ literal: "false" }] },
+                    { name: "value", postprocess: ({ data }) => { return (null); }, symbols: [{ literal: "null" }] }
+                ]
+            },
+            start: "json"
+        },
+        lexer: {
+            start: "json",
+            states: {
+                json: {
+                    regex: /(?:(?:(\s+))|(?:(-?(?:[0-9]|[1-9][0-9]+)(?:\.[0-9]+)?(?:[eE][-+]?[0-9]+)?\b))|(?:(\"(?:\\[\"bfnrt\/\\]|\\u[a-fA-F0-9]{4}|[^\"\\])*\"))|(?:((?:\{)))|(?:((?:\})))|(?:((?:\[)))|(?:((?:\])))|(?:((?:,)))|(?:((?::)))|(?:((?:true)))|(?:((?:false)))|(?:((?:null))))/ym,
+                    rules: [
+                        { tag: ["whitespace"], when: /\s+/ },
+                        { tag: ["number"], when: /-?(?:[0-9]|[1-9][0-9]+)(?:\.[0-9]+)?(?:[eE][-+]?[0-9]+)?\b/ },
+                        { tag: ["string"], when: /\"(?:\\[\"bfnrt\/\\]|\\u[a-fA-F0-9]{4}|[^\"\\])*\"/ },
+                        { tag: ["{"], when: "{" },
+                        { tag: ["}"], when: "}" },
+                        { tag: ["["], when: "[" },
+                        { tag: ["]"], when: "]" },
+                        { tag: [","], when: "," },
+                        { tag: [":"], when: ":" },
+                        { tag: ["true"], when: "true" },
+                        { tag: ["false"], when: "false" },
+                        { tag: ["null"], when: "null" }
+                    ]
+                },
+                whitespace: {
+                    regex: /(?:(?:(\s+)))/ym,
+                    rules: [
+                        { tag: ["whitespace"], when: /\s+/ }
+                    ]
+                }
+            }
+        }
+    };
+    constructor() { }
+}
+export default grammar;
+//# sourceMappingURL=json.js.map

package/build/generator/builtin/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../../../src/generator/builtin/json.ts"],"names":[],"mappings":"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"}

package/build/generator/builtin/registry.json

@@ -0,0 +1 @@
+{ "character": "lexer {\n\tstart: \"character\"\n\n\t[character]\n\t\t- when r:{.}\n\n}\n", "json": "import * from whitespace;\n\nlexer {\n\tstart: \"json\"\n\n\t[json]\n\t\t- import whitespace\n\t\t- when r:{-?(?:[0-9]|[1-9][0-9]+)(?:\\.[0-9]+)?(?:[eE][-+]?[0-9]+)?\\b} tag \"number\"\n\t\t- when r:{\"(?:\\\\[\"bfnrt/\\\\]|\\\\u[a-fA-F0-9]{4}|[^\"\\\\])*\"} tag \"string\"\n\t\t- when \"{\" tag \"{\"\n\t\t- when \"}\" tag \"}\"\n\t\t- when \"[\" tag \"[\"\n\t\t- when \"]\" tag \"]\"\n\t\t- when \",\" tag \",\"\n\t\t- when \":\" tag \":\"\n\t\t- when \"true\" tag \"true\"\n\t\t- when \"false\" tag \"false\"\n\t\t- when \"null\" tag \"null\"\n\n}\n\ngrammar {\n\tstart: \"json\"\n\n\t[json]\n\t\t| _ (object | array) _ => ( $1[0] )\n\n\t[object]\n\t\t| \"{\" _ \"}\" => ( {} )\n\t\t| \"{\" _ pair (_ \",\" _ pair)* _ \"}\" => ${ extractObject }\n\n\t[array]\n\t\t| \"[\" _ \"]\" => ( [] )\n\t\t| \"[\" _ value (_ \",\" _ value)* _ \"]\" => ${ extractArray }\n\n\t[value]\n\t\t| object => ( $0 )\n\t\t| array => ( $0 )\n\t\t| number => ( $0 )\n\t\t| string => ( $0 )\n\t\t| \"true\" => ( true )\n\t\t| \"false\" => ( false )\n\t\t| \"null\" => ( null )\n\n\t[number]\n\t\t| <number> => ( parseFloat($0.value) )\n\n\t[string]\n\t\t| <string> => ( JSON.parse($0.value) )\n\n\t[pair]\n\t\t| key@k _ \":\" _ value@v => ( [$k, $v] )\n\n\t[key]\n\t\t| string => ( $0 )\n\n}\n\non:import {\nfunction extractPair(kv, output) {\n        if(kv[0]) { output[kv[0]] = kv[1]; }\n    }\n\n    function extractObject({data}) {\n        let output = {};\n\n        extractPair(data[2], output);\n\n        for (let i in data[3]) {\n            extractPair(data[3][i][3], output);\n        }\n\n        return output;\n    }\n\n    function extractArray({data}) {\n        let output = [data[2]];\n\n        for (let i in data[3]) {\n            output.push(data[3][i][3]);\n        }\n\n        return output;\n    }\n}\n", "number": "grammar {\n\n\t[unsigned_int]\n\t\t| r:{[0-9]}+ => ( parseInt($0.join(\"\")) )\n\n\t[int]\n\t\t| (\"-\" | \"+\")? r:{[0-9]}+ => ( $0 ? parseInt($0[0]+$1.join(\"\")) : parseInt($1.join(\"\")) )\n\n\t[unsigned_decimal]\n\t\t| r:{[0-9]}+ (\".\" r:{[0-9]}+)? => ( parseFloat($0.join(\"\") + ($1 ? \".\"+$1[1].join(\"\") : \"\")) )\n\n\t[decimal]\n\t\t| \"-\"? r:{[0-9]}+ (\".\" r:{[0-9]}+)? => ( parseFloat( ($0 || \"\") + $1.join(\"\") +($2 ? \".\"+$2[1].join(\"\") : \"\")) )\n\n\t[percentage]\n\t\t| decimal \"%\" => ( $0/100 )\n\n\t[jsonfloat]\n\t\t| \"-\"? r:{[0-9]}+ (\".\" r:{[0-9]}+)? (r:{[eE]} r:{[+-]}? r:{[0-9]}+)? => ( parseFloat( ($0 || \"\") + $1.join(\"\") + ($2 ? \".\"+$2[1].join(\"\") : \"\") + ($3 ? \"e\" + ($3[1] || \"+\") + $3[2].join(\"\") : \"\")) )\n\n}\n", "string": "lexer {\n\n\t[string]\n\t\t- import singleQuoteString, doubleQuoteString\n\n\t[doubleQuoteString]\n\t\t- when \"\\\"\" tag \"dquote\" highlight \"string\" goto doubleQuoteStringEnd\n\n\t[singleQuoteString]\n\t\t- when \"'\" tag \"squote\" highlight \"string\" goto singleQuoteStringEnd\n\n\t[doubleQuoteStringEnd]\n\t\t- when r:{\\\\[\\\\/bnrft]} tag \"escaped\" highlight \"constant\"\n\t\t- when r:{\\\\\"} tag \"quoteEscape\"\n\t\t- when r:{\\\\u[A-Fa-f\\d]{4}} tag \"escaped\" highlight \"constant\"\n\t\t- when r:{\\\\.} tag \"badEscape\"\n\t\t- when r:{[^\"\\\\]+} tag \"string\" highlight \"string\"\n\t\t- when \"\\\"\" tag \"dquote\" highlight \"string\" pop\n\n\t[singleQuoteStringEnd]\n\t\t- when r:{\\\\[\\\\/bnrft]} tag \"escaped\"\n\t\t- when r:{\\\\'} tag \"quoteEscape\"\n\t\t- when r:{\\\\u[A-Fa-f\\d]{4}} tag \"escaped\"\n\t\t- when r:{\\\\.} tag \"badEscape\"\n\t\t- when r:{[^'\\\\]+} tag \"string\" highlight \"string\"\n\t\t- when \"'\" tag \"squote\" highlight \"string\" pop\n\n}\n\ngrammar {\n\n\t[string] => ( $0 )\n\t\t| singleQuoteString\n\t\t| doubleQuoteString\n\n\t[doubleQuoteString]\n\t\t| <dquote> stringInner <dquote> => ( $1 )\n\t\t| <dquote> <dquote> => ( '' )\n\n\t[singleQuoteString]\n\t\t| <squote> stringInner <squote> => ( $1 )\n\t\t| <squote> <squote> => ( '' )\n\n\t[stringInner]\n\t\t| stringEscape => ( $0 )\n\t\t| <string> => ( $0.value )\n\t\t| stringInner stringEscape => ( $0 + $1 )\n\t\t| stringInner <string> => ( $0 + $1.value )\n\n\t[stringEscape]\n\t\t| <escaped> => ( JSON.parse('\"' + $0.value + '\"') )\n\t\t| <quoteEscape> => ( $0.value[1] )\n\n}\n", "whitespace": "lexer {\n\n\t[whitespace]\n\t\t- when r:{\\s+} tag \"whitespace\"\n\n}\n\ngrammar {\n\n\t[_]\n\t\t| <whitespace>? => ( null )\n\n\t[__]\n\t\t| <whitespace>+ => ( null )\n\n}\n" }

package/build/generator/builtin/whitespace.d.ts

@@ -0,0 +1,61 @@
+declare class grammar {
+    artifacts: {
+        grammar: {
+            rules: {
+                _: {
+                    name: string;
+                    postprocess: ({ data }: {
+                        data: any;
+                    }) => any;
+                    symbols: string[];
+                }[];
+                _$RPT01x1: {
+                    name: string;
+                    postprocess: ({ data }: {
+                        data: any;
+                    }) => any;
+                    symbols: {
+                        token: string;
+                    }[];
+                }[];
+                __: {
+                    name: string;
+                    postprocess: ({ data }: {
+                        data: any;
+                    }) => any;
+                    symbols: string[];
+                }[];
+                __$RPT1Nx1: ({
+                    name: string;
+                    symbols: {
+                        token: string;
+                    }[];
+                    postprocess?: undefined;
+                } | {
+                    name: string;
+                    postprocess: ({ data }: {
+                        data: any;
+                    }) => any;
+                    symbols: (string | {
+                        token: string;
+                    })[];
+                })[];
+            };
+            start: string;
+        };
+        lexer: {
+            start: string;
+            states: {
+                whitespace: {
+                    regex: RegExp;
+                    rules: {
+                        tag: string[];
+                        when: RegExp;
+                    }[];
+                };
+            };
+        };
+    };
+    constructor();
+}
+export default grammar;

package/build/generator/builtin/whitespace.js

@@ -0,0 +1,37 @@
+class grammar {
+    artifacts = {
+        grammar: {
+            rules: {
+                _: [
+                    { name: "_", postprocess: ({ data }) => { return (null); }, symbols: ["_$RPT01x1"] }
+                ],
+                _$RPT01x1: [
+                    { name: "_$RPT01x1", postprocess: ({ data }) => data[0], symbols: [{ token: "whitespace" }] },
+                    { name: "_$RPT01x1", postprocess: () => null, symbols: [] }
+                ],
+                __: [
+                    { name: "__", postprocess: ({ data }) => { return (null); }, symbols: ["__$RPT1Nx1"] }
+                ],
+                __$RPT1Nx1: [
+                    { name: "__$RPT1Nx1", symbols: [{ token: "whitespace" }] },
+                    { name: "__$RPT1Nx1", postprocess: ({ data }) => data[0].concat([data[1]]), symbols: ["__$RPT1Nx1", { token: "whitespace" }] }
+                ]
+            },
+            start: "_"
+        },
+        lexer: {
+            start: "whitespace",
+            states: {
+                whitespace: {
+                    regex: /(?:(?:(\s+)))/ym,
+                    rules: [
+                        { tag: ["whitespace"], when: /\s+/ }
+                    ]
+                }
+            }
+        }
+    };
+    constructor() { }
+}
+export default grammar;
+//# sourceMappingURL=whitespace.js.map

package/build/generator/builtin/whitespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"whitespace.js","sourceRoot":"","sources":["../../../src/generator/builtin/whitespace.ts"],"names":[],"mappings":"AAMA,MAAM,OAAO;IACT,SAAS,GAAI;QACT,OAAO,EAAE;YACL,KAAK,EAAE;gBACH,CAAC,EAAE;oBACC,EAAE,IAAI,EAAE,GAAG,EAAE,WAAW,EAAE,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAE,WAAW,CAAE,EAAE;iBACvF;gBACD,SAAS,EAAE;oBACP,EAAE,IAAI,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAE,EAAE,KAAK,EAAE,YAAY,EAAE,CAAE,EAAE;oBAC7F,EAAE,IAAI,EAAE,WAAW,EAAE,WAAW,EAAE,GAAG,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAG,EAAE;iBAC/D;gBACD,EAAE,EAAE;oBACA,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAE,YAAY,CAAE,EAAE;iBACzF;gBACD,UAAU,EAAE;oBACR,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,CAAE,EAAE,KAAK,EAAE,YAAY,EAAE,CAAE,EAAE;oBAC5D,EAAE,IAAI,EAAE,YAAY,EAAE,WAAW,EAAE,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAE,YAAY,EAAE,EAAE,KAAK,EAAE,YAAY,EAAE,CAAE,EAAE;iBACjI;aACJ;YACD,KAAK,EAAE,GAAG;SACb;QACD,KAAK,EAAE;YACH,KAAK,EAAE,YAAY;YACnB,MAAM,EAAE;gBACJ,UAAU,EAAE;oBACR,KAAK,EAAE,iBAAiB;oBACxB,KAAK,EAAE;wBACH,EAAE,GAAG,EAAE,CAAC,YAAY,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE;qBACvC;iBACJ;aACJ;SACJ;KACJ,CAAA;IACD,gBAAc,CAAC;CAClB;AAED,eAAe,OAAO,CAAC"}

package/build/generator/generator.d.ts

@@ -0,0 +1,38 @@
+import { ASTDirectives, GeneratorContext, GeneratorOptions, GeneratorOutputOptions, GenerateOptions } from "../typings/index.js";
+import { GeneratorState } from "./state.js";
+export declare function Generate(source: string, config?: GenerateOptions): Promise<ReturnType<Generator['output']>>;
+export declare function Generate(directive: ASTDirectives, config?: GenerateOptions): Promise<ReturnType<Generator['output']>>;
+export declare function Generate(directives: ASTDirectives[], config?: GenerateOptions): Promise<ReturnType<Generator['output']>>;
+export declare const NAME_DELIMITER = ".";
+export declare class Generator {
+    private config;
+    private context;
+    private aliasPrefix;
+    private state;
+    constructor(config?: GeneratorOptions, context?: GeneratorContext, aliasPrefix?: string);
+    import(source: string): Promise<void>;
+    import(directive: ASTDirectives): Promise<void>;
+    import(directives: ASTDirectives[]): Promise<void>;
+    import(directives: string | ASTDirectives | (ASTDirectives[])): Promise<void>;
+    output(options: GeneratorOutputOptions): string | {
+        state: GeneratorState;
+        output: GeneratorOutputOptions;
+    };
+    private processImportDirective;
+    private processLifecycleDirective;
+    private processConfigDirective;
+    private processLexerDirective;
+    private importLexerStates;
+    private importLexerState;
+    private buildLexerSpanStates;
+    private processGrammarDirective;
+    private importBuiltIn;
+    private importGrammar;
+    private mergeGrammar;
+    private buildRules;
+    private buildRule;
+    private buildSymbol;
+    private buildCharacterRules;
+    private buildSubExpressionRules;
+    private buildRepeatRules;
+}

package/build/generator/generator.js

@@ -0,0 +1,368 @@
+import { Parse } from "../parser/parse.js";
+import GrammarV1 from './grammars/v1.js';
+import GrammarV2 from './grammars/v2.js';
+import BuiltInRegistry from "./builtin/registry.json" with { type: 'json' };
+import { GeneratorState } from "./state.js";
+import { ExportsRegistry } from "./stringify/exports/registry.js";
+import { JavaScriptGenerator } from "./stringify/javascript.js";
+import { BrowserImportResolver } from "./import-resolvers/browser.js";
+export async function Generate(source, config = {}) {
+    const builder = new Generator(config);
+    await builder.import(source);
+    return builder.output(config.output);
+}
+export const NAME_DELIMITER = '.';
+export class Generator {
+    config;
+    context;
+    aliasPrefix;
+    state = new GeneratorState();
+    constructor(config = {}, context = {
+        imported: new Set(),
+        resolver: undefined,
+        state: undefined
+    }, aliasPrefix = '') {
+        this.config = config;
+        this.context = context;
+        this.aliasPrefix = aliasPrefix;
+        if (typeof config.resolver == 'function') {
+            this.context.resolver = new config.resolver(config.basedir);
+        }
+        else if (config.resolver && typeof config.resolver.path == 'function' && typeof config.resolver.body == 'function') {
+            this.context.resolver = config.resolver;
+        }
+        else {
+            this.context.resolver == new BrowserImportResolver(config.basedir);
+        }
+        if (this.context.state?.grammar) {
+            this.state.initializeGrammar();
+            this.state.grammar.uuids = context.state.grammar.uuids;
+        }
+    }
+    async import(directives) {
+        if (typeof directives == 'string') {
+            await this.mergeGrammar(directives);
+            return;
+        }
+        directives = Array.isArray(directives) ? directives : [directives];
+        for (const directive of directives) {
+            if ("lifecycle" in directive) {
+                await this.processLifecycleDirective(directive);
+            }
+            else if ("import" in directive) {
+                await this.processImportDirective(directive);
+            }
+            else if ("config" in directive) {
+                this.processConfigDirective(directive);
+            }
+            else if ("grammar" in directive) {
+                this.processGrammarDirective(directive);
+            }
+            else if ("lexer" in directive) {
+                this.processLexerDirective(directive);
+            }
+        }
+    }
+    output(options) {
+        const format = options?.format || 'esm';
+        if (!ExportsRegistry[format]) {
+            throw new Error("No such output format: " + format);
+        }
+        const generator = new JavaScriptGenerator(this.state, options);
+        return ExportsRegistry[format](generator);
+    }
+    async processImportDirective(directive) {
+        if (directive.path) {
+            await this.importGrammar(directive.import, this.aliasPrefix + (directive.alias || ''));
+        }
+        else {
+            await this.importBuiltIn(directive.import, this.aliasPrefix + (directive.alias || ''));
+        }
+    }
+    async processLifecycleDirective(directive) {
+        this.state.addLifecycle(directive.lifecycle, directive.js.js);
+    }
+    processConfigDirective(directive) {
+        Object.assign(this.state.config, directive.config);
+    }
+    processLexerDirective(directive) {
+        this.state.initializeLexer();
+        if (directive.lexer.start) {
+            this.state.lexer.start = this.aliasPrefix + directive.lexer.start;
+        }
+        if (!this.state.lexer.start && directive.lexer.states.length) {
+            this.state.lexer.start = this.aliasPrefix + directive.lexer.states[0].name;
+        }
+        this.importLexerStates(directive.lexer.states);
+    }
+    importLexerStates(states) {
+        for (let state of states) {
+            this.importLexerState(state.name, state.state);
+        }
+    }
+    importLexerState(name, state) {
+        if ('span' in state) {
+            this.state.addLexerState(this.aliasPrefix + name, { rules: [{ import: [`${name}${NAME_DELIMITER}start`] }] });
+            const states = this.buildLexerSpanStates(name, state);
+            this.importLexerStates(states);
+        }
+        else {
+            if (state.default && state.unmatched) {
+                state.unmatched.type = typeof state.unmatched.type != 'undefined' ? state.unmatched.type : state.default?.type;
+                state.unmatched.tag = typeof state.unmatched.tag != 'undefined' ? state.unmatched.tag : state.default?.tag;
+                state.unmatched.open = typeof state.unmatched.open != 'undefined' ? state.unmatched.open : state.default?.open;
+                state.unmatched.close = typeof state.unmatched.close != 'undefined' ? state.unmatched.close : state.default?.close;
+                state.unmatched.highlight = typeof state.unmatched.highlight != 'undefined' ? state.unmatched.highlight : state.default?.highlight;
+            }
+            const rules = [];
+            for (const rule of state.rules) {
+                if ('span' in rule) {
+                    let i = 1;
+                    while (`${this.aliasPrefix}${name}${NAME_DELIMITER}${i}` in this.state.lexer.states)
+                        ++i;
+                    const states = this.buildLexerSpanStates(`${name}${NAME_DELIMITER}${i}`, rule);
+                    this.importLexerStates(states);
+                    rules.push({ import: `${name}.${i}${NAME_DELIMITER}start` });
+                    continue;
+                }
+                else {
+                    if (this.aliasPrefix) {
+                        if ('import' in rule) {
+                            rule.import = rule.import.map(v2 => this.aliasPrefix + v2);
+                        }
+                        if ('set' in rule) {
+                            rule.set = this.aliasPrefix + rule.set;
+                        }
+                        if ('goto' in rule) {
+                            rule.goto = this.aliasPrefix + rule.goto;
+                        }
+                    }
+                    if ('when' in rule && state.default) {
+                        rule.type = typeof rule.type != 'undefined' ? rule.type : state.default?.type;
+                        rule.tag = typeof rule.tag != 'undefined' ? rule.tag : state.default?.tag;
+                        rule.open = typeof rule.open != 'undefined' ? rule.open : state.default?.open;
+                        rule.close = typeof rule.close != 'undefined' ? rule.close : state.default?.close;
+                        rule.highlight = typeof rule.highlight != 'undefined' ? rule.highlight : state.default?.highlight;
+                    }
+                    rules.push(rule);
+                }
+            }
+            this.state.addLexerState(this.aliasPrefix + name, { ...state, rules });
+        }
+    }
+    buildLexerSpanStates(name, rule) {
+        const transition = rule.config?.transition == 'set' ? 'set' : 'goto';
+        const startRules = [];
+        const spanRules = [];
+        const stopRules = [];
+        const start = rule.span.find(v => v.name == 'start');
+        const span = rule.span.find(v => v.name == 'span');
+        const stop = rule.span.find(v => v.name == 'stop');
+        if (span?.state?.rules)
+            for (const r of span?.state?.rules) {
+                spanRules.push(r);
+            }
+        if (stop?.state?.rules)
+            for (const r of stop?.state?.rules) {
+                if ('when' in r) {
+                    stopRules.push({
+                        when: r.when,
+                        type: r.type,
+                        tag: r.tag,
+                        before: r.before,
+                        skip: r.skip,
+                        highlight: r.highlight,
+                        open: r.open,
+                        close: r.close,
+                        embed: r.embed,
+                        unembed: r.unembed,
+                        set: r.skip ? undefined : r.set,
+                        pop: r.skip || r.set ? undefined : 1
+                    });
+                }
+                if ('import' in r) {
+                    stopRules.push({
+                        import: r.import,
+                        set: r.set,
+                        pop: r.set ? undefined : 1
+                    });
+                }
+            }
+        if (stopRules.length && spanRules.length)
+            spanRules.push({ import: [`${name}${NAME_DELIMITER}stop`] });
+        const target = spanRules.length ? 'span' : 'stop';
+        for (const r of start?.state?.rules) {
+            if ('when' in r) {
+                startRules.push({
+                    when: r.when,
+                    skip: r.skip,
+                    type: r.type,
+                    tag: r.tag,
+                    before: r.before,
+                    highlight: r.highlight,
+                    open: r.open,
+                    close: r.close,
+                    embed: r.embed,
+                    unembed: r.unembed,
+                    [transition]: r.stay ? undefined : `${name}${NAME_DELIMITER}${target}`
+                });
+            }
+            if ('import' in r) {
+                startRules.push({
+                    import: r.import,
+                    [transition]: r.stay ? undefined : `${name}${NAME_DELIMITER}${target}`
+                });
+            }
+        }
+        return [
+            {
+                name: `${name}${NAME_DELIMITER}start`,
+                state: {
+                    default: start.state.default,
+                    rules: startRules
+                }
+            },
+            {
+                name: `${name}${NAME_DELIMITER}span`,
+                state: {
+                    default: span?.state?.default,
+                    unmatched: span?.state?.unmatched,
+                    rules: spanRules
+                }
+            },
+            {
+                name: `${name}${NAME_DELIMITER}stop`,
+                state: {
+                    default: stop?.state?.default,
+                    rules: stopRules
+                }
+            }
+        ];
+    }
+    processGrammarDirective(directive) {
+        this.state.initializeGrammar();
+        if (directive.grammar.config) {
+            if (directive.grammar.config.start) {
+                this.state.grammar.start = this.aliasPrefix + directive.grammar.config.start;
+            }
+            Object.assign(this.state.grammar.config, directive.grammar.config);
+        }
+        if (!this.state.grammar.start && directive.grammar.rules.length) {
+            this.state.grammar.start = this.aliasPrefix + directive.grammar.rules[0].name;
+        }
+        for (const rule of directive.grammar.rules) {
+            rule.name = this.aliasPrefix + rule.name;
+            this.buildRules(rule.name, rule.expressions, rule);
+        }
+    }
+    async importBuiltIn(name, alias) {
+        name = name.toLowerCase();
+        if (!this.context.imported.has(name)) {
+            this.context.imported.add(name);
+            if (!BuiltInRegistry[name])
+                return;
+            await this.mergeGrammar(BuiltInRegistry[name], alias);
+        }
+    }
+    async importGrammar(path, alias) {
+        const resolver = this.context.resolver;
+        const fullPath = resolver.path(path);
+        if (!this.context.imported.has(fullPath)) {
+            this.context.imported.add(fullPath);
+            await this.mergeGrammar(await resolver.body(fullPath), alias);
+        }
+    }
+    async mergeGrammar(body, alias = '') {
+        const grammar = body.indexOf('// Grammar Well Version 1') == 0 ? GrammarV1 : GrammarV2;
+        const generator = new Generator(this.config, { ...this.context, state: this.state }, alias);
+        await generator.import(Parse(new grammar(), body));
+        this.state.merge(generator.state);
+        return;
+    }
+    buildRules(name, expressions, rule) {
+        for (const expression of expressions) {
+            this.state.addGrammarRule(this.buildRule(name, expression, rule));
+        }
+    }
+    buildRule(name, expression, rule) {
+        const symbols = [];
+        for (let i = 0; i < expression.symbols.length; i++) {
+            const symbol = this.buildSymbol(name, expression.symbols[i]);
+            if (symbol)
+                symbols.push(symbol);
+        }
+        return { name, symbols, postprocess: expression.postprocess || rule?.postprocess };
+    }
+    buildSymbol(name, symbol) {
+        if ('repeat' in symbol) {
+            return this.buildRepeatRules(name, symbol);
+        }
+        if ('rule' in symbol) {
+            return { ...symbol, rule: this.aliasPrefix + symbol.rule };
+        }
+        if ('regex' in symbol) {
+            return symbol;
+        }
+        if ('token' in symbol) {
+            return symbol;
+        }
+        if ('literal' in symbol) {
+            if (!symbol.literal.length) {
+                return null;
+            }
+            if (symbol.literal.length === 1 || this.state.lexer) {
+                return symbol;
+            }
+            return this.buildCharacterRules(name, symbol);
+        }
+        if ('subexpression' in symbol) {
+            return this.buildSubExpressionRules(name, symbol);
+        }
+    }
+    buildCharacterRules(name, symbol) {
+        const id = this.state.grammarUUID(name + NAME_DELIMITER + "STR");
+        this.buildRules(id, [
+            {
+                symbols: symbol.literal
+                    .split("")
+                    .map((literal) => {
+                    if (symbol.insensitive && literal.toLowerCase() != literal.toUpperCase())
+                        return { regex: literal, flags: 'i' };
+                    return { literal };
+                }),
+                postprocess: { builtin: "join" }
+            }
+        ]);
+        return { rule: id };
+    }
+    buildSubExpressionRules(name, symbol) {
+        const id = this.state.grammarUUID(name + NAME_DELIMITER + "SUB");
+        this.buildRules(id, symbol.subexpression);
+        return { rule: id };
+    }
+    buildRepeatRules(name, symbol) {
+        let id;
+        const expr1 = { symbols: [] };
+        const expr2 = { symbols: [] };
+        if (symbol.repeat == '+') {
+            id = this.state.grammarUUID(name + NAME_DELIMITER + "RPT1N");
+            expr1.symbols = [symbol.expression];
+            expr2.symbols = [{ rule: id }, symbol.expression];
+            expr2.postprocess = { builtin: "concat" };
+        }
+        else if (symbol.repeat == '*') {
+            id = this.state.grammarUUID(name + NAME_DELIMITER + "RPT0N");
+            expr2.symbols = [{ rule: id }, symbol.expression];
+            expr2.postprocess = { builtin: "concat" };
+        }
+        else if (symbol.repeat == '?') {
+            id = this.state.grammarUUID(name + NAME_DELIMITER + "RPT01");
+            expr1.symbols = [symbol.expression];
+            expr1.postprocess = { builtin: "first" };
+            expr2.postprocess = { builtin: "null" };
+        }
+        this.buildRules(id, [expr1, expr2]);
+        return { rule: id };
+    }
+}
+//# sourceMappingURL=generator.js.map