@fuzdev/fuz_code 0.37.0

package/dist/CodeHighlight.svelte.d.ts

@@ -0,0 +1,101 @@
+/**
+     * Uses the CSS Custom Highlight API when available --
+     * https://developer.mozilla.org/en-US/docs/Web/API/CSS_Custom_Highlight_API
+     *
+     * Requires importing theme_highlight.css instead of theme.css.
+     */
+import { type Snippet } from 'svelte';
+import type { SvelteHTMLElements } from 'svelte/elements';
+import type { SyntaxStyler, SyntaxGrammar } from './syntax_styler.js';
+import { type HighlightMode } from './highlight_manager.js';
+type $$ComponentProps = SvelteHTMLElements['code'] & {
+    /** The source code to syntax highlight. */
+    content: string;
+    /**
+     * Language identifier (e.g., 'ts', 'css', 'html', 'json', 'svelte', 'md').
+     *
+     * **Purpose:**
+     * - When `grammar` is not provided, used to look up the grammar via `syntax_styler.get_lang(lang)`
+     * - Used for metadata: sets the `data-lang` attribute and determines `language_supported`
+     *
+     * **Special values:**
+     * - `null` - Explicitly disables syntax highlighting (content rendered as plain text)
+     * - `undefined` - Falls back to default ('svelte')
+     *
+     * **Relationship with `grammar`:**
+     * - If both `lang` and `grammar` are provided, `grammar` takes precedence for tokenization
+     * - However, `lang` is still used for the `data-lang` attribute and language detection
+     *
+     * @default 'svelte'
+     */
+    lang?: string | null;
+    /**
+     * Highlighting mode for this component.
+     *
+     * **Options:**
+     * - `'auto'` - Uses CSS Custom Highlight API if supported, falls back to HTML mode
+     * - `'ranges'` - Forces CSS Custom Highlight API (requires browser support)
+     * - `'html'` - Forces HTML generation with CSS classes
+     *
+     * **Note:** CSS Custom Highlight API has limitations and limited browser support.
+     * Requires importing `theme_highlight.css` instead of `theme.css`.
+     *
+     * @default 'auto'
+     */
+    mode?: HighlightMode;
+    /**
+     * Optional custom grammar object for syntax tokenization.
+     *
+     * **When to use:**
+     * - To provide a custom language definition not registered in `syntax_styler.langs`
+     * - To use a modified/extended version of an existing grammar
+     * - For one-off grammar variations without registering globally
+     *
+     * **Behavior:**
+     * - When provided, this grammar is used for tokenization instead of looking up via `lang`
+     * - Enables highlighting even if `lang` is not in the registry (useful for custom languages)
+     * - The `lang` parameter is still used for metadata (data-lang attribute)
+     * - When undefined, the grammar is automatically looked up via `syntax_styler.get_lang(lang)`
+     *
+     * @default undefined (uses grammar from `syntax_styler.langs[lang]`)
+     */
+    grammar?: SyntaxGrammar | undefined;
+    /**
+     * Whether to render as inline code or block code.
+     * Controls display via CSS classes.
+     *
+     * @default false
+     */
+    inline?: boolean;
+    /**
+     * Whether to wrap long lines in block code.
+     * Sets `white-space: pre-wrap` instead of `white-space: pre`.
+     *
+     * **Behavior:**
+     * - Wraps at whitespace (spaces, newlines)
+     * - Long tokens without spaces (URLs, hashes) will still scroll horizontally
+     * - Default `false` provides traditional code block behavior
+     *
+     * Only affects block code (ignored for inline mode).
+     *
+     * @default false
+     */
+    wrap?: boolean;
+    /**
+     * Custom SyntaxStyler instance to use for highlighting.
+     * Allows using a different styler with custom grammars or configuration.
+     *
+     * @default syntax_styler_global
+     */
+    syntax_styler?: SyntaxStyler;
+    /**
+     * Optional snippet to customize how the highlighted markup is rendered.
+     * - In HTML mode: receives the generated HTML string
+     * - In range mode: receives the plain text content
+     */
+    children?: Snippet<[markup: string]>;
+};
+declare const CodeHighlight: import("svelte").Component<$$ComponentProps, {}, "">;
+type CodeHighlight = ReturnType<typeof CodeHighlight>;
+export default CodeHighlight;
+//# sourceMappingURL=CodeHighlight.svelte.d.ts.map

package/dist/CodeHighlight.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodeHighlight.svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/CodeHighlight.svelte"],"names":[],"mappings":"AAGA;;;;;OAKI;AACJ,OAAO,EAAY,KAAK,OAAO,EAAC,MAAM,QAAQ,CAAC;AAE/C,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,iBAAiB,CAAC;AAGxD,OAAO,KAAK,EAAC,YAAY,EAAE,aAAa,EAAC,MAAM,oBAAoB,CAAC;AAEpE,OAAO,EAGL,KAAK,aAAa,EAClB,MAAM,wBAAwB,CAAC;AAEhC,KAAK,gBAAgB,GAAI,kBAAkB,CAAC,MAAM,CAAC,GAAG;IACrD,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;;;;;;OAgBG;IACH,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB;;;;;;;;;;;;OAYG;IACH,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;IACpC;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;;;;;;;;;OAYG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;;OAKG;IACH,aAAa,CAAC,EAAE,YAAY,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CACrC,CAAC;AAgGH,QAAA,MAAM,aAAa,sDAAwC,CAAC;AAC5D,KAAK,aAAa,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AACtD,eAAe,aAAa,CAAC"}

package/dist/code_sample.d.ts

@@ -0,0 +1,8 @@
+export interface CodeSample {
+    name: string;
+    lang: string;
+    content: string;
+}
+export declare const sample_langs: readonly ["json", "css", "ts", "html", "svelte", "md"];
+export type SampleLang = (typeof sample_langs)[number];
+//# sourceMappingURL=code_sample.d.ts.map

package/dist/code_sample.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code_sample.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/code_sample.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CAChB;AAGD,eAAO,MAAM,YAAY,wDAAyD,CAAC;AAEnF,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/code_sample.js

@@ -0,0 +1,2 @@
+// Languages ordered from simple to complex
+export const sample_langs = ['json', 'css', 'ts', 'html', 'svelte', 'md'];

package/dist/grammar_clike.d.ts

@@ -0,0 +1,12 @@
+import type { AddSyntaxGrammar } from './syntax_styler.js';
+export declare const class_keywords = "class|extends|implements|instanceof|interface|new";
+/**
+ * Based on Prism (https://github.com/PrismJS/prism)
+ * by Lea Verou (https://lea.verou.me/)
+ *
+ * MIT license
+ *
+ * @see LICENSE
+ */
+export declare const add_grammar_clike: AddSyntaxGrammar;
+//# sourceMappingURL=grammar_clike.d.ts.map

package/dist/grammar_clike.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar_clike.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/grammar_clike.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAmB,MAAM,oBAAoB,CAAC;AAE3E,eAAO,MAAM,cAAc,sDAAsD,CAAC;AAElF;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,gBAmC/B,CAAC"}

package/dist/grammar_clike.js

@@ -0,0 +1,43 @@
+export const class_keywords = 'class|extends|implements|instanceof|interface|new';
+/**
+ * Based on Prism (https://github.com/PrismJS/prism)
+ * by Lea Verou (https://lea.verou.me/)
+ *
+ * MIT license
+ *
+ * @see LICENSE
+ */
+export const add_grammar_clike = (syntax_styler) => {
+    const grammar_clike = {
+        comment: [
+            {
+                pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+                lookbehind: true,
+                greedy: true,
+            },
+            {
+                pattern: /(^|[^\\:])\/\/.*/,
+                lookbehind: true,
+                greedy: true,
+            },
+        ],
+        string: {
+            pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+            greedy: true,
+        },
+        class_name: {
+            pattern: new RegExp(`(\\b(?:${class_keywords}|trait)\\s+|\\bcatch\\s+\\()[\\w.\\\\]+`, 'i'),
+            lookbehind: true,
+            inside: {
+                punctuation: /[.\\]/,
+            },
+        },
+        keyword: /\b(?:break|catch|continue|do|else|finally|for|function|if|in|instanceof|new|null|return|throw|try|while)\b/,
+        boolean: /\b(?:false|true)\b/,
+        function: /\b\w+(?=\()/,
+        number: /\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+        operator: /[<>]=?|[!=]=?=?|--?|\+\+?|&&?|\|\|?|[?*/~^%]/,
+        punctuation: /[{}[\];(),.:]/,
+    };
+    syntax_styler.add_lang('clike', grammar_clike);
+};

package/dist/grammar_css.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_css: AddSyntaxGrammar;
+//# sourceMappingURL=grammar_css.d.ts.map

package/dist/grammar_css.d.ts.map

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

package/dist/grammar_css.js

@@ -0,0 +1,70 @@
+import { grammar_markup_add_attribute, grammar_markup_add_inlined } from './grammar_markup.js';
+var string = /(?:"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|'(?:\\(?:\r\n|[\s\S])|[^'\\\r\n])*')/;
+/**
+ * Based on Prism (https://github.com/PrismJS/prism)
+ * by Lea Verou (https://lea.verou.me/)
+ *
+ * MIT license
+ *
+ * @see LICENSE
+ */
+export const add_grammar_css = (syntax_styler) => {
+    const grammar_css = {
+        comment: /\/\*[\s\S]*?\*\//,
+        atrule: {
+            pattern: RegExp('@[\\w-](?:' +
+                /[^;{\s"']|\s+(?!\s)/.source +
+                '|' +
+                string.source +
+                ')*?' +
+                /(?:;|(?=\s*\{))/.source),
+            inside: {
+                rule: /^@[\w-]+/,
+                selector_function_argument: {
+                    pattern: /(\bselector\s*\(\s*(?![\s)]))(?:[^()\s]|\s+(?![\s)])|\((?:[^()]|\([^()]*\))*\))+(?=\s*\))/,
+                    lookbehind: true,
+                    alias: 'selector',
+                },
+                keyword: {
+                    pattern: /(^|[^\w-])(?:and|not|only|or)(?![\w-])/,
+                    lookbehind: true,
+                },
+            }, // see `rest` below
+        },
+        url: {
+            // https://drafts.csswg.org/css-values-3/#urls
+            pattern: RegExp('\\burl\\((?:' + string.source + '|' + /(?:[^\\\r\n()"']|\\[\s\S])*/.source + ')\\)', 'i'),
+            greedy: true,
+            inside: {
+                function: /^url/i,
+                punctuation: /^\(|\)$/,
+                string: {
+                    pattern: RegExp('^' + string.source + '$'),
+                    alias: 'url',
+                },
+            },
+        },
+        selector: {
+            pattern: RegExp('(^|[{}\\s])[^{}\\s](?:[^{};"\'\\s]|\\s+(?![\\s{])|' + string.source + ')*(?=\\s*\\{)'),
+            lookbehind: true,
+        },
+        string: {
+            pattern: string,
+            greedy: true,
+        },
+        property: {
+            pattern: /(^|[^-\w\xA0-\uFFFF])(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*(?=\s*:)/i,
+            lookbehind: true,
+        },
+        important: /!important\b/i,
+        function: {
+            pattern: /(^|[^-a-z0-9])[-a-z0-9]+(?=\()/i,
+            lookbehind: true,
+        },
+        punctuation: /[(){};:,]/,
+    };
+    grammar_css.atrule.inside.rest = grammar_css;
+    syntax_styler.add_lang('css', grammar_css);
+    grammar_markup_add_inlined(syntax_styler, 'style', 'css');
+    grammar_markup_add_attribute(syntax_styler, 'style', 'css');
+};

package/dist/grammar_js.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_js: AddSyntaxGrammar;
+//# sourceMappingURL=grammar_js.d.ts.map

package/dist/grammar_js.d.ts.map

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

package/dist/grammar_js.js

@@ -0,0 +1,180 @@
+import { grammar_markup_add_attribute, grammar_markup_add_inlined } from './grammar_markup.js';
+import { class_keywords } from './grammar_clike.js';
+/**
+ * Based on Prism (https://github.com/PrismJS/prism)
+ * by Lea Verou (https://lea.verou.me/)
+ *
+ * MIT license
+ *
+ * @see LICENSE
+ */
+export const add_grammar_js = (syntax_styler) => {
+    const grammar_clike = syntax_styler.get_lang('clike');
+    // Main JS keywords (from keyword pattern, excluding those with special lookaheads)
+    const main_keywords = 'class|const|debugger|delete|enum|extends|function|implements|in|instanceof|interface|let|new|null|of|package|private|protected|public|static|super|this|typeof|undefined|var|void|with';
+    // Keywords that are treated specially (inserted before 'function')
+    const special_keywords = 'as|await|break|case|catch|continue|default|do|else|export|finally|for|from|if|import|return|switch|throw|try|while|yield';
+    // All JS keywords (for negative lookahead in parameter pattern)
+    // Note: 'assert', 'async', 'get', 'set' have special lookahead requirements in the main keyword pattern
+    const all_js_keywords = `assert|async|${main_keywords}|get|set|${special_keywords}`;
+    const grammar_js = syntax_styler.add_extended_lang('clike', 'js', {
+        class_name: [
+            ...grammar_clike.class_name,
+            {
+                pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$A-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\.(?:constructor|prototype))/,
+                lookbehind: true,
+            },
+        ],
+        keyword: [
+            {
+                pattern: new RegExp(`(^|[^.]|\\.\\.\\.\\s*)\\b(?:assert(?=\\s*\\{)|async(?=\\s*(?:function\\b|\\*|\\(|[$\\w\\xA0-\\uFFFF]|$))|${main_keywords}|(?:get|set)(?=\\s*(?:[#[$\\w\\xA0-\\uFFFF]|$)))\\b`),
+                lookbehind: true,
+            },
+        ],
+        // Allow for all non-ASCII characters (See http://stackoverflow.com/a/2008444)
+        function: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*(?:\.\s*(?:apply|bind|call)\s*)?\()/,
+        number: {
+            pattern: RegExp(/(^|[^\w$])/.source +
+                '(?:' +
+                // constant
+                (/NaN|Infinity/.source +
+                    '|' +
+                    // binary integer
+                    /0[bB][01]+(?:_[01]+)*n?/.source +
+                    '|' +
+                    // octal integer
+                    /0[oO][0-7]+(?:_[0-7]+)*n?/.source +
+                    '|' +
+                    // hexadecimal integer
+                    /0[xX][\dA-Fa-f]+(?:_[\dA-Fa-f]+)*n?/.source +
+                    '|' +
+                    // decimal bigint
+                    /\d+(?:_\d+)*n/.source +
+                    '|' +
+                    // decimal number (integer or float) but no bigint
+                    /(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[Ee][+-]?\d+(?:_\d+)*)?/
+                        .source) +
+                ')' +
+                /(?![\w$])/.source),
+            lookbehind: true,
+        },
+        operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/,
+    }, ['javascript']);
+    grammar_js.class_name[0].pattern = new RegExp(`(\\b(?:${class_keywords})\\s+)[\\w.\\\\]+`);
+    syntax_styler.grammar_insert_before('js', 'function', {
+        special_keyword: new RegExp(`\\b(?:${special_keywords})\\b`),
+    });
+    syntax_styler.grammar_insert_before('js', 'keyword', {
+        regex: {
+            pattern: RegExp(
+            // lookbehind
+            /((?:^|[^$\w\xA0-\uFFFF."'\])\s]|\b(?:return|yield))\s*)/.source +
+                // Regex pattern:
+                // There are 2 regex patterns here. The RegExp set notation proposal added support for nested character
+                // classes if the `v` flag is present. Unfortunately, nested CCs are both context-free and incompatible
+                // with the only syntax, so we have to define 2 different regex patterns.
+                /\//.source +
+                '(?:' +
+                /(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\[\r\n])+\/[dgimyus]{0,7}/.source +
+                '|' +
+                // `v` flag syntax. This supports 3 levels of nested character classes.
+                /(?:\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.|\[(?:[^[\]\\\r\n]|\\.)*\])*\])*\]|\\.|[^/\\[\r\n])+\/[dgimyus]{0,7}v[dgimyus]{0,7}/
+                    .source +
+                ')' +
+                // lookahead
+                /(?=(?:\s|\/\*(?:[^*]|\*(?!\/))*\*\/)*(?:$|[\r\n,.;:})\]]|\/\/))/.source),
+            lookbehind: true,
+            greedy: true,
+            inside: {
+                regex_source: {
+                    pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
+                    lookbehind: true,
+                    alias: 'lang_regex',
+                    inside: syntax_styler.langs.regex, // TODO use `get_lang` after adding `regex` support
+                },
+                regex_delimiter: /^\/|\/$/,
+                regex_flags: /^[a-z]+$/,
+            },
+        },
+        // Arrow function and function expression variable names
+        // This must be declared before keyword because we use "function" inside the look-forward
+        function_variable: {
+            pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/,
+            alias: 'function',
+        },
+        parameter: [
+            {
+                pattern: /(function(?:\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)?\s*\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\))/,
+                lookbehind: true,
+                inside: grammar_js,
+            },
+            {
+                pattern: /(^|[^$\w\xA0-\uFFFF])(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=>)/i,
+                lookbehind: true,
+                inside: grammar_js,
+            },
+            {
+                pattern: /(\(\s*)(?!\s)(?:[^()\s]|\s+(?![\s)])|\([^()]*\))+(?=\s*\)\s*=>)/,
+                lookbehind: true,
+                inside: grammar_js,
+            },
+            {
+                pattern: new RegExp(`((?:\\b|\\s|^)(?!(?:${all_js_keywords})(?![$\\w\\xA0-\\uFFFF]))(?:(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*\\s*)\\(\\s*|\\]\\s*\\(\\s*)(?!\\s)(?:[^()\\s]|\\s+(?![\\s)])|\\([^()]*\\))+(?=\\s*\\)\\s*\\{)`),
+                lookbehind: true,
+                inside: grammar_js,
+            },
+        ],
+        constant: /\b[A-Z](?:[A-Z_]|\dx?)*\b/,
+        // Heuristic: treat capitalized identifiers as class names when not already matched
+        capitalized_identifier: {
+            pattern: /\b[A-Z][\w]*\b/,
+            alias: 'class_name',
+        },
+    });
+    syntax_styler.grammar_insert_before('js', 'string', {
+        hashbang: {
+            pattern: /^#!.*/,
+            greedy: true,
+            alias: 'comment',
+        },
+        template_string: {
+            pattern: /`(?:\\[\s\S]|\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}|(?!\$\{)[^\\`])*`/,
+            greedy: true,
+            inside: {
+                template_punctuation: {
+                    pattern: /^`|`$/,
+                    alias: 'string',
+                },
+                interpolation: {
+                    pattern: /((?:^|[^\\])(?:\\{2})*)\$\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+                    lookbehind: true,
+                    inside: {
+                        interpolation_punctuation: {
+                            pattern: /^\$\{|\}$/,
+                            alias: 'punctuation',
+                        },
+                        rest: grammar_js, // TODO try to fix this type
+                    },
+                },
+                string: /[\s\S]+/,
+            },
+        },
+        string_property: {
+            pattern: /((?:^|[,{])[ \t]*)(["'])(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2(?=\s*:)/m,
+            lookbehind: true,
+            greedy: true,
+            alias: 'property',
+        },
+    });
+    syntax_styler.grammar_insert_before('js', 'operator', {
+        literal_property: {
+            pattern: /((?:^|[,{])[ \t]*)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*:)/m,
+            lookbehind: true,
+            alias: 'property',
+        },
+    });
+    grammar_markup_add_inlined(syntax_styler, 'script', 'js');
+    // add attribute support for all DOM events (on* attributes)
+    // https://developer.mozilla.org/en-US/docs/Web/Events#Standard_events
+    grammar_markup_add_attribute(syntax_styler, 'on\\w+', 'js');
+};

package/dist/grammar_json.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_json: AddSyntaxGrammar;
+//# sourceMappingURL=grammar_json.d.ts.map

package/dist/grammar_json.d.ts.map

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

package/dist/grammar_json.js

@@ -0,0 +1,35 @@
+/**
+ * Based on Prism (https://github.com/PrismJS/prism)
+ * by Lea Verou (https://lea.verou.me/)
+ *
+ * MIT license
+ *
+ * @see LICENSE
+ */
+export const add_grammar_json = (syntax_styler) => {
+    const grammar_json = {
+        property: {
+            pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?=\s*:)/,
+            lookbehind: true,
+            greedy: true,
+        },
+        string: {
+            pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"(?!\s*:)/,
+            lookbehind: true,
+            greedy: true,
+        },
+        comment: {
+            pattern: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
+            greedy: true,
+        },
+        number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+        punctuation: /[{}[\],]/,
+        operator: /:/,
+        boolean: /\b(?:false|true)\b/,
+        null: {
+            pattern: /\bnull\b/,
+            alias: 'keyword',
+        },
+    };
+    syntax_styler.add_lang('json', grammar_json);
+};

package/dist/grammar_markdown.d.ts

@@ -0,0 +1,8 @@
+import type { AddSyntaxGrammar } from './syntax_styler.js';
+/**
+ * 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 declare const add_grammar_markdown: AddSyntaxGrammar;
+//# sourceMappingURL=grammar_markdown.d.ts.map

package/dist/grammar_markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grammar_markdown.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/grammar_markdown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,gBAAgB,EAIhB,MAAM,oBAAoB,CAAC;AAsF5B;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,EAAE,gBAgMlC,CAAC"}