grammar-well 1.3.2 → 2.0.0

package/src/compiler/generator/artifacts/standard.ts

@@ -1,26 +0,0 @@
-import { GeneratorGrammarRule, } from "../../../typings";
-import { Generator } from "../generator";
-
-export class StandardGrammar {
-
-    constructor(private generator: Generator) { }
-
-    serialize(depth: number = 0) {
-        if (!this.generator.state.grammar) {
-            return null;
-        }
-        return Generator.Pretty({
-            start: JSON.stringify(this.generator.state.grammar.start),
-            rules: this.serializeGrammarRules(depth + 1)
-        }, depth);
-    }
-
-    private serializeGrammarRules(depth: number = 0) {
-        const map = {};
-        for (const rule in this.generator.state.grammar.rules) {
-            map[rule] = this.generator.state.grammar.rules[rule].map(v => this.generator.serializeGrammarRule(v))
-        }
-        return Generator.Pretty(map, depth);
-    }
-
-}

package/src/compiler/generator/generator.ts

@@ -1,237 +0,0 @@
-import { Dictionary, GeneratorState, GeneratorGrammarRule, GeneratorGrammarSymbol, LexerConfig, LexerStateDefinition } from "../../typings";
-import { LRParseTableBuilder } from "./artifacts/lr";
-import { StandardGrammar } from "./artifacts/standard";
-
-const PostProcessors = {
-    "join": "({data}) => data.join('')",
-    "concat": "({data}) => data[0].concat([data[1]])",
-    "null": "() => null",
-    "first": "({data}) => data[0]"
-};
-
-export class Generator {
-
-    state: GeneratorState = {
-        grammar: {
-            start: '',
-            config: {},
-            rules: {},
-            uuids: {},
-        },
-        lexer: null,
-        head: [],
-        body: [],
-        config: {},
-        version: 'unknown',
-    }
-
-    serializeHead() {
-        if (this.state.config.noscript)
-            return '';
-        return this.state.head.join('\n');
-    }
-
-    serializeBody() {
-        if (this.state.config.noscript)
-            return '';
-        return this.state.body.join('\n');
-    }
-
-    serializeLanguage(depth: number = 0) {
-        const serialier = new StandardGrammar(this);
-        let lr = null;
-
-        if ('lr' in this.state.config) {
-            const table = new LRParseTableBuilder(this);
-            lr = Generator.Pretty({
-                k: "0",
-                table: table.serialize(depth + 2)
-            }, depth + 1);
-        }
-
-        return Generator.Pretty({
-            grammar: serialier.serialize(depth + 1),
-            lexer: this.serializeLexerConfig(depth + 1),
-            lr
-        }, depth);
-    }
-
-    merge(state: GeneratorState) {
-        // TODO: Resolve Conflicting Rules and UUIDS
-        Object.assign(this.state.grammar.rules, state.grammar.rules);
-        this.state.grammar.start = state.grammar.start || this.state.grammar.start;
-        this.state.grammar.config.postprocessorDefault = state.grammar.config.postprocessorDefault || this.state.grammar.config.postprocessorDefault;
-        this.state.grammar.config.postprocessorOverride = state.grammar.config.postprocessorOverride || this.state.grammar.config.postprocessorOverride;
-
-        if (state.lexer) {
-            if (this.state.lexer) {
-                Object.assign(this.state.lexer.states, state.lexer.states);
-            } else {
-                this.state.lexer = state.lexer;
-            }
-            this.state.lexer.start = state.lexer.start || this.state.lexer.start;
-        }
-        this.state.head.push(...state.head);
-        this.state.body.push(...state.body);
-        Object.assign(this.state.config, state.config);
-    }
-
-    grammarUUID(name: string) {
-        this.state.grammar.uuids[name] = (this.state.grammar.uuids[name] || 0) + 1;
-        return name + 'x' + this.state.grammar.uuids[name];
-    }
-
-    addGrammarRule(rule: GeneratorGrammarRule) {
-        this.state.grammar.rules[rule.name] = this.state.grammar.rules[rule.name] || [];
-        this.state.grammar.rules[rule.name].push(rule);
-    }
-
-    addLexerState(state: LexerStateDefinition) {
-        this.state.lexer.states[state.name] = this.state.lexer.states[state.name] || { name: state.name, rules: [] }
-        const target = this.state.lexer.states[state.name];
-        target.default = typeof state.default == 'string' ? state.default : target.default;
-        target.unmatched = typeof state.unmatched == 'string' ? state.unmatched : target.unmatched;
-        target.rules.push(...state.rules);
-    }
-
-    serializePostProcess(postprocess: GeneratorGrammarRule['postprocess'], alias: Dictionary<number>) {
-        postprocess = this.state.grammar.config.postprocessorOverride || postprocess || this.state.grammar.config.postprocessorDefault;
-        if (!postprocess)
-            return null;
-        if ('builtin' in postprocess)
-            return PostProcessors[postprocess.builtin];
-        if (this.state.config.noscript)
-            return;
-        if (typeof postprocess == 'string')
-            return postprocess;
-        if ('js' in postprocess)
-            return postprocess.js;
-        if ('template' in postprocess)
-            return this.templatePostProcess(postprocess.template, alias);
-    }
-
-    private templatePostProcess(templateBody: string, alias: { [key: string]: number }) {
-        for (const key in alias) {
-            templateBody = templateBody.replace(new RegExp('(?:\\$)' + key + '(?![a-zA-Z\\d\\$_])'), `data[${alias[key]}]`);
-        }
-        return "({data}) => { return " + templateBody.replace(/\$(\d+)/g, "data[$1]") + "; }";
-    }
-
-    private serializeLexerConfig(depth: number = 0) {
-        if (!this.state.lexer)
-            return null;
-
-        if (typeof this.state.lexer === 'string')
-            return this.state.lexer;
-
-        return Generator.Pretty({
-            start: JSON.stringify(this.state.lexer.start),
-            states: this.serializeLexerConfigStates(depth + 1)
-        }, depth);
-    }
-
-    private serializeLexerConfigStates(depth: number) {
-        const map = {};
-        for (const key in this.state.lexer.states) {
-            const state = this.state.lexer.states[key];
-            map[state.name] = Generator.Pretty({
-                name: JSON.stringify(state.name),
-                default: state.default ? JSON.stringify(state.default) : null,
-                unmatched: state.unmatched ? JSON.stringify(state.unmatched) : null,
-                rules: this.serializeLexerConfigStateRules(state.rules, depth + 2)
-            }, depth + 1);
-        }
-        return Generator.Pretty(map, depth);
-    }
-
-    private serializeLexerConfigStateRules(rules: LexerConfig['states'][0]['rules'], depth: number) {
-        const ary = rules.map(rule => {
-            if ('import' in rule)
-                return Generator.Pretty({ import: JSON.stringify(rule.import) }, -1)
-            return Generator.Pretty({
-                when: Generator.SerializeSymbol(rule.when as any),
-                type: JSON.stringify(rule.type),
-                tag: JSON.stringify(rule.tag),
-                pop: JSON.stringify(rule.pop),
-                before: JSON.stringify(rule.before),
-                open: JSON.stringify(rule.open),
-                close: JSON.stringify(rule.close),
-                highlight: JSON.stringify(rule.highlight),
-                set: JSON.stringify(rule.set),
-                inset: JSON.stringify(rule.inset),
-                goto: JSON.stringify(rule.goto),
-            }, -1);
-        });
-        return Generator.Pretty(ary, depth);
-    }
-
-    serializeGrammarRule(rule: GeneratorGrammarRule) {
-        const symbols = [];
-        const alias = {};
-        for (let i = 0; i < rule.symbols.length; i++) {
-            symbols.push(Generator.SerializeSymbol(rule.symbols[i]));
-            if (rule.symbols[i].alias) {
-                alias[rule.symbols[i].alias] = i;
-            }
-        }
-
-        return Generator.Pretty({
-            name: JSON.stringify(rule.name),
-            symbols: Generator.Pretty(symbols, -1),
-            postprocess: this.serializePostProcess(rule.postprocess, alias)
-        }, -1);
-    }
-
-    static NewLine(depth: number) {
-        return '\n' + ' '.repeat(depth * 4);
-    }
-
-    static Pretty(obj: string[] | { [key: string]: string | (string[]) }, depth = 0) {
-        if (Array.isArray(obj)) {
-            let r = `[`;
-            for (let i = 0; i < obj.length; i++) {
-                const value = obj[i];
-                r += `${depth >= 0 ? Generator.NewLine(depth + 1) : ' '}${value}${(Generator.IsVal(obj[i + 1]) ? ',' : '')}`;
-            }
-            r += `${depth >= 0 ? Generator.NewLine(depth) : ' '}]`;
-            return r;
-        }
-
-        let r = `{`;
-        const keys = Object.keys(obj).filter(v => Generator.IsVal(obj[v]));
-        const prefix = depth >= 0 ? Generator.NewLine(depth + 1) : ' ';
-        for (let i = 0; i < keys.length; i++) {
-            const key = /[a-z_][a-z\d_$]*/i.test(keys[i]) ? keys[i] : JSON.stringify(keys[i]);
-            const value = Array.isArray(obj[keys[i]]) ? Generator.Pretty(obj[keys[i]] as string[], depth >= 0 ? depth + 1 : -1) : obj[keys[i]];
-            const suffix = (Generator.IsVal(obj[keys[i + 1]]) ? ',' : '');
-            r += `${prefix}${key}: ${value}${suffix}`;
-        }
-        r += `${depth >= 0 ? Generator.NewLine(depth) : ' '}}`;
-        return r;
-    }
-
-    static IsVal(value) {
-        return typeof value !== 'undefined' && value !== null;
-    }
-
-    static SerializeSymbol(s: GeneratorGrammarSymbol) {
-        if (typeof s === 'string') {
-            return JSON.stringify(s);
-        } else if ('rule' in s) {
-            return JSON.stringify(s.rule);
-        } else if ('regex' in s) {
-            return `/${s.regex}/${s.flags || ''}`;
-        } else if ('token' in s) {
-            return `{ token: ${JSON.stringify(s.token)} }`;
-        } else if ('literal' in s) {
-            return `{ literal: ${JSON.stringify(s.literal)} }`;
-        } else {
-            return JSON.stringify(s);
-        }
-    }
-
-    static SymbolIsTerminal(s: GeneratorGrammarSymbol) {
-        return !(typeof s === 'string' || 'rule' in s);
-    }
-
-}

package/src/compiler/gwell.gwell

@@ -1,294 +0,0 @@
-lexer: {{
-    start: "start"
-
-    start ->
-        - import: string, js, ws, comment, l_scolon, l_star
-        - when: /lexer(?![a-zA-Z\d_])/ tag: "T_WORD" goto: lexer highlight: "type"
-        - when: /grammar(?![a-zA-Z\d_])/ tag: "T_WORD" goto: grammar highlight: "type"
-        - when: /config(?![a-zA-Z\d_])/ tag: "T_WORD" goto: config highlight: "type"
-        - import: kv
-    config ->
-        - import: ws, l_colon
-        - when: "{{" tag: "L_TEMPLATEL" set: config_inner
-    config_inner ->
-        - import: comment, kv
-        - when: "}}" tag: "L_TEMPLATER" pop: 1
-    grammar ->
-        - import: ws, l_colon
-        - when: "{{" tag: "L_TEMPLATEL" set: grammar_inner
-    grammar_inner ->
-        - import: comment, js, js_template, ws, regex, l_qmark, l_plus, l_star, kv, l_colon, l_comma, l_pipe, l_parenl, l_parenr, l_arrow, l_dsign, l_dash
-        - when: "}}" tag: "L_TEMPLATER" pop: 1
-    lexer ->
-        - import: ws, l_colon
-        - when: "{{" tag: "L_TEMPLATEL" set: lexer_inner
-    lexer_inner ->
-        - import: ws, comment, regex, l_comma, l_arrow, l_dash, kv, js
-        - when: "}}" tag: "L_TEMPLATER" pop: 1
-    js ->
-        - when: "${" tag: "L_JSL" goto: js_wrap
-    js_wrap ->
-        default: "T_JSBODY"
-        unmatched: "T_JSBODY"
-        - import: jsignore
-        - when: "{" tag: "T_JSBODY" goto: js_literal
-        - when: "}" tag: "L_JSR" pop: 1
-    js_literal ->
-        default: "T_JSBODY"
-        unmatched: "T_JSBODY"
-        - import: jsignore
-        - when: "{" tag: "T_JSBODY" goto: js_literal
-        - when: "}" tag: "T_JSBODY" pop: 1
-    js_template ->
-        - when: "{{" tag: "L_TEMPLATEL" goto: js_template_inner
-    js_template_inner ->
-        default: "T_JSBODY"
-        unmatched: "T_JSBODY"
-        - import: jsignore
-        - when: "{" tag: "T_JSBODY" goto: js_literal
-        - when: "}}" tag: "L_TEMPLATER" pop: 1
-    kv ->
-        - import: string, ws, word, l_colon, integer
-    jsignore ->
-        - when: /"(?:[^"\\\r\n]|\\.)*"/ tag: "T_JSBODY"
-        - when: /'(?:[^'\\\r\n]|\\.)*'/ tag: "T_JSBODY"
-        - when: /`(?:[^`\\]|\\.)*`/ tag: "T_JSBODY"
-        - when: /\/(?:[^\/\\\r\n]|\\.)+\/[gmiyu]*/ tag: "T_JSBODY"
-        - when: /\/\/[^\n]*/ tag: "T_JSBODY"
-        - when: /\/\*.*\*\// tag: "T_JSBODY"
-    string ->
-        - when: /"(?:[^"\\\r\n]|\\.)*"/ tag: "T_STRING" highlight: "string"
-    string2 ->
-        - when: /'(?:[^'\\\r\n]|\\.)*'/ tag: "T_STRING" highlight: "string"
-    string3 ->
-        - when: /`(?:[^`\\]|\\.)*`/ tag: "T_STRING" highlight: "string"
-    regex ->
-        - when: /\/(?:[^\/\\\r\n]|\\.)+\// tag: "T_REGEX" highlight: "regexp"
-    integer ->
-        - when: /\d+/ tag: "T_INTEGER" highlight: "number"
-    word ->
-        - when: /[a-zA-Z_][a-zA-Z_\d]*/ tag: "T_WORD"
-    ws ->
-        - when: /\s+/ tag: "T_WS"
-    l_colon ->
-        - when: ":" tag: "L_COLON" highlight: "keyword"
-    l_scolon ->
-        - when: ";" tag: "L_SCOLON" 
-    l_qmark ->
-        - when: "?" tag: "L_QMARK"
-    l_plus ->
-        - when: "+" tag: "L_PLUS"
-    l_star ->
-        - when: "*" tag: "L_STAR"
-    l_comma ->
-        - when: "," tag: "L_COMMA"
-    l_pipe ->
-        - when: "|" tag: "L_PIPE" highlight: "keyword"
-    l_parenl ->
-        - when: "(" tag: "L_PARENL"
-    l_parenr ->
-        - when: ")" tag: "L_PARENR"
-    l_templatel ->
-        - when: "{{" tag: "L_TEMPLATEL"
-    l_templater ->
-        - when: "}}" tag: "L_TEMPLATER"
-    l_arrow ->
-        - when: "->" tag: "L_ARROW" highlight: "keyword"
-    l_dsign ->
-        - when: "$" tag: "L_DSIGN"
-    l_dash ->
-        - when: "-" tag: "L_DASH"
-    comment ->
-        - when: /\/\/[^\n]*/ tag: "T_COMMENT" highlight: "comment"
-    commentmulti ->
-        - when: /\/\*.*\*\// tag: "T_COMMENT" highlight: "comment"
-
-}}
-
-grammar: {{
-
-    main ->
-        _ section_list _ : {{ $1 }}
-
-    section_list ->
-        section : {{ [$0] }}
-        | section T_WS section_list : {{ [$0].concat($2) }}
-
-    section ->
-        K_CONFIG _ L_COLON _ L_TEMPLATEL _ kv_list:list _ L_TEMPLATER : {{ { config: Object.assign(...$list) } }}
-        | K_IMPORT _ L_STAR _ K_FROM __ T_WORD:import _ L_SCOLON : {{ { import: $import } }}
-        | K_IMPORT _ L_STAR _ K_FROM __ T_STRING:import _ L_SCOLON : {{ { import: $import, path: true } }}
-        | K_IMPORT _ L_STAR _ "as" _ T_WORD:alias _ K_FROM __ T_WORD:import _ L_SCOLON : {{ { import: $import, alias: $alias} }}
-        | K_IMPORT _ L_STAR _ "as" _ T_WORD:alias _ K_FROM __ T_STRING:import _ L_SCOLON : {{ { import: $import, path: true, alias: $alias} }}
-        | K_LEXER _ L_COLON _ L_TEMPLATEL _ lexer:lexer _ L_TEMPLATER : {{ { lexer: Object.assign(...$lexer) } }}
-        | K_GRAMMAR _ L_COLON _ L_TEMPLATEL _ grammar:grammar _ L_TEMPLATER : {{ { grammar: $grammar } }}
-        | K_BODY _ L_COLON _ T_JS:js : {{ { body: $js } }}
-        | K_BODY _ L_COLON _ T_STRING:js : {{ { body: $js, path: true } }}
-        | K_HEAD _ L_COLON _ T_JS:js : {{ { head: $js } }}
-        | K_HEAD _ L_COLON _ T_STRING:js : {{ { head: $js, path: true } }}
-
-    lexer ->
-        kv_list _ state_list : {{ $0.concat({ states: $2 }) }}
-        | state_list : {{ [{ states: $0 }] }}
-
-    state_list ->
-        state : {{ data }}
-        | state _ state_list : {{ [$0].concat($2) }}
-
-    state ->
-        state_declare _ state_definition : {{ Object.assign({ name: $0 }, $2) }}
-
-    state_declare ->
-        T_WORD _ L_ARROW : {{ $0 }}
-
-    state_definition ->
-        kv_list _ token_list : {{ Object.assign(...$0, { rules: $2 }) }}
-        | token_list : {{ { rules: $0 } }}
-
-    token_list ->
-        token : {{ data }}
-        | token _ token_list : {{ [$0].concat($2) }}
-
-    token ->
-        L_DASH _ K_IMPORT _ L_COLON _ word_list : {{ { import: $6 } }}
-        | L_DASH _ token_definition_list : {{ Object.assign(...$2) }}
-
-    token_definition_list ->
-        token_definition : {{ data }}
-        | token_definition _ token_definition_list : {{ [$0].concat($2) }}
-
-    token_definition ->
-        K_TAG _ L_COLON _ string_list : {{ { tag: $4 } }}
-        | K_WHEN _ L_COLON _ T_STRING : {{ { when: $4 } }}
-        | K_WHEN _ L_COLON _ T_REGEX : {{ { when: $4 } }}
-        | K_OPEN _ L_COLON _ T_STRING : {{ { open: $4 } }}
-        | K_CLOSE _ L_COLON _ T_STRING : {{ { close: $4 } }}
-        | K_BEFORE _ L_COLON _ T_STRING : {{ { when: $4, before:true } }}
-        | K_BEFORE _ L_COLON _ T_REGEX : {{ { when: $4, before:true } }}
-        | K_POP : {{ { pop: 1 } }}
-        | K_POP _ L_COLON _ T_INTEGER : {{ { pop: parseInt($4) } }}
-        | K_POP _ L_COLON _ K_ALL : {{ { pop: "all" } }}
-        | K_HIGHLIGHT _ L_COLON _ T_STRING : {{ { highlight: $4 } }}
-        | K_EMBED _ L_COLON _ T_STRING : {{ { embed: $4 } }}
-        | K_UNEMBED : {{ { unembed: true } }}
-        | K_INSET : {{ { inset: 1 } }}
-        | K_INSET _ L_COLON _ T_INTEGER : {{ { inset: parseInt($4) } }}
-        | K_SET _ L_COLON _ T_WORD : {{ { set: $4 } }}
-        | K_GOTO _ L_COLON _ T_WORD : {{ { goto: $4 } }}
-        | K_TYPE _ L_COLON _ T_STRING : {{ { type: $4 } }}
-
-    grammar ->
-        kv_list _ grammar_rule_list : {{ { config: Object.assign(...$0), rules: $2 } }}
-        | grammar_rule_list : {{ { rules: $0 } }}
-
-    grammar_rule_list ->
-        grammar_rule : {{ [$0] }}
-        | grammar_rule _ grammar_rule_list : {{ [$0].concat($2) }}
-
-    grammar_rule ->
-        T_WORD _ L_ARROW _ expression_list : {{ { name: $0, expressions: $4 } }}
-        | T_WORD  __ L_COLON _ T_JS:js _ L_ARROW _ expression_list:expressions : {{ { name: $0, expressions: $expressions, postprocess: $js } }}
-        | T_WORD  __ L_COLON _ T_GRAMMAR_TEMPLATE:template _ L_ARROW _ expression_list:expressions : {{ { name: $0, expressions: $expressions, postprocess: $template } }}
-
-    expression_list ->
-        expression
-        | expression_list _ L_PIPE _ expression : {{ $0.concat([$4]) }}
-
-    expression ->
-        expression_symbol_list : {{ { symbols: $0 } }}
-        | expression_symbol_list __ L_COLON _ T_JS:js : {{ { symbols: $0, postprocess: $js } }}
-        | expression_symbol_list __ L_COLON _ T_GRAMMAR_TEMPLATE:template : {{ { symbols: $0, postprocess: $template } }}
-
-    expression_symbol_list ->
-        expression_symbol
-        | expression_symbol_list T_WS expression_symbol : {{ $0.concat([$2]) }}
-
-    
-    expression_symbol ->
-        expression_symbol_match : {{ $0 }}
-        | expression_symbol_match L_COLON T_WORD : {{ { ...$0,  alias: $2 } }}
-        | expression_symbol_match expression_repeater : {{ { expression: $0, repeat: $1 } }}
-        | expression_symbol_match expression_repeater L_COLON T_WORD : {{ { expression: $0, repeat: $1, alias: $4 } }}
-
-
-    expression_symbol_match ->
-        T_WORD : {{ { rule: $0 } }}
-        | T_STRING "i"? : {{ { literal: $0, insensitive: !!$1 } }}
-        | L_DSIGN T_WORD : {{ { token: $1} }}
-        | L_DSIGN T_STRING : {{ { token: $1} }}
-        | T_REGEX : {{ $0 }}
-        | L_PARENL _ expression_list _ L_PARENR : {{ { subexpression: $2 } }}
-        | T_JS : {{ $0 }}
-
-    expression_repeater : {{ $0[0].value }} ->
-        L_QMARK
-        | L_PLUS
-        | L_STAR
-
-    kv_list ->
-        kv : {{ data }}
-        | kv _ kv_list : {{ [$0].concat($2) }}
-
-    kv ->
-        T_WORD _ L_COLON _ ( T_WORD| T_STRING| T_INTEGER | T_JS | T_GRAMMAR_TEMPLATE) : {{ { [$0]: $4[0] } }}
-
-    string_list ->
-        T_STRING : {{ [$0] }}
-        | T_STRING _ L_COMMA _ string_list : {{ [$0].concat($4) }}
-
-    word_list ->
-        T_WORD : {{ [$0] }}
-        | T_WORD _ L_COMMA _ word_list : {{ [$0].concat($4) }}
-
-    _ ->
-        ( T_WS | T_COMMENT )* : {{ null }} 
-
-    __ ->
-        ( T_WS | T_COMMENT )+ : {{ null }}
-
-    L_COLON -> $L_COLON
-    L_SCOLON -> $L_SCOLON
-    L_QMARK -> $L_QMARK
-    L_PLUS -> $L_PLUS
-    L_STAR -> $L_STAR
-    L_COMMA -> $L_COMMA
-    L_PIPE -> $L_PIPE
-    L_PARENL -> $L_PARENL
-    L_PARENR -> $L_PARENR
-    L_TEMPLATEL -> $L_TEMPLATEL
-    L_TEMPLATER -> $L_TEMPLATER
-    L_ARROW -> $L_ARROW
-    L_DSIGN -> $L_DSIGN
-    L_DASH -> $L_DASH
-
-    K_ALL -> "all"
-    K_TAG -> "tag"
-    K_FROM -> "from"
-    K_TYPE -> "type"
-    K_WHEN -> "when"
-    K_POP -> "pop"
-    K_BEFORE -> "before"
-    K_OPEN -> "open"
-    K_CLOSE -> "close"
-    K_HIGHLIGHT -> "highlight"
-    K_EMBED -> "embed"
-    K_UNEMBED -> "unembed"
-    K_INSET -> "inset"
-    K_SET -> "set"
-    K_GOTO -> "goto"
-    K_CONFIG -> "config"
-    K_LEXER -> "lexer"
-    K_GRAMMAR -> "grammar"
-    K_IMPORT -> "import"
-    K_BODY -> "body" 
-    K_HEAD -> "head"
-
-    T_JS -> $L_JSL $T_JSBODY* $L_JSR : {{ { js: $1.map(v=>v.value).join('') } }}
-    T_GRAMMAR_TEMPLATE -> $L_TEMPLATEL _ $T_JSBODY* _ $L_TEMPLATER : {{ { template: $2.map(v=>v.value).join('').trim() } }}
-    T_STRING -> $T_STRING : {{ JSON.parse($0.value) }}
-    T_WORD -> $T_WORD : {{ $0.value }}
-    T_REGEX -> $T_REGEX /[gmiuy]/* : {{ { regex: $0.value.replace(/\\\\\//g,'/').slice(1,-1), flags: $1.map(v=>v.value).join('').trim() } }}
-    T_COMMENT -> $T_COMMENT
-    T_INTEGER -> $T_INTEGER : {{ $0.value }}
-    T_WS -> $T_WS : {{ null }}
-}}