svelte-multiselect 11.5.1 → 11.6.0

package/dist/heading-anchors.js

@@ -0,0 +1,114 @@
+// Svelte preprocessor that adds IDs to headings at build time for SSR support
+// This ensures fragment navigation (#heading-id) works on initial page load
+// Match headings in two contexts:
+// 1. Start of line (for .svelte files with formatted HTML)
+// 2. After > (for mdsvex output where HTML is on single line, e.g., "</p> <h2>")
+// Avoid matching inside src={...} attributes by requiring these specific contexts
+// Note: [^>]* for attributes won't match if an attribute value contains > (e.g., data-foo="a>b")
+// This edge case is rare in practice and would require significantly more complex parsing
+const heading_regex_line_start = /^(\s*)<(h[1-6])([^>]*)>([\s\S]*?)<\/\2>/gim;
+const heading_regex_after_tag = /(>)(\s*)<(h[1-6])([^>]*)>([\s\S]*?)<\/\3>/gi;
+// Remove Svelte expressions handling nested braces (e.g., {fn({a: 1})})
+// Treats unmatched } as literal text to avoid dropping content
+function strip_svelte_expressions(str) {
+    let result = ``;
+    let depth = 0;
+    for (const char of str) {
+        if (char === `{`)
+            depth++;
+        else if (char === `}` && depth > 0)
+            depth--;
+        else if (depth === 0)
+            result += char;
+    }
+    return result;
+}
+// Generate URL-friendly slug from text
+const slugify = (text) => text
+    .toLowerCase()
+    .replace(/\s+/g, `-`)
+    .replace(/[^\w-]/g, ``)
+    .replace(/-+/g, `-`) // collapse multiple dashes
+    .replace(/^-|-$/g, ``); // trim leading/trailing dashes
+/** @type {() => import('svelte/compiler').PreprocessorGroup} */
+export function heading_ids() {
+    return {
+        name: `heading-ids`,
+        markup({ content }) {
+            const seen_ids = new Map();
+            let result = content;
+            const process_heading = (attrs, inner) => {
+                // Skip if already has an id (use ^|\s to avoid matching data-id, aria-id, etc.)
+                if (/(^|\s)id\s*=/.test(attrs))
+                    return null;
+                const text = strip_svelte_expressions(inner.replace(/<[^>]+>/g, ``)).trim();
+                if (!text)
+                    return null;
+                const base_id = slugify(text);
+                if (!base_id)
+                    return null;
+                // Handle duplicates within same file
+                const count = seen_ids.get(base_id) ?? 0;
+                seen_ids.set(base_id, count + 1);
+                return count ? `${base_id}-${count}` : base_id;
+            };
+            // Pass 1: Match headings at start of line (for .svelte files)
+            result = result.replace(heading_regex_line_start, (match, indent, tag, attrs, inner) => {
+                const id = process_heading(attrs, inner);
+                return id ? `${indent}<${tag} id="${id}"${attrs}>${inner}</${tag}>` : match;
+            });
+            // Pass 2: Match headings after closing tag (for mdsvex single-line output)
+            result = result.replace(heading_regex_after_tag, (match, gt, space, tag, attrs, inner) => {
+                const id = process_heading(attrs, inner);
+                return id ? `${gt}${space}<${tag} id="${id}"${attrs}>${inner}</${tag}>` : match;
+            });
+            return { code: result };
+        },
+    };
+}
+// SVG link icon for heading anchors
+const link_svg = `<svg width="16" height="16" viewBox="0 0 16 16" aria-label="Link to heading" role="img"><path d="M7.775 3.275a.75.75 0 0 0 1.06 1.06l1.25-1.25a2 2 0 1 1 2.83 2.83l-2.5 2.5a2 2 0 0 1-2.83 0 .75.75 0 0 0-1.06 1.06 3.5 3.5 0 0 0 4.95 0l2.5-2.5a3.5 3.5 0 0 0-4.95-4.95l-1.25 1.25zm-4.69 9.64a2 2 0 0 1 0-2.83l2.5-2.5a2 2 0 0 1 2.83 0 .75.75 0 0 0 1.06-1.06 3.5 3.5 0 0 0-4.95 0l-2.5 2.5a3.5 3.5 0 0 0 4.95 4.95l1.25-1.25a.75.75 0 0 0-1.06-1.06l-1.25 1.25a2 2 0 0 1-2.83 0z" fill="currentColor"/></svg>`;
+// Add anchor link to a single heading element
+function add_anchor_to_heading(heading, icon_svg = link_svg) {
+    if (heading.querySelector(`a[aria-hidden="true"]`))
+        return;
+    if (!heading.id) {
+        // Generate ID from text content (fallback for dynamic headings)
+        const base_id = slugify((heading.textContent ?? ``).trim());
+        if (!base_id)
+            return;
+        // Ensure unique ID in document
+        let counter = 0;
+        while (document.getElementById(counter ? `${base_id}-${counter}` : base_id))
+            counter++;
+        heading.id = counter ? `${base_id}-${counter}` : base_id;
+    }
+    const anchor = document.createElement(`a`);
+    anchor.href = `#${heading.id}`;
+    anchor.setAttribute(`aria-hidden`, `true`);
+    anchor.innerHTML = icon_svg;
+    heading.appendChild(anchor);
+}
+// Svelte 5 attachment that adds anchor links to headings within a container
+// Uses MutationObserver to handle dynamically added headings
+export const heading_anchors = (options = {}) => (node) => {
+    if (typeof document === `undefined`)
+        return;
+    // :scope refers to the element on which querySelectorAll is called
+    // This works whether the attachment is on <main> or a parent element
+    const selector = options.selector ??
+        `:scope > :is(h1, h2, h3, h4, h5, h6), :scope > * > :is(h1, h2, h3, h4, h5, h6)`;
+    const icon_svg = options.icon_svg ?? link_svg;
+    // Process existing headings
+    for (const heading of Array.from(node.querySelectorAll(selector))) {
+        add_anchor_to_heading(heading, icon_svg);
+    }
+    // Watch for new headings - requery the container to respect nesting depth constraints
+    const observer = new MutationObserver(() => {
+        for (const heading of Array.from(node.querySelectorAll(selector))) {
+            add_anchor_to_heading(heading, icon_svg);
+        }
+    });
+    observer.observe(node, { childList: true, subtree: true });
+    return () => observer.disconnect();
+};

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from './attachments';
+export * from './heading-anchors';
 export { default as CircleSpinner } from './CircleSpinner.svelte';
 export { default as CmdPalette } from './CmdPalette.svelte';
 export { default as CodeExample } from './CodeExample.svelte';

package/dist/index.js

@@ -1,4 +1,5 @@
 export * from './attachments';
+export * from './heading-anchors';
 export { default as CircleSpinner } from './CircleSpinner.svelte';
 export { default as CmdPalette } from './CmdPalette.svelte';
 export { default as CodeExample } from './CodeExample.svelte';

package/dist/live-examples/highlighter.js

@@ -0,0 +1,62 @@
+// Starry-night highlighter for mdsvex
+import { createStarryNight } from '@wooorm/starry-night';
+import source_css from '@wooorm/starry-night/source.css';
+import source_js from '@wooorm/starry-night/source.js';
+import source_json from '@wooorm/starry-night/source.json';
+import source_shell from '@wooorm/starry-night/source.shell';
+import source_svelte from '@wooorm/starry-night/source.svelte';
+import source_ts from '@wooorm/starry-night/source.ts';
+import text_html_basic from '@wooorm/starry-night/text.html.basic';
+// Escape HTML special characters in text content (not for attribute values)
+const escape_html_text = (str) => str.replace(/&/g, `&amp;`).replace(/</g, `&lt;`).replace(/>/g, `&gt;`);
+// Convert HAST to HTML string (simplified - only handles what starry-night outputs)
+export const hast_to_html = (node) => {
+    if (node.type === `text`)
+        return escape_html_text(node.value);
+    if (node.type === `root`)
+        return node.children?.map(hast_to_html).join(``) ?? ``;
+    const { tagName, properties, children } = node;
+    const cls = properties?.className?.join(` `);
+    const attrs = cls ? ` class="${cls}"` : ``;
+    const inner = children?.map(hast_to_html).join(``) ?? ``;
+    return `<${tagName}${attrs}>${inner}</${tagName}>`;
+};
+// Shared starry-night instance (grammars loaded once at build time)
+export const starry_night = await createStarryNight([
+    source_svelte,
+    source_js,
+    source_ts,
+    source_css,
+    source_json,
+    source_shell,
+    text_html_basic,
+]);
+// Map code fence language to starry-night grammar scope
+export const LANG_TO_SCOPE = {
+    svelte: `source.svelte`,
+    html: `text.html.basic`,
+    ts: `source.ts`,
+    typescript: `source.ts`,
+    js: `source.js`,
+    javascript: `source.js`,
+    css: `source.css`,
+    json: `source.json`,
+    shell: `source.shell`,
+    bash: `source.shell`,
+    sh: `source.shell`,
+};
+// Escape characters that would be interpreted as Svelte template syntax
+const escape_svelte = (html) => html.replace(/\{/g, `&#123;`).replace(/\}/g, `&#125;`);
+// mdsvex highlighter function
+export function starry_night_highlighter(code, lang) {
+    const lang_key = lang?.toLowerCase();
+    const scope = lang_key ? LANG_TO_SCOPE[lang_key] : undefined;
+    if (!scope) {
+        // Return escaped code if language not supported
+        const escaped = escape_svelte(escape_html_text(code));
+        return `<pre class="highlight"><code>${escaped}</code></pre>`;
+    }
+    const tree = starry_night.highlight(code, scope);
+    const html = escape_svelte(hast_to_html(tree));
+    return `<pre class="highlight highlight-${lang_key}"><code>${html}</code></pre>`;
+}

package/dist/live-examples/index.d.ts

@@ -0,0 +1,7 @@
+export { starry_night_highlighter } from './highlighter.js';
+export { default as mdsvex_transform, EXAMPLE_COMPONENT_PREFIX, EXAMPLE_MODULE_PREFIX, } from './mdsvex-transform.js';
+export { default as vite_plugin } from './vite-plugin.js';
+import { sveltePreprocess as _sveltePreprocess } from 'svelte-preprocess';
+type SveltePreprocessOptions = Parameters<typeof _sveltePreprocess>[0];
+type PreprocessorGroup = ReturnType<typeof _sveltePreprocess>;
+export declare function sveltePreprocess(opts?: SveltePreprocessOptions): PreprocessorGroup;

package/dist/live-examples/index.js

@@ -0,0 +1,23 @@
+// Live examples - transforms ```svelte example code blocks into rendered components
+// with syntax highlighting and live preview
+export { starry_night_highlighter } from './highlighter.js';
+export { default as mdsvex_transform, EXAMPLE_COMPONENT_PREFIX, EXAMPLE_MODULE_PREFIX, } from './mdsvex-transform.js';
+export { default as vite_plugin } from './vite-plugin.js';
+import { sveltePreprocess as _sveltePreprocess } from 'svelte-preprocess';
+// Wrap sveltePreprocess to skip markdown files - otherwise it transpiles code inside
+// markdown code fences, losing whitespace formatting
+const is_markdown = (filename) => /\.(md|mdx|svx)$/.test(filename ?? ``);
+export function sveltePreprocess(opts) {
+    const base = _sveltePreprocess(opts);
+    return {
+        markup: async (args) => is_markdown(args.filename)
+            ? { code: args.content }
+            : (await base.markup?.(args)) ?? { code: args.content },
+        script: async (args) => is_markdown(args.filename)
+            ? { code: args.content }
+            : (await base.script?.(args)) ?? { code: args.content },
+        style: async (args) => is_markdown(args.filename)
+            ? { code: args.content }
+            : (await base.style?.(args)) ?? { code: args.content },
+    };
+}

package/dist/live-examples/mdsvex-transform.d.ts

@@ -0,0 +1,32 @@
+export declare const EXAMPLE_MODULE_PREFIX = "___live_example___";
+export declare const EXAMPLE_COMPONENT_PREFIX = "LiveExample___";
+interface RemarkMeta {
+    Wrapper?: string | [string, string];
+    filename?: string;
+    csr?: boolean;
+    example?: boolean;
+    hideScript?: boolean;
+    hideStyle?: boolean;
+    [key: string]: unknown;
+}
+interface RemarkOptions {
+    defaults?: Partial<RemarkMeta>;
+}
+interface RemarkTree {
+    type: string;
+    children: RemarkNode[];
+}
+interface RemarkNode {
+    type: string;
+    lang?: string;
+    meta?: string;
+    value?: string;
+    children?: RemarkNode[];
+}
+interface RemarkFile {
+    filename: string;
+    cwd: string;
+}
+type RemarkTransformer = (tree: RemarkTree, file: RemarkFile) => void;
+declare function remark(options?: RemarkOptions): RemarkTransformer;
+export default remark;

package/dist/live-examples/mdsvex-transform.js

@@ -0,0 +1,184 @@
+// Remark plugin - transforms ```svelte example code blocks into rendered components
+import { Buffer } from 'node:buffer';
+import path from 'node:path';
+import { hast_to_html, LANG_TO_SCOPE, starry_night } from './highlighter.js';
+// Base64 encode to prevent preprocessors from modifying the content
+const to_base64 = (src) => Buffer.from(src, `utf-8`).toString(`base64`);
+// Escape backticks and template literal syntax for embedding in template literals
+const encode_escapes = (src) => src.replace(/`/g, `\\\``).replace(/\$\{/g, `\\$\{`);
+// Regex to find <script> block in svelte
+// Note: These patterns handle common cases but may have edge cases with nested
+// comments containing </script> strings or complex attribute syntax
+const RE_SCRIPT_START = /<script(?:\s+?[a-zA-Z]+(=(?:["']){0,1}[a-zA-Z0-9]+(?:["']){0,1}){0,1})*\s*?>/;
+const RE_SCRIPT_BLOCK = /(<script[\s\S]*?>)([\s\S]*?)(<\/script>)/g;
+const RE_STYLE_BLOCK = /(<style[\s\S]*?>)([\s\S]*?)(<\/style>)/g;
+// Parses key=value pairs from a string. Supports strings (with escaped quotes),
+// numbers, booleans, and arrays. Note: nested structures in arrays are not supported.
+const RE_PARSE_META = /(\w+=\d+|\w+="(?:[^"\\]|\\.)*"|\w+=\[[^\]]*\]|\w+)/g;
+export const EXAMPLE_MODULE_PREFIX = `___live_example___`;
+export const EXAMPLE_COMPONENT_PREFIX = `LiveExample___`;
+// Languages that render as live Svelte components (O(1) lookup)
+const LIVE_LANGUAGES = new Set([`svelte`, `html`]);
+// All languages that support the `example` meta (O(1) lookup)
+const EXAMPLE_LANGUAGES = new Set(Object.keys(LANG_TO_SCOPE));
+// Simple tree traversal - finds all nodes of a given type
+const visit = (tree, type, callback) => {
+    const walk = (nodes) => {
+        for (const node of nodes) {
+            if (node.type === type)
+                callback(node);
+            if (node.children)
+                walk(node.children);
+        }
+    };
+    walk(tree.children);
+};
+// Default wrapper component
+const DEFAULT_WRAPPER = `$lib/CodeExample.svelte`;
+function remark(options = {}) {
+    const { defaults = {} } = options;
+    return function transformer(tree, file) {
+        const examples = [];
+        // Track wrapper imports to avoid duplicates and generate unique aliases
+        const wrapper_aliases = new Map(); // wrapper key -> alias name
+        const filename = path.relative(file.cwd, file.filename);
+        // Helper to get or create a wrapper alias
+        function get_wrapper_alias(wrapper) {
+            // Use '::' as delimiter to avoid misparsing paths with colons (Windows, URLs)
+            const wrapper_key = typeof wrapper === `string`
+                ? wrapper
+                : `${wrapper[0]}::${wrapper[1]}`;
+            let alias = wrapper_aliases.get(wrapper_key);
+            if (!alias) {
+                alias = `Example_${wrapper_aliases.size}`;
+                wrapper_aliases.set(wrapper_key, alias);
+            }
+            return alias;
+        }
+        visit(tree, `code`, (node) => {
+            const meta = {
+                Wrapper: DEFAULT_WRAPPER,
+                filename,
+                ...defaults,
+                ...parse_meta(node.meta || ``),
+            };
+            const { csr, example, Wrapper } = meta;
+            // find code blocks with `example` meta in supported languages
+            if (example && node.lang && EXAMPLE_LANGUAGES.has(node.lang)) {
+                const is_live = LIVE_LANGUAGES.has(node.lang);
+                const wrapper_alias = is_live ? get_wrapper_alias(Wrapper ?? DEFAULT_WRAPPER) : ``;
+                const value = create_example_component(node.value || ``, meta, is_live ? examples.length : -1, // -1 for code-only (no component import needed)
+                node.lang, is_live, wrapper_alias);
+                // Only track live examples for component imports
+                if (is_live) {
+                    examples.push({ csr, wrapper_alias });
+                }
+                node.type = `paragraph`;
+                node.children = [{ type: `text`, value }];
+                delete node.lang;
+                delete node.meta;
+                delete node.value;
+            }
+        });
+        // add imports for each generated example
+        let scripts = ``;
+        // Add wrapper imports
+        // Use '::' as the tuple delimiter to avoid misparsing Windows paths (C:\path)
+        // or URLs (https://example.com) that contain single colons
+        for (const [wrapper_key, alias] of wrapper_aliases) {
+            const double_colon_idx = wrapper_key.indexOf(`::`);
+            if (double_colon_idx === -1) {
+                // Simple string path (default import)
+                scripts += `import ${alias} from "${wrapper_key}";\n`;
+            }
+            else {
+                // Tuple [module, export] using '::' delimiter
+                const module_path = wrapper_key.slice(0, double_colon_idx);
+                const export_name = wrapper_key.slice(double_colon_idx + 2);
+                scripts += `import { ${export_name} as ${alias} } from "${module_path}";\n`;
+            }
+        }
+        // Add example component imports
+        for (const [idx, ex] of examples.entries()) {
+            if (!ex.csr) {
+                scripts +=
+                    `import ${EXAMPLE_COMPONENT_PREFIX}${idx} from "${EXAMPLE_MODULE_PREFIX}${idx}.svelte";\n`;
+            }
+        }
+        // Try to inject imports into existing script block
+        let injected = false;
+        visit(tree, `html`, (node) => {
+            if (!injected && node.value && RE_SCRIPT_START.test(node.value)) {
+                node.value = node.value.replace(RE_SCRIPT_START, (opening_tag) => `${opening_tag}\n${scripts}`);
+                injected = true;
+            }
+        });
+        // Create script block if none existed
+        if (!injected) {
+            tree.children.push({ type: `html`, value: `<script>\n${scripts}</script>` });
+        }
+    };
+}
+function parse_meta(meta) {
+    const result = {};
+    for (const part of meta.match(RE_PARSE_META) ?? []) {
+        const eq = part.indexOf(`=`);
+        const key = eq === -1 ? part : part.slice(0, eq);
+        const value = eq === -1 ? `true` : part.slice(eq + 1);
+        try {
+            result[key] = JSON.parse(value);
+        }
+        catch {
+            throw new Error(`Unable to parse meta \`${key}=${value}\``);
+        }
+    }
+    return result;
+}
+function format_code(code, meta) {
+    let result = code;
+    if (meta.hideScript)
+        result = result.replace(RE_SCRIPT_BLOCK, ``);
+    if (meta.hideStyle)
+        result = result.replace(RE_STYLE_BLOCK, ``);
+    return result.trim();
+}
+function create_example_component(value, meta, index, lang, is_live, wrapper_alias) {
+    const code = format_code(value, meta);
+    const tree = starry_night.highlight(code, LANG_TO_SCOPE[lang]);
+    // Convert newlines to &#10; to prevent bundlers from stripping whitespace
+    const highlighted = hast_to_html(tree).replace(/\n/g, `&#10;`);
+    // Code-only examples (ts, js, css, etc.) - just render highlighted code block
+    if (!is_live) {
+        // Close and reopen <p> to avoid block-in-inline HTML nesting issues
+        return `</p><pre class="highlight highlight-${lang}"><code>{@html ${JSON.stringify(highlighted)}}</code></pre><p>`;
+    }
+    // Live examples (svelte, html) - render with CodeExample wrapper
+    const component = `${EXAMPLE_COMPONENT_PREFIX}${index}`;
+    const base64_src = to_base64(value);
+    const escaped_src = JSON.stringify(encode_escapes(code));
+    const escaped_meta = encode_escapes(JSON.stringify(meta));
+    // Close and reopen <p> to avoid block-in-inline HTML nesting issues
+    return `</p>
+  <${wrapper_alias}
+    __live_example_src={"${base64_src}"}
+    src={${escaped_src}}
+    meta={${escaped_meta}}
+  >
+    {#snippet example()}
+      ${meta.csr
+        ? `{#if typeof window !== 'undefined'}
+        {#await import("${EXAMPLE_MODULE_PREFIX}${index}.svelte") then module}
+          {@const ${component} = module.default}
+          <${component} />
+        {/await}
+        {/if}`
+        : `<${component} />`}
+    {/snippet}
+
+    {#snippet code()}
+      {@html ${JSON.stringify(highlighted)}}
+    {/snippet}
+  </${wrapper_alias}>
+  <p>`;
+}
+export default remark;

package/dist/live-examples/vite-plugin.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from 'vite';
+import { EXAMPLE_MODULE_PREFIX } from './mdsvex-transform.js';
+export { EXAMPLE_MODULE_PREFIX };
+export default function live_examples_plugin(options?: {
+    extensions?: string[];
+}): Plugin;

package/dist/live-examples/vite-plugin.js

@@ -0,0 +1,170 @@
+// Vite plugin - handles virtual module resolution for example components
+// @ts-expect-error no types available
+import ast from 'abstract-syntax-tree';
+import { Buffer } from 'node:buffer';
+import path from 'node:path';
+import process from 'node:process';
+import { EXAMPLE_MODULE_PREFIX } from './mdsvex-transform.js';
+export { EXAMPLE_MODULE_PREFIX };
+// Max chars to scan after property end for trailing comma/whitespace cleanup
+const TRAILING_CLEANUP_BOUND = 50; // Generous bound - typical trailing content is ", " (2 chars)
+// Apply edits in reverse order so positions stay valid
+const apply_edits = (source, edits) => edits
+    .sort((a, b) => b.start - a.start)
+    .reduce((str, { start, end, content }) => str.slice(0, start) + content + str.slice(end), source);
+export default function live_examples_plugin(options = {}) {
+    const { extensions = [`.svelte.md`, `.md`, `.svx`] } = options;
+    // Extracted examples as individual virtual files (id -> svelte source)
+    const virtual_files = new Map();
+    // Reverse lookup: parent markdown path -> set of virtual file IDs (for O(1) HMR lookups)
+    const parent_to_virtual = new Map();
+    let vite_server;
+    return {
+        name: `live-examples-plugin`,
+        configureServer(server) {
+            vite_server = server;
+        },
+        resolveId(id) {
+            if (id.includes(EXAMPLE_MODULE_PREFIX)) {
+                // Force absolute path (dev uses relative, prod uses absolute)
+                // Use posix.join to ensure forward slashes on all platforms (Vite normalizes to /)
+                const cwd = process.cwd().replace(/\\/g, `/`);
+                return id.includes(cwd) ? id : path.posix.join(cwd, id);
+            }
+        },
+        load(id) {
+            if (id.includes(EXAMPLE_MODULE_PREFIX)) {
+                // Strip query parameters - Vite requests derived modules (styles, etc.) with queries
+                // like ?inline&svelte&type=style&lang.css but we store the base path
+                const [base_id, query = ``] = id.split(`?`);
+                const src = virtual_files.get(base_id);
+                if (src)
+                    return src;
+                // Virtual file not found - can happen during SSR/parallel builds when derived
+                // modules (styles, scripts) are requested before parent markdown is transformed.
+                // For derived module requests, return empty content to avoid crashes.
+                if (query.includes(`type=style`) || query.includes(`type=script`) ||
+                    query.includes(`type=module`)) {
+                    return ``;
+                }
+                // For main component requests in production, fail the build
+                const msg = `Example src not found for ${id}`;
+                if (process.env.NODE_ENV === `production`) {
+                    throw new Error(msg);
+                }
+                // In dev, warn and return error component to surface issue visibly
+                this.warn(msg);
+                return `<script>console.error(${JSON.stringify(msg)})</script><p style="color:red">${msg}</p>`;
+            }
+        },
+        transform(code, id) {
+            // Strip query params for extension check (Vite adds ?query for HMR, styles, etc.)
+            const base_id = id.split(`?`)[0];
+            // Skip non-matching files
+            const is_example_module = id.includes(EXAMPLE_MODULE_PREFIX);
+            const is_markdown = extensions.some((ext) => base_id.endsWith(ext));
+            if (!is_example_module && !is_markdown)
+                return;
+            // Skip derived modules (styles, etc.) - only process the main markdown file
+            // Vite creates derived modules like ?svelte&type=style&lang.css for style blocks
+            if (id.includes(`?svelte&type=`))
+                return { code, map: { mappings: `` } };
+            if (is_markdown) {
+                // Use AST for precise node location, collect edits to apply at end
+                let tree;
+                try {
+                    tree = ast.parse(code, { ranges: true });
+                }
+                catch {
+                    // Code may contain Svelte syntax that the JS parser can't handle
+                    // (e.g., template blocks, special directives). Skip transformation.
+                    return { code, map: { mappings: `` } };
+                }
+                const edits = [];
+                // Find all __live_example_src properties
+                const src_props = ast.find(tree, {
+                    type: `Property`,
+                    key: { name: `__live_example_src` },
+                });
+                for (const [idx, prop] of src_props.entries()) {
+                    // Extract the string literal content (base64 encoded)
+                    const string_literals = ast.find(prop, {
+                        type: `Literal`,
+                    });
+                    if (string_literals.length === 0)
+                        continue;
+                    const value_node = string_literals[0];
+                    // AST Literal nodes store value in .value property (string for literals)
+                    const src = Buffer.from(String(value_node.value ?? ``), `base64`).toString(`utf-8`);
+                    // Use base_id (without query params) to ensure consistent virtual file IDs
+                    const virtual_id = `${base_id}${EXAMPLE_MODULE_PREFIX}${idx}.svelte`;
+                    if (src !== virtual_files.get(virtual_id)) {
+                        virtual_files.set(virtual_id, src);
+                        // Update reverse lookup for HMR (get-or-create pattern)
+                        const virtual_set = parent_to_virtual.get(base_id) ?? new Set();
+                        if (!parent_to_virtual.has(base_id)) {
+                            parent_to_virtual.set(base_id, virtual_set);
+                        }
+                        virtual_set.add(virtual_id);
+                        // Invalidate modules for HMR
+                        if (vite_server) {
+                            const mod = vite_server.moduleGraph.getModuleById(virtual_id);
+                            const parent_mod = vite_server.moduleGraph.getModuleById(base_id);
+                            if (mod)
+                                vite_server.moduleGraph.invalidateModule(mod);
+                            if (parent_mod)
+                                vite_server.moduleGraph.invalidateModule(parent_mod);
+                        }
+                    }
+                    // Remove the property (including trailing comma/whitespace)
+                    if (prop.start !== undefined && prop.end !== undefined) {
+                        let end = prop.end;
+                        const max_end = Math.min(prop.end + TRAILING_CLEANUP_BOUND, code.length);
+                        while (end < max_end && /[\s,]/.test(code[end]))
+                            end++;
+                        edits.push({ start: prop.start, end, content: `` });
+                    }
+                }
+                // Update import paths (static and dynamic) to use virtual file IDs
+                const imports = [
+                    ...ast.find(tree, { type: `ImportDeclaration` }),
+                    ...ast.find(tree, { type: `ImportExpression` }),
+                ];
+                for (const { source } of imports) {
+                    const match = source?.value?.match(/___live_example___(\d+)\.svelte/);
+                    if (match && source?.start !== undefined && source?.end !== undefined) {
+                        const virtual_id = `${base_id}${EXAMPLE_MODULE_PREFIX}${match[1]}.svelte`;
+                        edits.push({
+                            start: source.start + 1,
+                            end: source.end - 1,
+                            content: virtual_id,
+                        });
+                    }
+                }
+                return {
+                    code: apply_edits(code, edits),
+                    map: { mappings: `` },
+                };
+            }
+            return { code, map: { mappings: `` } };
+        },
+        handleHotUpdate(ctx) {
+            // Collect virtual file modules that need HMR updates
+            const additional_modules = [];
+            // Normalize to forward slashes (ctx.file uses OS separators, Map keys use Vite's forward slashes)
+            const file = ctx.file.replace(/\\/g, `/`);
+            // O(1) lookup using reverse map instead of iterating all virtual files
+            if (extensions.some((ext) => file.endsWith(ext))) {
+                const virtual_ids = parent_to_virtual.get(file);
+                if (virtual_ids) {
+                    for (const id of virtual_ids) {
+                        const mod = ctx.server.moduleGraph.getModuleById(id);
+                        if (mod)
+                            additional_modules.push(mod);
+                    }
+                }
+            }
+            return [...additional_modules, ...ctx.modules];
+        },
+    };
+}