@fuzdev/fuz_code 0.37.0

package/dist/grammar_markdown.js

@@ -0,0 +1,228 @@
+/**
+ * Helper to create fenced code block pattern for a language
+ */
+const create_fence_pattern = (backticks, aliases, lang_id, syntax_styler) => {
+    const aliases_pattern = aliases.join('|');
+    const pattern = new RegExp(`^${backticks}(?:${aliases_pattern})[^\\n\\r]*(?:\\r?\\n|\\r)[\\s\\S]*?^${backticks}$`, 'm');
+    const code_fence_pattern = new RegExp(`^${backticks}[^\\n\\r]*|^${backticks}$`, 'm');
+    return {
+        pattern,
+        greedy: true,
+        inside: {
+            code_fence: {
+                pattern: code_fence_pattern,
+                alias: 'punctuation',
+            },
+            [`lang_${lang_id}`]: {
+                pattern: /[\s\S]+/,
+                inside: syntax_styler.get_lang(lang_id),
+            },
+        },
+    };
+};
+/**
+ * Helper to create catch-all fence pattern (unknown languages)
+ */
+const create_catchall_fence = (backticks) => {
+    const pattern = new RegExp(`^${backticks}[^\\n\\r]*(?:\\r?\\n|\\r)[\\s\\S]*?^${backticks}$`, 'm');
+    const code_fence_pattern = new RegExp(`^${backticks}[^\\n\\r]*|^${backticks}$`, 'm');
+    return {
+        pattern,
+        greedy: true,
+        inside: {
+            code_fence: {
+                pattern: code_fence_pattern,
+                alias: 'punctuation',
+            },
+        },
+    };
+};
+/**
+ * Helper to create md self-reference placeholder pattern
+ */
+const create_md_placeholder = (backticks) => {
+    const pattern = new RegExp(`^${backticks}(?:md|markdown)[^\\n\\r]*(?:\\r?\\n|\\r)[\\s\\S]*?^${backticks}$`, 'm');
+    const code_fence_pattern = new RegExp(`^${backticks}[^\\n\\r]*|^${backticks}$`, 'm');
+    return {
+        pattern,
+        greedy: true,
+        inside: {
+            code_fence: {
+                pattern: code_fence_pattern,
+                alias: 'punctuation',
+            },
+            // lang_md will be added after registration
+        },
+    };
+};
+/**
+ * Markdown grammar extending markup.
+ * Supports: headings, fenced code blocks (3/4/5 backticks with nesting), lists, blockquotes,
+ * bold, italic, strikethrough, inline code, and links.
+ */
+export const add_grammar_markdown = (syntax_styler) => {
+    // Language definitions with aliases
+    const langs = [
+        { aliases: ['ts', 'typescript'], id: 'ts' },
+        { aliases: ['js', 'javascript'], id: 'js' },
+        { aliases: ['css'], id: 'css' },
+        { aliases: ['html', 'markup'], id: 'markup' },
+        { aliases: ['json'], id: 'json' },
+        { aliases: ['svelte'], id: 'svelte' },
+    ];
+    // Fence types: higher counts first (for proper precedence in tokenization)
+    const fence_types = [
+        { backticks: '`````', suffix: '5tick' },
+        { backticks: '````', suffix: '4tick' },
+        { backticks: '```', suffix: '' },
+    ];
+    // Build grammar dynamically
+    const grammar = {};
+    const md_self_refs = []; // Track md patterns for later self-reference
+    // Generate fence patterns for each type
+    for (const { backticks, suffix } of fence_types) {
+        const token_suffix = suffix ? `_${suffix}` : '';
+        // md pattern (self-reference added after registration)
+        const md_key = `fenced_code${token_suffix}_md`;
+        grammar[md_key] = create_md_placeholder(backticks);
+        md_self_refs.push(md_key);
+        // Other language patterns (use first alias as token name for backward compatibility)
+        for (const { aliases, id } of langs) {
+            const token_name = aliases[0]; // Use first alias for token name
+            grammar[`fenced_code${token_suffix}_${token_name}`] = create_fence_pattern(backticks, aliases, id, syntax_styler);
+        }
+        // Catch-all fence
+        grammar[`fenced_code${token_suffix}`] = create_catchall_fence(backticks);
+    }
+    // Register markdown grammar first, then add self-references for md fences
+    const grammar_md = syntax_styler.add_extended_lang('markup', 'md', {
+        ...grammar,
+        // Headings (# through ######)
+        heading: {
+            pattern: /^#{1,6}\s+.+$/m,
+            inside: {
+                punctuation: {
+                    pattern: /^#{1,6}/,
+                    alias: 'heading_punctuation',
+                },
+            },
+        },
+        // Blockquotes (> at line start)
+        blockquote: {
+            pattern: /^>\s*.+$/m,
+            inside: {
+                punctuation: {
+                    pattern: /^>/,
+                    alias: 'blockquote_punctuation',
+                },
+            },
+        },
+        // Lists (* or - with any preceding whitespace)
+        list: {
+            pattern: /^\s*[-*]\s+.+$/m,
+            inside: {
+                punctuation: /^\s*[-*]/,
+            },
+        },
+        // Inline elements
+        // Links [text](url)
+        link: {
+            pattern: /\[[^[\]\n\r]+\]\([^)\n\r]+\)/,
+            inside: {
+                link_text_wrapper: {
+                    pattern: /^\[[^\]]+\]/,
+                    inside: {
+                        punctuation: {
+                            pattern: /^\[|\]$/,
+                            alias: 'link_punctuation',
+                        },
+                        link_text: /[^[\]]+/,
+                    },
+                },
+                url_wrapper: {
+                    pattern: /\([^)]+\)$/,
+                    inside: {
+                        punctuation: {
+                            pattern: /^\(|\)$/,
+                            alias: 'link_punctuation',
+                        },
+                        url: /[^()]+/,
+                    },
+                },
+            },
+        },
+        // Inline code `text`
+        inline_code: {
+            pattern: /`[^`\n\r]+`/,
+            alias: 'code',
+            inside: {
+                punctuation: {
+                    pattern: /^`|`$/,
+                    alias: 'code_punctuation',
+                },
+                content: /[^`]+/,
+            },
+        },
+        // Bold **text** or __text__
+        bold: [
+            {
+                // **text** - no asterisks inside
+                pattern: /\*\*[^\s*][^*]*[^\s*]\*\*|\*\*[^\s*]\*\*/,
+                inside: {
+                    punctuation: /^\*\*|\*\*$/,
+                },
+            },
+            {
+                // __text__ - at word boundaries, no underscores inside
+                pattern: /\b__[^\s_][^_]*[^\s_]__\b|\b__[^\s_]__\b/,
+                inside: {
+                    punctuation: /^__|__$/,
+                },
+            },
+        ],
+        // Italic *text* or _text_
+        italic: [
+            {
+                // *text* - no asterisks inside
+                pattern: /\*[^\s*][^*]*[^\s*]\*|\*[^\s*]\*/,
+                inside: {
+                    punctuation: /^\*|\*$/,
+                },
+            },
+            {
+                // _text_ - at word boundaries, no underscores inside
+                pattern: /\b_[^\s_][^_]*[^\s_]_\b|\b_[^\s_]_\b/,
+                inside: {
+                    punctuation: /^_|_$/,
+                },
+            },
+        ],
+        // Strikethrough ~~text~~
+        strikethrough: {
+            pattern: /~~[^\s~][^~]*[^\s~]~~|~~[^\s~]~~/,
+            inside: {
+                punctuation: /^~~|~~$/,
+            },
+        },
+    }, ['markdown']);
+    // Add self-reference for markdown-in-markdown (all fence types)
+    // This must be done after registration to avoid circular dependency
+    const lang_md_inside = {
+        pattern: /[\s\S]+/,
+        inside: syntax_styler.get_lang('md'),
+    };
+    for (const key of md_self_refs) {
+        // After normalization, grammar values are arrays of SyntaxGrammarToken
+        // We need to add lang_md as a normalized array
+        const patterns = grammar_md[key];
+        // Manually normalize the lang_md pattern we're adding
+        const lang_md_token = {
+            pattern: lang_md_inside.pattern,
+            lookbehind: false,
+            greedy: false,
+            alias: [],
+            inside: lang_md_inside.inside,
+        };
+        patterns[0].inside.lang_md = [lang_md_token];
+    }
+};

package/dist/grammar_markup.d.ts

@@ -0,0 +1,31 @@
+import type { SyntaxStyler, AddSyntaxGrammar } from './syntax_styler.js';
+/**
+ * Based on Prism (https://github.com/PrismJS/prism)
+ * by Lea Verou (https://lea.verou.me/)
+ *
+ * MIT license
+ *
+ * @see LICENSE
+ */
+export declare const add_grammar_markup: AddSyntaxGrammar;
+/**
+ * Adds an inlined language to markup.
+ *
+ * An example of an inlined language is CSS with `<style>` tags.
+ *
+ * @param tag_name - The name of the tag that contains the inlined language. This name will be treated as
+ * case insensitive.
+ * @param lang - The language key.
+ */
+export declare const grammar_markup_add_inlined: (syntax_styler: SyntaxStyler, tag_name: string, lang: string, inside_lang?: string) => void;
+/**
+ * Adds an pattern to style languages embedded in HTML attributes.
+ *
+ * An example of an inlined language is CSS with `style` attributes.
+ *
+ * @param attr_name - The name of the tag that contains the inlined language. This name will be treated as
+ * case insensitive.
+ * @param lang - The language key.
+ */
+export declare const grammar_markup_add_attribute: (syntax_styler: SyntaxStyler, attr_name: string, lang: string) => void;
+//# sourceMappingURL=grammar_markup.d.ts.map

package/dist/grammar_markup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar_markup.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/grammar_markup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,YAAY,EACZ,gBAAgB,EAIhB,MAAM,oBAAoB,CAAC;AAE5B;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,EAAE,gBA6EhC,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,GACtC,eAAe,YAAY,EAC3B,UAAU,MAAM,EAChB,MAAM,MAAM,EACZ,oBAAsB,KACpB,IAmCF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,4BAA4B,GACxC,eAAe,YAAY,EAC3B,WAAW,MAAM,EACjB,MAAM,MAAM,KACV,IAiEF,CAAC"}

package/dist/grammar_markup.js

@@ -0,0 +1,192 @@
+/**
+ * Based on Prism (https://github.com/PrismJS/prism)
+ * by Lea Verou (https://lea.verou.me/)
+ *
+ * MIT license
+ *
+ * @see LICENSE
+ */
+export const add_grammar_markup = (syntax_styler) => {
+    const grammar_markup = {
+        comment: {
+            pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
+            greedy: true,
+        },
+        processing_instruction: {
+            pattern: /<\?[\s\S]+?\?>/,
+            greedy: true,
+        },
+        // https://www.w3.org/TR/xml/#NT-doctypedecl
+        doctype: {
+            pattern: /<!DOCTYPE[^>]*>/i,
+            greedy: true,
+        },
+        cdata: {
+            pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+            greedy: true,
+        },
+        tag: {
+            pattern: /<\/?(?!\d)[^\s>/=$<%]+(?:\s(?:\s*[^\s>/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
+            greedy: true,
+            inside: {
+                tag: {
+                    pattern: /^<\/?[^\s>/]+/,
+                    inside: {
+                        punctuation: {
+                            pattern: /^<\/?/,
+                            alias: 'tag_punctuation',
+                        },
+                        namespace: /^[^\s>/:]+:/,
+                    },
+                },
+                special_attr: [],
+                attr_value: {
+                    pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+                    inside: {
+                        punctuation: [
+                            {
+                                pattern: /^=/,
+                                alias: 'attr_equals',
+                            },
+                            {
+                                pattern: /^(\s*)["']|["']$/,
+                                lookbehind: true,
+                                alias: 'attr_quote',
+                            },
+                        ],
+                        entity: undefined, // see below
+                    },
+                },
+                punctuation: {
+                    pattern: /\/?>/,
+                    alias: 'tag_punctuation',
+                },
+                attr_name: {
+                    pattern: /[^\s>/]+/,
+                    inside: {
+                        namespace: /^[^\s>/:]+:/,
+                    },
+                },
+            },
+        },
+        entity: [
+            {
+                pattern: /&[\da-z]{1,8};/i,
+                alias: 'named_entity',
+            },
+            /&#x?[\da-f]{1,8};/i,
+        ],
+    };
+    grammar_markup.tag.inside.attr_value.inside.entity = grammar_markup.entity;
+    syntax_styler.add_lang('markup', grammar_markup, ['html', 'mathml', 'svg']);
+    syntax_styler.add_extended_lang('markup', 'xml', {}, ['ssml', 'atom', 'rss']);
+};
+/**
+ * Adds an inlined language to markup.
+ *
+ * An example of an inlined language is CSS with `<style>` tags.
+ *
+ * @param tag_name - The name of the tag that contains the inlined language. This name will be treated as
+ * case insensitive.
+ * @param lang - The language key.
+ */
+export const grammar_markup_add_inlined = (syntax_styler, tag_name, lang, inside_lang = 'markup') => {
+    const lang_key = 'lang_' + lang;
+    syntax_styler.grammar_insert_before(inside_lang, 'cdata', {
+        [tag_name]: {
+            pattern: RegExp(/(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(/__/g, () => {
+                return tag_name;
+            }), 'i'),
+            lookbehind: true,
+            greedy: true,
+            inside: {
+                included_cdata: {
+                    pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+                    inside: {
+                        cdata: /^<!\[CDATA\[|\]\]>$/i,
+                        [lang_key]: {
+                            pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+                            lookbehind: true,
+                            inside: syntax_styler.get_lang(lang),
+                        },
+                    },
+                },
+                [lang_key]: {
+                    pattern: /[\s\S]+/,
+                    inside: syntax_styler.get_lang(lang),
+                },
+            },
+        },
+    });
+};
+/**
+ * Adds an pattern to style languages embedded in HTML attributes.
+ *
+ * An example of an inlined language is CSS with `style` attributes.
+ *
+ * @param attr_name - The name of the tag that contains the inlined language. This name will be treated as
+ * case insensitive.
+ * @param lang - The language key.
+ */
+export const grammar_markup_add_attribute = (syntax_styler, attr_name, lang) => {
+    // After normalization, grammar.tag is an array of SyntaxGrammarToken
+    const markup_grammar = syntax_styler.get_lang('markup');
+    const tag_patterns = markup_grammar.tag;
+    const tag_inside = tag_patterns[0].inside;
+    tag_inside.special_attr.push({
+        pattern: RegExp(/(^|["'\s])/.source +
+            '(?:' +
+            attr_name +
+            ')' +
+            /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source, 'i'),
+        lookbehind: true,
+        greedy: false,
+        alias: [],
+        inside: {
+            attr_name: [
+                {
+                    pattern: /^[^\s=]+/,
+                    lookbehind: false,
+                    greedy: false,
+                    alias: [],
+                    inside: null,
+                },
+            ],
+            attr_value: [
+                {
+                    pattern: /=[\s\S]+/,
+                    lookbehind: false,
+                    greedy: false,
+                    alias: [],
+                    inside: {
+                        value: [
+                            {
+                                pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
+                                lookbehind: true,
+                                greedy: false,
+                                alias: [lang, 'lang_' + lang], // TODO remove this alias?
+                                inside: syntax_styler.get_lang(lang),
+                            },
+                        ],
+                        punctuation: [
+                            {
+                                pattern: /^=/,
+                                lookbehind: false,
+                                greedy: false,
+                                alias: ['attr_equals'],
+                                inside: null,
+                            },
+                            {
+                                pattern: /"|'/,
+                                lookbehind: false,
+                                greedy: false,
+                                alias: ['attr_quote'],
+                                inside: null,
+                            },
+                        ],
+                    },
+                },
+            ],
+        },
+    });
+};

package/dist/grammar_svelte.d.ts

@@ -0,0 +1,12 @@
+import type { AddSyntaxGrammar, SyntaxStyler } from './syntax_styler.js';
+/**
+ * Based on `prism-svelte` (https://github.com/pngwn/prism-svelte)
+ * by pngwn (https://github.com/pngwn)
+ *
+ * MIT license
+ *
+ * @see LICENSE
+ */
+export declare const add_grammar_svelte: AddSyntaxGrammar;
+export declare const grammar_svelte_add_inlined: (syntax_styler: SyntaxStyler, tag_name: string, lang: string) => void;
+//# sourceMappingURL=grammar_svelte.d.ts.map

package/dist/grammar_svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar_svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/grammar_svelte.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAE,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAKvE;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,EAAE,gBA+IhC,CAAC;AAEF,eAAO,MAAM,0BAA0B,GACtC,eAAe,YAAY,EAC3B,UAAU,MAAM,EAChB,MAAM,MAAM,KACV,IAEF,CAAC"}

package/dist/grammar_svelte.js

@@ -0,0 +1,150 @@
+import { grammar_markup_add_inlined } from './grammar_markup.js';
+const blocks = '(if|else if|else|await|then|catch|each|html|debug|snippet)';
+/**
+ * Based on `prism-svelte` (https://github.com/pngwn/prism-svelte)
+ * by pngwn (https://github.com/pngwn)
+ *
+ * MIT license
+ *
+ * @see LICENSE
+ */
+export const add_grammar_svelte = (syntax_styler) => {
+    const grammar_ts = syntax_styler.get_lang('ts');
+    // Define the at_directive pattern once for reuse (matches any @word)
+    const at_directive_pattern = {
+        pattern: /^{(@\w+)(\s+[\s\S]*)?}$/,
+        inside: {
+            lang_ts: {
+                pattern: /(@\w+\s+)([\s\S]+)/, // Fixed: removed incorrect (?=}$)
+                lookbehind: true,
+                inside: grammar_ts,
+            },
+            at_keyword: /@\w+/,
+            punctuation: /[{}]/,
+        },
+    };
+    // Full expression patterns for top-level contexts
+    const svelte_expression_inside_full = {
+        // Generic @ directive - matches any @word
+        at_directive: at_directive_pattern,
+        // {#each items as item} with special syntax
+        each: {
+            pattern: /^{([#/]each)\s+([\s\S]*)}$/,
+            inside: {
+                special_keyword: /[#/]each/,
+                lang_ts: [
+                    {
+                        pattern: /(#each\s+)[\s\S]+(?=\s+as)/, // Expression before 'as'
+                        lookbehind: true,
+                        inside: grammar_ts,
+                    },
+                    {
+                        pattern: /(as\s+)[\s\S]+/, // Everything after 'as' (including key)
+                        lookbehind: true,
+                        inside: grammar_ts,
+                    },
+                ],
+                keyword: /as/,
+                punctuation: /[{}]/,
+            },
+        },
+        // {#block ...} and {/block}
+        block: {
+            pattern: new RegExp('^\\{([#:/@]\\s*' + blocks + ')\\s*([\\s\\S]*)\\}$'),
+            inside: {
+                special_keyword: new RegExp('[#:/@]' + blocks),
+                keyword: [/as/, /then/],
+                lang_ts: {
+                    pattern: /[\s\S]+(?=}$)/,
+                    inside: grammar_ts,
+                },
+                punctuation: /[{}]/,
+            },
+        },
+        // Default: plain TS expression
+        punctuation: /[{}]/,
+        lang_ts: {
+            pattern: /[\s\S]+/,
+            inside: grammar_ts,
+        },
+    };
+    // Simplified patterns for tag contexts (no block directives)
+    const svelte_expression_inside_simple = {
+        // Generic @ directive
+        at_directive: at_directive_pattern,
+        // Default: plain TS expression
+        punctuation: /[{}]/,
+        lang_ts: {
+            pattern: /[\s\S]+/,
+            inside: grammar_ts,
+        },
+    };
+    const grammar_svelte = syntax_styler.add_extended_lang('markup', 'svelte', {
+        svelte_expression: {
+            pattern: /\{(?:[^{}]|\{[^}]*\})*\}/,
+            greedy: true,
+            inside: svelte_expression_inside_full,
+        },
+        tag: {
+            pattern: /<\/?(?!\d)[^\s>/=$<%]+(?:\s(?:\s*(?:\{(?:[^{}]|\{[^}]*\})*\}|[^\s>/=]+)(?:\s*=\s*(?:(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?:"[^"]*"|'[^']*'|{[\s\S]+?}(?=[\s/>])))|(?=[\s/>])))+)?\s*\/?>/i,
+            greedy: true,
+            inside: {
+                tag: {
+                    pattern: /^<\/?[^\s>/]+/i,
+                    inside: {
+                        punctuation: {
+                            pattern: /^<\/?/,
+                            alias: 'tag_punctuation',
+                        },
+                        namespace: /^[^\s>/:]+:/,
+                    },
+                },
+                svelte_expression: {
+                    pattern: /\{(?:[^{}]|\{[^}]*\})*\}/,
+                    inside: svelte_expression_inside_simple,
+                },
+                attr_value: {
+                    pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/i,
+                    inside: {
+                        punctuation: [
+                            {
+                                pattern: /^=/,
+                                alias: 'attr_equals',
+                            },
+                            {
+                                pattern: /^(\s*)["']|["']$/,
+                                lookbehind: true,
+                                alias: 'attr_quote',
+                            },
+                        ],
+                        svelte_expression: {
+                            pattern: /\{(?:[^{}]|\{[^}]*\})*\}/,
+                            inside: svelte_expression_inside_simple,
+                        },
+                    },
+                },
+                punctuation: {
+                    pattern: /\/?>/,
+                    alias: 'tag_punctuation',
+                },
+                attr_name: {
+                    pattern: /[^\s>/]+/,
+                    inside: {
+                        namespace: /^[^\s>/:]+:/,
+                    },
+                },
+            },
+        },
+    });
+    // oof lol
+    // After normalization, grammar.tag is an array of SyntaxGrammarToken
+    const tag_patterns = grammar_svelte.tag;
+    const tag_inside = tag_patterns[0].inside;
+    tag_inside.attr_value[0].inside.entity = grammar_svelte.entity;
+    grammar_svelte_add_inlined(syntax_styler, 'style', 'css');
+    // Assume TypeScript for all Svelte script tags (no plain JS)
+    grammar_svelte_add_inlined(syntax_styler, 'script', 'ts');
+};
+export const grammar_svelte_add_inlined = (syntax_styler, tag_name, lang) => {
+    grammar_markup_add_inlined(syntax_styler, tag_name, lang, 'svelte');
+};

package/dist/grammar_ts.d.ts

@@ -0,0 +1,11 @@
+import type { AddSyntaxGrammar } from './syntax_styler.js';
+/**
+ * Based on Prism (https://github.com/PrismJS/prism)
+ * by Lea Verou (https://lea.verou.me/)
+ *
+ * MIT license
+ *
+ * @see LICENSE
+ */
+export declare const add_grammar_ts: AddSyntaxGrammar;
+//# sourceMappingURL=grammar_ts.d.ts.map

package/dist/grammar_ts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar_ts.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/grammar_ts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAC;AAGzD;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,EAAE,gBAsG5B,CAAC"}