@fuzdev/fuz_code 0.37.0

package/dist/grammar_ts.js

@@ -0,0 +1,95 @@
+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_ts = (syntax_styler) => {
+    const grammar_ts = syntax_styler.add_extended_lang('js', 'ts', {
+        class_name: {
+            pattern: new RegExp(`(\\b(?:${class_keywords}|type)\\s+)(?!keyof\\b)(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*(?:\\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?`),
+            lookbehind: true,
+            greedy: true,
+            inside: null, // see below
+        },
+        builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/,
+        // TypeScript arrow functions with type annotations
+        function_variable: {
+            pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*[=:]\s*(?:async\s*)?(?:\bfunction\b|(?:\((?:[^()]|\([^()]*\))*\)(?:\s*:\s*(?:(?!=>).)+)?\s*=>|(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*=>)))/,
+            alias: 'function',
+        },
+    }, ['typescript']);
+    // The keywords TypeScript adds to JS
+    grammar_ts.keyword.push(/\b(?:abstract|declare|is|keyof|readonly|require|satisfies)\b/, 
+    // keywords that have to be followed by an identifier
+    /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/, 
+    // This is for `import type *, {}`
+    /\btype\b(?=\s*(?:[{*]|$))/);
+    // doesn't work with TS because TS is too complex
+    delete grammar_ts.parameter;
+    delete grammar_ts.literal_property;
+    // a version of TS specifically for styling types
+    var type_inside = syntax_styler.extend_grammar('ts', {
+        // Recognize type names in type contexts
+        type_name: {
+            pattern: /\b[A-Z]\w*/,
+            alias: 'class_name',
+        },
+    });
+    // Prevent double-wrapping of class names
+    type_inside.class_name = undefined;
+    // After normalization, grammar_ts.class_name is an array
+    grammar_ts.class_name[0].inside = type_inside;
+    syntax_styler.grammar_insert_before('ts', 'function', {
+        type_assertion: {
+            pattern: /(\b(?:as|satisfies)\s+)(?!\s)[_$A-Za-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
+            lookbehind: true,
+            alias: 'class_name',
+        },
+        import_type_keyword: {
+            pattern: /(\b(?:import|export)\s+)type\b|(\b(?:import|export)\s*\{[^}]*,\s*)type\b/,
+            lookbehind: true,
+            alias: 'special_keyword',
+        },
+        type_annotation: {
+            pattern: /:(?:\s*)((?:[^<>=;,)}\s]|<[^>]*>|\[[^\]]*\]|\s)+)(?=\s*=)/,
+            greedy: true,
+            inside: {
+                ':': /^:/,
+                type: {
+                    pattern: /.+/,
+                    inside: type_inside,
+                },
+            },
+        },
+        decorator: {
+            pattern: /@[$\w\xA0-\uFFFF]+/,
+            inside: {
+                at: {
+                    pattern: /^@/,
+                    alias: 'operator',
+                },
+                function: {
+                    pattern: /^[\s\S]+/,
+                    alias: 'decorator_name',
+                },
+            },
+        },
+        generic_function: {
+            // e.g. foo<T extends "bar" | "baz">( ...
+            pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
+            greedy: true,
+            inside: {
+                function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
+                generic: {
+                    pattern: /<[\s\S]+/, // everything after the first <
+                    alias: 'class_name',
+                    inside: type_inside,
+                },
+            },
+        },
+    });
+};

package/dist/highlight_manager.d.ts

@@ -0,0 +1,25 @@
+import type { SyntaxTokenStream } from './syntax_token.js';
+export type HighlightMode = 'auto' | 'ranges' | 'html';
+/**
+ * Check for CSS Highlights API support.
+ */
+export declare const supports_css_highlight_api: () => boolean;
+/**
+ * Manages highlights for a single element.
+ * Tracks ranges per element and only removes its own ranges when clearing.
+ */
+export declare class HighlightManager {
+    #private;
+    element_ranges: Map<string, Array<Range>>;
+    constructor();
+    /**
+     * Highlight from syntax styler token stream.
+     */
+    highlight_from_syntax_tokens(element: Element, tokens: SyntaxTokenStream): void;
+    /**
+     * Clear only this element's ranges from highlights.
+     */
+    clear_element_ranges(): void;
+    destroy(): void;
+}
+//# sourceMappingURL=highlight_manager.d.ts.map

package/dist/highlight_manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"highlight_manager.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/highlight_manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AAGzD,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC;AAEvD;;GAEG;AACH,eAAO,MAAM,0BAA0B,QAAO,OACS,CAAC;AAExD;;;GAGG;AACH,qBAAa,gBAAgB;;IAC5B,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;;IAS1C;;OAEG;IACH,4BAA4B,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAkD/E;;OAEG;IACH,oBAAoB,IAAI,IAAI;IAmB5B,OAAO,IAAI,IAAI;CAiFf"}

package/dist/highlight_manager.js

@@ -0,0 +1,139 @@
+import { highlight_priorities } from './highlight_priorities.js';
+/**
+ * Check for CSS Highlights API support.
+ */
+export const supports_css_highlight_api = () => !!(globalThis.CSS?.highlights && globalThis.Highlight); // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+/**
+ * Manages highlights for a single element.
+ * Tracks ranges per element and only removes its own ranges when clearing.
+ */
+export class HighlightManager {
+    element_ranges;
+    constructor() {
+        if (!supports_css_highlight_api()) {
+            throw Error('CSS Highlights API not supported');
+        }
+        this.element_ranges = new Map();
+    }
+    /**
+     * Highlight from syntax styler token stream.
+     */
+    highlight_from_syntax_tokens(element, tokens) {
+        // Find the text node (it might not be firstChild due to Svelte comment nodes)
+        let text_node = null;
+        for (const node of element.childNodes) {
+            if (node.nodeType === Node.TEXT_NODE) {
+                text_node = node;
+                break;
+            }
+        }
+        if (!text_node) {
+            throw new Error('no text node to highlight');
+        }
+        this.clear_element_ranges();
+        const ranges_by_type = new Map();
+        const final_pos = this.#create_all_ranges(tokens, text_node, ranges_by_type, 0);
+        // Validate that token positions matched text node length
+        const text_length = text_node.textContent?.length ?? 0;
+        if (final_pos !== text_length) {
+            throw new Error(`Token stream length mismatch: tokens covered ${final_pos} chars but text node has ${text_length} chars`);
+        }
+        // Apply highlights
+        for (const [type, ranges] of ranges_by_type) {
+            const prefixed_type = `token_${type}`;
+            // Track ranges for this element
+            this.element_ranges.set(prefixed_type, ranges);
+            // Get or create the shared highlight
+            let highlight = CSS.highlights.get(prefixed_type);
+            if (!highlight) {
+                highlight = new Highlight();
+                // Set priority based on CSS cascade order (higher = later in CSS = wins)
+                highlight.priority =
+                    highlight_priorities[prefixed_type] ?? 0;
+                CSS.highlights.set(prefixed_type, highlight);
+            }
+            // Add all ranges to the highlight
+            for (const range of ranges) {
+                highlight.add(range);
+            }
+        }
+    }
+    /**
+     * Clear only this element's ranges from highlights.
+     */
+    clear_element_ranges() {
+        for (const [name, ranges] of this.element_ranges) {
+            const highlight = CSS.highlights.get(name);
+            if (!highlight) {
+                throw new Error('Expected to find CSS highlight: ' + name);
+            }
+            for (const range of ranges) {
+                highlight.delete(range);
+            }
+            if (highlight.size === 0) {
+                CSS.highlights.delete(name);
+            }
+        }
+        this.element_ranges.clear();
+    }
+    destroy() {
+        this.clear_element_ranges();
+    }
+    /**
+     * Create ranges for all tokens in the tree.
+     */
+    #create_all_ranges(tokens, text_node, ranges_by_type, offset) {
+        const text_length = text_node.textContent?.length ?? 0;
+        let pos = offset;
+        for (const token of tokens) {
+            if (typeof token === 'string') {
+                pos += token.length;
+                continue;
+            }
+            const length = token.length;
+            const end_pos = pos + length;
+            // Validate positions are within text node bounds before creating ranges
+            if (end_pos > text_length) {
+                throw new Error(`Token ${token.type} extends beyond text node: position ${end_pos} > length ${text_length}`);
+            }
+            try {
+                const range = new Range();
+                range.setStart(text_node, pos);
+                range.setEnd(text_node, end_pos);
+                // Add range for the token type
+                const type = token.type;
+                if (!ranges_by_type.has(type)) {
+                    ranges_by_type.set(type, []);
+                }
+                ranges_by_type.get(type).push(range);
+                // Also add range for any aliases (alias is always an array)
+                for (const alias of token.alias) {
+                    if (!ranges_by_type.has(alias)) {
+                        ranges_by_type.set(alias, []);
+                    }
+                    // Create a new range for each alias (ranges can't be reused)
+                    const alias_range = new Range();
+                    alias_range.setStart(text_node, pos);
+                    alias_range.setEnd(text_node, end_pos);
+                    ranges_by_type.get(alias).push(alias_range);
+                }
+            }
+            catch (e) {
+                throw new Error(`Failed to create range for ${token.type}: ${e}`);
+            }
+            // Process nested tokens
+            if (Array.isArray(token.content)) {
+                const actual_end_pos = this.#create_all_ranges(token.content, text_node, ranges_by_type, pos);
+                // Validate that nested tokens match the parent token's claimed length
+                if (actual_end_pos !== end_pos) {
+                    throw new Error(`Token ${token.type} length mismatch: claimed ${length} chars (${pos}-${end_pos}) but nested content covered ${actual_end_pos - pos} chars (${pos}-${actual_end_pos})`);
+                }
+                pos = actual_end_pos;
+            }
+            else {
+                pos = end_pos;
+            }
+        }
+        return pos;
+    }
+}

package/dist/highlight_priorities.d.ts

@@ -0,0 +1,3 @@
+export type HighlightTokenName = 'token_processing_instruction' | 'token_doctype' | 'token_cdata' | 'token_punctuation' | 'token_tag' | 'token_constant' | 'token_symbol' | 'token_deleted' | 'token_keyword' | 'token_null' | 'token_boolean' | 'token_interpolation_punctuation' | 'token_heading' | 'token_heading_punctuation' | 'token_tag_punctuation' | 'token_comment' | 'token_char' | 'token_inserted' | 'token_blockquote' | 'token_blockquote_punctuation' | 'token_builtin' | 'token_class_name' | 'token_number' | 'token_attr_value' | 'token_attr_quote' | 'token_string' | 'token_template_punctuation' | 'token_inline_code' | 'token_code_punctuation' | 'token_attr_equals' | 'token_selector' | 'token_function' | 'token_regex' | 'token_important' | 'token_variable' | 'token_atrule' | 'token_attr_name' | 'token_property' | 'token_decorator' | 'token_decorator_name' | 'token_link_text_wrapper' | 'token_link_text' | 'token_link_punctuation' | 'token_special_keyword' | 'token_namespace' | 'token_rule' | 'token_at_keyword' | 'token_url' | 'token_strikethrough' | 'token_bold' | 'token_italic';
+export declare const highlight_priorities: Record<HighlightTokenName, number | undefined>;
+//# sourceMappingURL=highlight_priorities.d.ts.map

package/dist/highlight_priorities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"highlight_priorities.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/highlight_priorities.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,kBAAkB,GAC3B,8BAA8B,GAC9B,eAAe,GACf,aAAa,GACb,mBAAmB,GACnB,WAAW,GACX,gBAAgB,GAChB,cAAc,GACd,eAAe,GACf,eAAe,GACf,YAAY,GACZ,eAAe,GACf,iCAAiC,GACjC,eAAe,GACf,2BAA2B,GAC3B,uBAAuB,GACvB,eAAe,GACf,YAAY,GACZ,gBAAgB,GAChB,kBAAkB,GAClB,8BAA8B,GAC9B,eAAe,GACf,kBAAkB,GAClB,cAAc,GACd,kBAAkB,GAClB,kBAAkB,GAClB,cAAc,GACd,4BAA4B,GAC5B,mBAAmB,GACnB,wBAAwB,GACxB,mBAAmB,GACnB,gBAAgB,GAChB,gBAAgB,GAChB,aAAa,GACb,iBAAiB,GACjB,gBAAgB,GAChB,cAAc,GACd,iBAAiB,GACjB,gBAAgB,GAChB,iBAAiB,GACjB,sBAAsB,GACtB,yBAAyB,GACzB,iBAAiB,GACjB,wBAAwB,GACxB,uBAAuB,GACvB,iBAAiB,GACjB,YAAY,GACZ,kBAAkB,GAClB,WAAW,GACX,qBAAqB,GACrB,YAAY,GACZ,cAAc,CAAC;AAElB,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,kBAAkB,EAAE,MAAM,GAAG,SAAS,CAoDtE,CAAC"}

package/dist/highlight_priorities.gen.d.ts

@@ -0,0 +1,4 @@
+import type { Gen } from '@ryanatkn/gro';
+/** @nodocs */
+export declare const gen: Gen;
+//# sourceMappingURL=highlight_priorities.gen.d.ts.map

package/dist/highlight_priorities.gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"highlight_priorities.gen.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/highlight_priorities.gen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,eAAe,CAAC;AAKvC,cAAc;AACd,eAAO,MAAM,GAAG,EAAE,GAgEjB,CAAC"}

package/dist/highlight_priorities.gen.js

@@ -0,0 +1,58 @@
+import { readFileSync } from 'node:fs';
+const theme_css_path = 'src/lib/theme_highlight.css';
+/** @nodocs */
+export const gen = {
+    dependencies: { files: [theme_css_path] },
+    generate: ({ origin_path }) => {
+        // Read the theme_highlight.css file
+        let css_content = readFileSync(theme_css_path, 'utf-8');
+        // Strip CSS comments to avoid false positives
+        css_content = css_content.replace(/\/\*[\s\S]*?\*\//g, '');
+        // Extract ::highlight() rules by CSS rule blocks
+        const highlight_priorities = {};
+        let priority = 1;
+        // Split CSS into rule blocks (roughly by closing braces)
+        const rule_blocks = css_content.split('}');
+        for (const block of rule_blocks) {
+            // Find all ::highlight(token_name) declarations in this block
+            const highlight_regex = /::highlight\(([^)]+)\)/g;
+            const tokens_in_block = [];
+            let match;
+            while ((match = highlight_regex.exec(block)) !== null) {
+                const token_name = match[1];
+                if (!tokens_in_block.includes(token_name)) {
+                    tokens_in_block.push(token_name);
+                }
+            }
+            // Assign the same priority to all tokens in this block
+            if (tokens_in_block.length > 0) {
+                for (const token_name of tokens_in_block) {
+                    if (!Object.hasOwn(highlight_priorities, token_name)) {
+                        highlight_priorities[token_name] = priority;
+                    }
+                }
+                priority++;
+            }
+        }
+        const banner = `// generated by ${origin_path} - DO NOT EDIT OR RISK LOST DATA`;
+        // Generate priority entries
+        const priority_entries = Object.entries(highlight_priorities)
+            .map(([token, priority]) => `\t${token}: ${priority}`)
+            .join(',\n');
+        // Generate the type
+        const token_names = Object.keys(highlight_priorities)
+            .map((name) => `'${name}'`)
+            .join(' | ');
+        return `
+			${banner}
+
+			export type HighlightTokenName = ${token_names};
+
+			export const highlight_priorities: Record<HighlightTokenName, number | undefined> = {
+			${priority_entries},
+			} as const;
+
+			${banner}
+		`;
+    },
+};

package/dist/highlight_priorities.js

@@ -0,0 +1,55 @@
+// generated by src/lib/highlight_priorities.gen.ts - DO NOT EDIT OR RISK LOST DATA
+export const highlight_priorities = {
+    token_processing_instruction: 1,
+    token_doctype: 1,
+    token_cdata: 1,
+    token_punctuation: 1,
+    token_tag: 2,
+    token_constant: 2,
+    token_symbol: 2,
+    token_deleted: 2,
+    token_keyword: 2,
+    token_null: 2,
+    token_boolean: 2,
+    token_interpolation_punctuation: 2,
+    token_heading: 2,
+    token_heading_punctuation: 2,
+    token_tag_punctuation: 2,
+    token_comment: 3,
+    token_char: 3,
+    token_inserted: 3,
+    token_blockquote: 3,
+    token_blockquote_punctuation: 3,
+    token_builtin: 4,
+    token_class_name: 4,
+    token_number: 4,
+    token_attr_value: 5,
+    token_attr_quote: 5,
+    token_string: 5,
+    token_template_punctuation: 5,
+    token_inline_code: 5,
+    token_code_punctuation: 5,
+    token_attr_equals: 6,
+    token_selector: 7,
+    token_function: 7,
+    token_regex: 7,
+    token_important: 7,
+    token_variable: 7,
+    token_atrule: 8,
+    token_attr_name: 9,
+    token_property: 9,
+    token_decorator: 9,
+    token_decorator_name: 9,
+    token_link_text_wrapper: 9,
+    token_link_text: 9,
+    token_link_punctuation: 9,
+    token_special_keyword: 10,
+    token_namespace: 10,
+    token_rule: 10,
+    token_at_keyword: 11,
+    token_url: 11,
+    token_strikethrough: 13,
+    token_bold: 14,
+    token_italic: 15,
+};
+// generated by src/lib/highlight_priorities.gen.ts - DO NOT EDIT OR RISK LOST DATA

package/dist/syntax_styler.d.ts

@@ -0,0 +1,277 @@
+import { SyntaxToken, type SyntaxTokenStream } from './syntax_token.js';
+export type AddSyntaxGrammar = (syntax_styler: SyntaxStyler) => void;
+/**
+ * Based on Prism (https://github.com/PrismJS/prism)
+ * by Lea Verou (https://lea.verou.me/)
+ *
+ * MIT license
+ *
+ * @see LICENSE
+ */
+export declare class SyntaxStyler {
+    langs: Record<string, SyntaxGrammar | undefined>;
+    add_lang(id: string, grammar: SyntaxGrammarRaw, aliases?: Array<string>): void;
+    add_extended_lang(base_id: string, extension_id: string, extension: SyntaxGrammarRaw, aliases?: Array<string>): SyntaxGrammar;
+    get_lang(id: string): SyntaxGrammar;
+    /**
+     * Generates HTML with syntax highlighting from source code.
+     *
+     * **Process:**
+     * 1. Runs `before_tokenize` hook
+     * 2. Tokenizes code using the provided or looked-up grammar
+     * 3. Runs `after_tokenize` hook
+     * 4. Runs `wrap` hook on each token
+     * 5. Converts tokens to HTML with CSS classes
+     *
+     * **Parameter Relationship:**
+     * - `lang` is ALWAYS required for hook context and identification
+     * - `grammar` is optional; when undefined, automatically looks up via `this.get_lang(lang)`
+     * - When both are provided, `grammar` is used for tokenization, `lang` for metadata
+     *
+     * **Use cases:**
+     * - Standard usage: `stylize(code, 'ts')` - uses registered TypeScript grammar
+     * - Custom grammar: `stylize(code, 'ts', customGrammar)` - uses custom grammar but keeps 'ts' label
+     * - Extended grammar: `stylize(code, 'custom', this.extend_grammar('ts', extension))` - new language variant
+     *
+     * @param text - The source code to syntax highlight.
+     * @param lang - Language identifier (e.g., 'ts', 'css', 'html'). Used for:
+     *   - Grammar lookup when `grammar` is undefined
+     *   - Hook context (`lang` field passed to hooks)
+     *   - Language identification in output
+     * @param grammar - Optional custom grammar object. When undefined, automatically
+     *   looks up the grammar via `this.get_lang(lang)`. Provide this to use a custom
+     *   or modified grammar instead of the registered one.
+     *
+     * @returns HTML string with syntax highlighting using CSS classes (`.token_*`)
+     *
+     * @example
+     * // Standard usage - uses registered grammar
+     * stylize('var foo = true;', 'ts');
+     *
+     * @example
+     * // Custom grammar - overrides registered grammar
+     * const customGrammar = { keyword: [...], string: [...] };
+     * stylize('var foo = false;', 'ts', customGrammar);
+     *
+     * @example
+     * // Extended grammar - builds on existing grammar
+     * const extended = this.extend_grammar('ts', { customToken: [...] });
+     * stylize('var foo = 42;', 'ts-extended', extended);
+     */
+    stylize(text: string, lang: string, grammar?: SyntaxGrammar | undefined): string;
+    /**
+     * Inserts tokens _before_ another token in a language definition or any other grammar.
+     *
+     * ## Usage
+     *
+     * This helper method makes it easy to modify existing languages. For example, the CSS language definition
+     * not only defines CSS styling for CSS documents, but also needs to define styling for CSS embedded
+     * in HTML through `<style>` elements. To do this, it needs to modify `syntax_styler.get_lang('markup')` and add the
+     * appropriate tokens. However, `syntax_styler.get_lang('markup')` is a regular JS object literal, so if you do
+     * this:
+     *
+     * ```js
+     * syntax_styler.get_lang('markup').style = {
+     *     // token
+     * };
+     * ```
+     *
+     * then the `style` token will be added (and processed) at the end. `insert_before` allows you to insert tokens
+     * before existing tokens. For the CSS example above, you would use it like this:
+     *
+     * ```js
+     * grammar_insert_before('markup', 'cdata', {
+     *     'style': {
+     *         // token
+     *     }
+     * });
+     * ```
+     *
+     * ## Special cases
+     *
+     * If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar
+     * will be ignored.
+     *
+     * This behavior can be used to insert tokens after `before`:
+     *
+     * ```js
+     * grammar_insert_before('markup', 'comment', {
+     *     'comment': syntax_styler.get_lang('markup').comment,
+     *     // tokens after 'comment'
+     * });
+     * ```
+     *
+     * ## Limitations
+     *
+     * The main problem `insert_before` has to solve is iteration order. Since ES2015, the iteration order for object
+     * properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave
+     * differently when keys are deleted and re-inserted. So `insert_before` can't be implemented by temporarily
+     * deleting properties which is necessary to insert at arbitrary positions.
+     *
+     * To solve this problem, `insert_before` doesn't actually insert the given tokens into the target object.
+     * Instead, it will create a new object and replace all references to the target object with the new one. This
+     * can be done without temporarily deleting properties, so the iteration order is well-defined.
+     *
+     * However, only references that can be reached from `syntax_styler.langs` or `insert` will be replaced. I.e. if
+     * you hold the target object in a variable, then the value of the variable will not change.
+     *
+     * ```js
+     * var oldMarkup = syntax_styler.get_lang('markup');
+     * var newMarkup = grammar_insert_before('markup', 'comment', { ... });
+     *
+     * assert(oldMarkup !== syntax_styler.get_lang('markup'));
+     * assert(newMarkup === syntax_styler.get_lang('markup'));
+     * ```
+     *
+     * @param inside - The property of `root` (e.g. a language id in `syntax_styler.langs`) that contains the
+     * object to be modified.
+     * @param before - The key to insert before.
+     * @param insert - An object containing the key-value pairs to be inserted.
+     * @param root - The object containing `inside`, i.e. the object that contains the
+     * object to be modified.
+     *
+     * Defaults to `syntax_styler.langs`.
+     *
+     * @returns the new grammar object
+     */
+    grammar_insert_before(inside: string, before: string, insert: SyntaxGrammarRaw, root?: Record<string, any>): SyntaxGrammar;
+    /**
+     * Converts the given token or token stream to an HTML representation.
+     *
+     * Runs the `wrap` hook on each `SyntaxToken`.
+     *
+     * @param o - The token or token stream to be converted.
+     * @param lang - The name of current language.
+     * @returns The HTML representation of the token or token stream.
+     */
+    stringify_token(o: string | SyntaxToken | SyntaxTokenStream, lang: string): string;
+    /**
+     * Creates a deep copy of the language with the given id and appends the given tokens.
+     *
+     * If a token in `extension` also appears in the copied language, then the existing token in the copied language
+     * will be overwritten at its original position.
+     *
+     * ## Best practices
+     *
+     * Since the position of overwriting tokens (token in `extension` that overwrite tokens in the copied language)
+     * doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to
+     * understand the language definition because, normally, the order of tokens matters in the grammars.
+     *
+     * Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.
+     * Furthermore, all non-overwriting tokens should be placed after the overwriting ones.
+     *
+     * @param base_id - The id of the language to extend. This has to be a key in `syntax_styler.langs`.
+     * @param extension - The new tokens to append.
+     * @returns the new grammar
+     */
+    extend_grammar(base_id: string, extension: SyntaxGrammarRaw): SyntaxGrammar;
+    /**
+     * Normalize a single pattern to have consistent shape.
+     * This ensures all patterns have the same object shape for V8 optimization.
+     */
+    private normalize_pattern;
+    /**
+     * Normalize a grammar to have consistent object shapes.
+     * This performs several optimizations:
+     * 1. Merges `rest` property into main grammar
+     * 2. Ensures all pattern values are arrays
+     * 3. Normalizes all pattern objects to have consistent shapes
+     * 4. Adds global flag to greedy patterns
+     *
+     * This is called once at registration time to avoid runtime overhead.
+     * @param visited - Set of grammar object IDs already normalized (for circular references)
+     */
+    private normalize_grammar;
+    plugins: Record<string, any>;
+    hooks_before_tokenize: Array<HookBeforeTokenizeCallback>;
+    hooks_after_tokenize: Array<HookAfterTokenizeCallback>;
+    hooks_wrap: Array<HookWrapCallback>;
+    add_hook_before_tokenize(cb: HookBeforeTokenizeCallback): void;
+    add_hook_after_tokenize(cb: HookAfterTokenizeCallback): void;
+    add_hook_wrap(cb: HookWrapCallback): void;
+    run_hook_before_tokenize(ctx: HookBeforeTokenizeCallbackContext): void;
+    run_hook_after_tokenize(ctx: HookAfterTokenizeCallbackContext): void;
+    run_hook_wrap(ctx: HookWrapCallbackContext): void;
+}
+export type SyntaxGrammarValueRaw = RegExp | SyntaxGrammarTokenRaw | Array<RegExp | SyntaxGrammarTokenRaw>;
+export type SyntaxGrammarRaw = Record<string, SyntaxGrammarValueRaw | undefined> & {
+    rest?: SyntaxGrammarRaw | undefined;
+};
+/**
+ * The expansion of a simple `RegExp` literal to support additional properties.
+ *
+ * The `inside` grammar will be used to tokenize the text value of each token of this kind.
+ *
+ * This can be used to make nested and even recursive language definitions.
+ *
+ * Note: This can cause infinite recursion. Be careful when you embed different languages or even the same language into
+ * each another.
+ *
+ * Note: Grammar authors can use optional properties, but they will be normalized
+ * to required properties at registration time for optimal performance.
+ */
+export interface SyntaxGrammarTokenRaw {
+    /**
+     * The regular expression of the token.
+     */
+    pattern: RegExp;
+    /**
+     * If `true`, then the first capturing group of `pattern` will (effectively)
+     * behave as a lookbehind group meaning that the captured text will not be part of the matched text of the new token.
+     * @default false
+     */
+    lookbehind?: boolean;
+    /**
+     * Whether the token is greedy.
+     * @default false
+     */
+    greedy?: boolean;
+    /**
+     * An optional alias or list of aliases.
+     */
+    alias?: string | Array<string>;
+    /**
+     * The nested grammar of this token.
+     */
+    inside?: SyntaxGrammarRaw | null;
+}
+/**
+ * Grammar token with all properties required.
+ * This is the normalized representation used at runtime.
+ */
+export interface SyntaxGrammarToken {
+    pattern: RegExp;
+    lookbehind: boolean;
+    greedy: boolean;
+    alias: Array<string>;
+    inside: SyntaxGrammar | null;
+}
+/**
+ * A grammar after normalization.
+ * All values are arrays of normalized tokens with consistent shapes.
+ */
+export type SyntaxGrammar = Record<string, Array<SyntaxGrammarToken>>;
+export type HookBeforeTokenizeCallback = (ctx: HookBeforeTokenizeCallbackContext) => void;
+export type HookAfterTokenizeCallback = (ctx: HookAfterTokenizeCallbackContext) => void;
+export type HookWrapCallback = (ctx: HookWrapCallbackContext) => void;
+export interface HookBeforeTokenizeCallbackContext {
+    code: string;
+    grammar: SyntaxGrammar;
+    lang: string;
+    tokens: undefined;
+}
+export interface HookAfterTokenizeCallbackContext {
+    code: string;
+    grammar: SyntaxGrammar;
+    lang: string;
+    tokens: SyntaxTokenStream;
+}
+export interface HookWrapCallbackContext {
+    type: string;
+    content: string;
+    tag: string;
+    classes: Array<string>;
+    attributes: Record<string, string>;
+    lang: string;
+}
+//# sourceMappingURL=syntax_styler.d.ts.map