markstream-svelte 0.0.1-beta.1

package/dist/enhanceRenderedHtml.js

@@ -0,0 +1,768 @@
+import { getD2 } from './optional/d2';
+import { getInfographic } from './optional/infographic';
+import { getKatex } from './optional/katex';
+import { getMermaid } from './optional/mermaid';
+import { getUseMonaco } from './optional/monaco';
+import { extractRenderedSvg, toSafeSvgMarkup } from './sanitizeSvg';
+import { hideTooltip, showTooltipForAnchor } from './tooltip/singletonTooltip';
+import { normalizeKaTeXRenderInput } from './utils/normalizeKaTeXRenderInput';
+import { renderKaTeXWithBackpressure, setKaTeXCache, WORKER_BUSY_CODE } from './workers/katexWorkerClient';
+import { canParseOffthread, findPrefixOffthread } from './workers/mermaidWorkerClient';
+let mermaidRenderId = 0;
+const rootHandles = new WeakMap();
+const DARK_THEME_OVERRIDES = {
+    N1: '#E5E7EB',
+    N2: '#CBD5E1',
+    N3: '#94A3B8',
+    N4: '#64748B',
+    N5: '#475569',
+    N6: '#334155',
+    N7: '#0B1220',
+    B1: '#60A5FA',
+    B2: '#3B82F6',
+    B3: '#2563EB',
+    B4: '#1D4ED8',
+    B5: '#1E40AF',
+    B6: '#111827',
+    AA2: '#22D3EE',
+    AA4: '#0EA5E9',
+    AA5: '#0284C7',
+    AB4: '#FBBF24',
+    AB5: '#F59E0B',
+};
+const MONACO_LANGUAGE_ALIASES = {
+    cjs: 'javascript',
+    cts: 'typescript',
+    d2lang: 'plaintext',
+    js: 'javascript',
+    jsonc: 'json',
+    jsx: 'javascript',
+    md: 'markdown',
+    mjs: 'javascript',
+    sh: 'shell',
+    text: 'plaintext',
+    ts: 'typescript',
+    tsx: 'typescript',
+    txt: 'plaintext',
+    vue: 'html',
+    yml: 'yaml',
+};
+export async function enhanceRenderedHtml(root, options = {}) {
+    disposeRenderedHtmlEnhancements(root);
+    const cleanupFns = [];
+    let disposed = false;
+    const isActive = () => { var _a; return !disposed && ((_a = options.isCancelled) === null || _a === void 0 ? void 0 : _a.call(options)) !== true; };
+    const handle = {
+        dispose: () => {
+            var _a;
+            if (disposed)
+                return;
+            disposed = true;
+            for (let index = cleanupFns.length - 1; index >= 0; index -= 1) {
+                try {
+                    (_a = cleanupFns[index]) === null || _a === void 0 ? void 0 : _a.call(cleanupFns);
+                }
+                catch {
+                    // Best-effort cleanup only.
+                }
+            }
+            if (rootHandles.get(root) === handle)
+                rootHandles.delete(root);
+        },
+    };
+    rootHandles.set(root, handle);
+    if (!isActive())
+        return handle;
+    await renderKatex(root, isActive);
+    if (!isActive())
+        return handle;
+    await renderMermaid(root, cleanupFns, options, isActive);
+    if (!isActive())
+        return handle;
+    if (options.final !== false) {
+        await renderInfographic(root, cleanupFns, options, isActive);
+        if (!isActive())
+            return handle;
+        await renderD2(root, cleanupFns, options, isActive);
+        if (!isActive())
+            return handle;
+        if (!options.renderCodeBlocksAsPre)
+            await renderMonaco(root, cleanupFns, options, isActive);
+    }
+    enhanceFootnotes(root, cleanupFns);
+    enhanceTooltips(root, cleanupFns, options);
+    return handle;
+}
+export function disposeRenderedHtmlEnhancements(root) {
+    if (!root)
+        return;
+    const existing = rootHandles.get(root);
+    existing === null || existing === void 0 ? void 0 : existing.dispose();
+}
+function readKatexSource(node, selector) {
+    const sourceElement = node.querySelector(selector);
+    return {
+        sourceElement,
+        source: ((sourceElement === null || sourceElement === void 0 ? void 0 : sourceElement.textContent) || (!sourceElement ? node.textContent : '') || '').trim(),
+    };
+}
+function resolveKatexRenderTarget(node, selector) {
+    return node.querySelector(selector);
+}
+function hasRenderedKatex(node, selector) {
+    const renderTarget = resolveKatexRenderTarget(node, selector);
+    const scope = renderTarget || node;
+    return !!scope.querySelector('.katex, .katex-display');
+}
+function writeKatexMarkup(node, renderTarget, markup, options = {}) {
+    if (renderTarget)
+        renderTarget.innerHTML = markup;
+    else
+        node.innerHTML = markup;
+    node.dataset.markstreamKatex = '1';
+    if (options.renderedClass)
+        node.classList.add(options.renderedClass);
+}
+function clearKatexMarkup(node, renderTarget, options = {}) {
+    if (renderTarget)
+        renderTarget.innerHTML = '';
+    delete node.dataset.markstreamKatex;
+    delete node.dataset.markstreamKatexSource;
+    if (options.renderedClass)
+        node.classList.remove(options.renderedClass);
+}
+async function renderKatex(root, isActive) {
+    const inlineNodes = Array.from(root.querySelectorAll('.markstream-nested-math'));
+    for (const node of inlineNodes) {
+        if (!isActive())
+            return;
+        if (node.dataset.markstreamKatexManaged === '1')
+            continue;
+        const { source } = readKatexSource(node, '.markstream-nested-math__source');
+        const renderTarget = resolveKatexRenderTarget(node, '.markstream-nested-math__render');
+        if (!source) {
+            clearKatexMarkup(node, renderTarget);
+            continue;
+        }
+        if (node.dataset.markstreamKatex === '1'
+            && node.dataset.markstreamKatexSource === source
+            && hasRenderedKatex(node, '.markstream-nested-math__render')) {
+            continue;
+        }
+        try {
+            writeKatexMarkup(node, renderTarget, await renderKatexMarkup(source, node.dataset.display === 'block'));
+            node.dataset.markstreamKatexSource = source;
+        }
+        catch {
+            clearKatexMarkup(node, renderTarget);
+        }
+    }
+    const blockNodes = Array.from(root.querySelectorAll('.markstream-nested-math-block'));
+    for (const node of blockNodes) {
+        if (!isActive())
+            return;
+        if (node.dataset.markstreamKatexManaged === '1')
+            continue;
+        const { source } = readKatexSource(node, '.markstream-nested-math-block__source');
+        const renderTarget = resolveKatexRenderTarget(node, '.markstream-nested-math-block__render');
+        if (!source) {
+            clearKatexMarkup(node, renderTarget, { renderedClass: 'markstream-nested-math-block--rendered' });
+            continue;
+        }
+        if (node.dataset.markstreamKatex === '1'
+            && node.dataset.markstreamKatexSource === source
+            && hasRenderedKatex(node, '.markstream-nested-math-block__render')) {
+            continue;
+        }
+        try {
+            writeKatexMarkup(node, renderTarget, await renderKatexMarkup(source, true), {
+                renderedClass: 'markstream-nested-math-block--rendered',
+            });
+            node.dataset.markstreamKatexSource = source;
+        }
+        catch {
+            clearKatexMarkup(node, renderTarget, { renderedClass: 'markstream-nested-math-block--rendered' });
+        }
+    }
+}
+async function renderKatexMarkup(source, displayMode) {
+    const normalizedSource = normalizeKaTeXRenderInput(source);
+    try {
+        return await renderKaTeXWithBackpressure(normalizedSource, displayMode, {
+            timeout: 1500,
+            waitTimeout: 0,
+            maxRetries: 0,
+        });
+    }
+    catch (error) {
+        const code = (error === null || error === void 0 ? void 0 : error.code) || (error === null || error === void 0 ? void 0 : error.name);
+        const isWorkerInitFailure = code === 'WORKER_INIT_ERROR' || (error === null || error === void 0 ? void 0 : error.fallbackToRenderer);
+        const isBusyOrTimeout = code === WORKER_BUSY_CODE || code === 'WORKER_TIMEOUT';
+        if (!isWorkerInitFailure && !isBusyOrTimeout)
+            throw error;
+    }
+    const katex = await getKatex();
+    if (!katex)
+        throw new Error('KaTeX renderer is not available.');
+    const html = katex.renderToString(normalizedSource, {
+        displayMode,
+        throwOnError: false,
+    });
+    setKaTeXCache(normalizedSource, displayMode, html);
+    return html;
+}
+async function renderMermaid(root, cleanupFns, options, isActive) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const strictMode = ((_a = options.mermaidProps) === null || _a === void 0 ? void 0 : _a.isStrict) !== false;
+    const mermaid = await getMermaid({
+        startOnLoad: false,
+        securityLevel: strictMode ? 'strict' : 'loose',
+        suppressErrorRendering: true,
+        ...(strictMode ? { flowchart: { htmlLabels: false } } : {}),
+    });
+    if (!mermaid || !isActive())
+        return;
+    const codeNodes = Array.from(root.querySelectorAll('pre > code.language-mermaid'));
+    for (const codeNode of codeNodes) {
+        if (!isActive())
+            return;
+        const pre = codeNode.parentElement;
+        const source = (codeNode.textContent || '').trim();
+        if (!pre || !source)
+            continue;
+        const originalPre = pre.cloneNode(true);
+        const shell = createEnhancedBlockShell('mermaid', 'Mermaid', source, true, options, {
+            showHeader: ((_b = options.mermaidProps) === null || _b === void 0 ? void 0 : _b.showHeader) !== false,
+        });
+        pre.replaceWith(shell.wrapper);
+        try {
+            const theme = options.isDark ? 'dark' : 'light';
+            let sourceToRender = source;
+            if (options.final === false) {
+                try {
+                    await canParseMermaidWithFallback(source, theme, mermaid, options);
+                }
+                catch (error) {
+                    if ((error === null || error === void 0 ? void 0 : error.name) === 'AbortError')
+                        return;
+                    const prefix = await findMermaidPrefixCandidate(source, theme, options);
+                    if (!isActive())
+                        return;
+                    if (!prefix) {
+                        shell.wrapper.replaceWith(originalPre);
+                        continue;
+                    }
+                    sourceToRender = prefix;
+                }
+            }
+            const renderId = `markstream-svelte-mermaid-${++mermaidRenderId}`;
+            const rendered = await withTimeout(() => Promise.resolve(mermaid.render(renderId, applyMermaidThemeTo(sourceToRender, theme))), options.final === false
+                ? Number((_d = (_c = options.mermaidProps) === null || _c === void 0 ? void 0 : _c.renderTimeoutMs) !== null && _d !== void 0 ? _d : 2500)
+                : Number((_f = (_e = options.mermaidProps) === null || _e === void 0 ? void 0 : _e.fullRenderTimeoutMs) !== null && _f !== void 0 ? _f : 4000));
+            if (!isActive())
+                return;
+            const svg = typeof rendered === 'string' ? rendered : rendered === null || rendered === void 0 ? void 0 : rendered.svg;
+            if (!svg)
+                continue;
+            const safeSvg = strictMode ? toSafeSvgMarkup(svg) : svg;
+            if (!safeSvg)
+                continue;
+            shell.body.innerHTML = safeSvg;
+            shell.body.classList.add('markstream-svelte-mermaid');
+            shell.wrapper.dataset.markstreamMermaid = '1';
+            (_g = rendered === null || rendered === void 0 ? void 0 : rendered.bindFunctions) === null || _g === void 0 ? void 0 : _g.call(rendered, shell.body);
+            cleanupFns.push(() => {
+                if (shell.wrapper.isConnected)
+                    shell.wrapper.replaceWith(originalPre.cloneNode(true));
+            });
+        }
+        catch {
+            shell.wrapper.replaceWith(originalPre);
+        }
+    }
+}
+function applyMermaidThemeTo(source, theme) {
+    const trimmed = source.trimStart();
+    if (trimmed.startsWith('%%{'))
+        return source;
+    const themeValue = theme === 'dark' ? 'dark' : 'default';
+    return `%%{init: {"theme": "${themeValue}"}}%%\n${source}`;
+}
+async function canParseMermaidWithFallback(source, theme, mermaid, options) {
+    var _a, _b, _c, _d;
+    const workerTimeout = Number((_b = (_a = options.mermaidProps) === null || _a === void 0 ? void 0 : _a.workerTimeoutMs) !== null && _b !== void 0 ? _b : 1400);
+    const parseTimeout = Number((_d = (_c = options.mermaidProps) === null || _c === void 0 ? void 0 : _c.parseTimeoutMs) !== null && _d !== void 0 ? _d : 1800);
+    try {
+        const ok = await canParseOffthread(source, theme, workerTimeout);
+        if (ok)
+            return true;
+    }
+    catch (error) {
+        if ((error === null || error === void 0 ? void 0 : error.name) === 'AbortError')
+            throw error;
+    }
+    const themedSource = applyMermaidThemeTo(source, theme);
+    if (typeof (mermaid === null || mermaid === void 0 ? void 0 : mermaid.parse) === 'function') {
+        await withTimeout(() => Promise.resolve(mermaid.parse(themedSource)), parseTimeout);
+        return true;
+    }
+    const renderId = `markstream-svelte-mermaid-parse-${++mermaidRenderId}`;
+    await withTimeout(() => Promise.resolve(mermaid.render(renderId, themedSource)), parseTimeout);
+    return true;
+}
+async function findMermaidPrefixCandidate(source, theme, options) {
+    var _a, _b;
+    const workerTimeout = Number((_b = (_a = options.mermaidProps) === null || _a === void 0 ? void 0 : _a.workerTimeoutMs) !== null && _b !== void 0 ? _b : 1400);
+    try {
+        const prefix = await findPrefixOffthread(source, theme, workerTimeout);
+        if (prefix)
+            return prefix;
+    }
+    catch (error) {
+        if ((error === null || error === void 0 ? void 0 : error.name) === 'AbortError')
+            throw error;
+    }
+    return getSafeMermaidPrefixCandidate(source);
+}
+function getSafeMermaidPrefixCandidate(source) {
+    const lines = source.split('\n');
+    while (lines.length > 0) {
+        const lastRaw = lines[lines.length - 1];
+        const last = lastRaw.trimEnd();
+        if (!last) {
+            lines.pop();
+            continue;
+        }
+        const looksDangling = /^[-=~>|<\s]+$/.test(last.trim())
+            || /(?:--|==|~~|->|<-|-\||-\)|-x|o-|\|-|\.-)\s*$/.test(last)
+            || /[-|><]$/.test(last)
+            || /(?:graph|flowchart|sequenceDiagram|classDiagram|stateDiagram|erDiagram|gantt)\s*$/i.test(last);
+        if (!looksDangling)
+            break;
+        lines.pop();
+    }
+    return lines.join('\n');
+}
+function withTimeout(run, timeoutMs) {
+    if (!timeoutMs || timeoutMs <= 0)
+        return run();
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const timer = globalThis.setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            reject(new Error('Operation timed out'));
+        }, timeoutMs);
+        run()
+            .then((value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        })
+            .catch((error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+async function renderInfographic(root, cleanupFns, options, isActive) {
+    var _a;
+    const codeNodes = Array.from(root.querySelectorAll('pre[data-markstream-code-block="1"] > code.language-infographic'));
+    if (!codeNodes.length)
+        return;
+    const InfographicClass = await getInfographic();
+    if (!InfographicClass || !isActive())
+        return;
+    for (const codeNode of codeNodes) {
+        if (!isActive())
+            return;
+        const pre = codeNode.parentElement;
+        const source = codeNode.textContent || '';
+        if (!pre || !source.trim())
+            continue;
+        const originalPre = pre.cloneNode(true);
+        const shell = createEnhancedBlockShell('infographic', 'Infographic', source, true, options, {
+            showHeader: ((_a = options.infographicProps) === null || _a === void 0 ? void 0 : _a.showHeader) !== false,
+        });
+        shell.body.style.minHeight = '320px';
+        shell.body.style.height = '360px';
+        pre.replaceWith(shell.wrapper);
+        try {
+            const instance = new InfographicClass({
+                container: shell.body,
+                width: '100%',
+                height: '100%',
+            });
+            instance.render(source);
+            let frameId = null;
+            if (typeof window !== 'undefined' && typeof window.requestAnimationFrame === 'function') {
+                frameId = window.requestAnimationFrame(() => {
+                    const actualHeight = shell.body.scrollHeight;
+                    if (actualHeight > 0)
+                        shell.body.style.height = `${Math.min(Math.max(actualHeight, 260), 720)}px`;
+                });
+            }
+            cleanupFns.push(() => {
+                var _a;
+                if (frameId != null && typeof window !== 'undefined')
+                    window.cancelAnimationFrame(frameId);
+                (_a = instance.destroy) === null || _a === void 0 ? void 0 : _a.call(instance);
+                if (shell.wrapper.isConnected)
+                    shell.wrapper.replaceWith(originalPre.cloneNode(true));
+            });
+            shell.wrapper.dataset.markstreamInfographic = '1';
+        }
+        catch {
+            shell.wrapper.replaceWith(originalPre);
+        }
+    }
+}
+async function renderD2(root, cleanupFns, options, isActive) {
+    var _a, _b, _c, _d, _e, _f;
+    const D2Ctor = await getD2();
+    if (!D2Ctor || !isActive())
+        return;
+    const codeNodes = Array.from(root.querySelectorAll('pre[data-markstream-code-block="1"] > code.language-d2, pre[data-markstream-code-block="1"] > code.language-d2lang'));
+    for (const codeNode of codeNodes) {
+        if (!isActive())
+            return;
+        const pre = codeNode.parentElement;
+        const source = codeNode.textContent || '';
+        if (!pre || !source.trim())
+            continue;
+        const originalPre = pre.cloneNode(true);
+        const shell = createEnhancedBlockShell('d2', 'D2', source, true, options, {
+            showHeader: ((_a = options.d2Props) === null || _a === void 0 ? void 0 : _a.showHeader) !== false,
+        });
+        pre.replaceWith(shell.wrapper);
+        try {
+            const instance = createD2Instance(D2Ctor);
+            if (!instance || typeof instance.compile !== 'function' || typeof instance.render !== 'function')
+                throw new TypeError('D2 instance is missing compile/render methods.');
+            const compileResult = await instance.compile(source);
+            const diagram = (_b = compileResult === null || compileResult === void 0 ? void 0 : compileResult.diagram) !== null && _b !== void 0 ? _b : compileResult;
+            const baseRenderOptions = (_d = (_c = compileResult === null || compileResult === void 0 ? void 0 : compileResult.renderOptions) !== null && _c !== void 0 ? _c : compileResult === null || compileResult === void 0 ? void 0 : compileResult.options) !== null && _d !== void 0 ? _d : {};
+            const resolvedThemeId = (_e = options.d2ThemeId) !== null && _e !== void 0 ? _e : baseRenderOptions.themeID;
+            const resolvedDarkThemeId = (_f = options.d2DarkThemeId) !== null && _f !== void 0 ? _f : baseRenderOptions.darkThemeID;
+            const renderOptions = { ...baseRenderOptions };
+            renderOptions.themeID = options.isDark && resolvedDarkThemeId != null
+                ? resolvedDarkThemeId
+                : resolvedThemeId;
+            renderOptions.darkThemeID = null;
+            renderOptions.darkThemeOverrides = null;
+            if (options.isDark) {
+                const baseOverrides = baseRenderOptions.themeOverrides && typeof baseRenderOptions.themeOverrides === 'object'
+                    ? baseRenderOptions.themeOverrides
+                    : null;
+                renderOptions.themeOverrides = {
+                    ...DARK_THEME_OVERRIDES,
+                    ...(baseOverrides || {}),
+                };
+            }
+            const renderResult = await instance.render(diagram, renderOptions);
+            if (!isActive())
+                return;
+            const safeSvg = toSafeSvgMarkup(extractRenderedSvg(renderResult));
+            if (!safeSvg)
+                throw new Error('D2 render returned empty output.');
+            shell.body.innerHTML = safeSvg;
+            shell.wrapper.dataset.markstreamD2 = '1';
+            cleanupFns.push(() => {
+                if (shell.wrapper.isConnected)
+                    shell.wrapper.replaceWith(originalPre.cloneNode(true));
+            });
+        }
+        catch {
+            shell.wrapper.replaceWith(originalPre);
+        }
+    }
+}
+async function renderMonaco(root, cleanupFns, options, isActive) {
+    var _a, _b;
+    const monacoModule = await getUseMonaco();
+    if (!monacoModule || typeof monacoModule.useMonaco !== 'function' || !isActive())
+        return;
+    const preNodes = Array.from(root.querySelectorAll('pre[data-markstream-code-block="1"]'));
+    for (const pre of preNodes) {
+        if (!isActive())
+            return;
+        const codeNode = pre.querySelector('code');
+        if (!codeNode)
+            continue;
+        const rawLanguage = resolveCodeLanguage(pre, codeNode);
+        const normalizedLanguage = rawLanguage.trim().toLowerCase();
+        if (normalizedLanguage === 'mermaid' || normalizedLanguage === 'infographic' || normalizedLanguage === 'd2' || normalizedLanguage === 'd2lang')
+            continue;
+        const source = codeNode.textContent || '';
+        const diff = pre.dataset.markstreamDiff === '1';
+        const updatedCode = decodeDataPayload(pre.dataset.markstreamUpdated);
+        const monacoLanguage = resolveMonacoLanguage(rawLanguage);
+        const renderLanguage = diff ? 'plaintext' : monacoLanguage;
+        const shell = createEnhancedBlockShell('code', diff ? `Diff / ${monacoLanguage}` : `Code / ${monacoLanguage}`, source, false, options, {
+            showHeader: ((_a = options.codeBlockProps) === null || _a === void 0 ? void 0 : _a.showHeader) !== false,
+        });
+        shell.body.classList.add('markstream-svelte-enhanced-block__body--code');
+        shell.body.style.minHeight = `${estimateCodeBlockHeight(diff ? updatedCode || source : source, diff)}px`;
+        const originalPre = pre.cloneNode(true);
+        let helpers = null;
+        let restored = false;
+        const restoreOriginalPre = () => {
+            var _a;
+            if (restored)
+                return;
+            restored = true;
+            try {
+                (_a = helpers === null || helpers === void 0 ? void 0 : helpers.cleanupEditor) === null || _a === void 0 ? void 0 : _a.call(helpers);
+            }
+            catch {
+                // Ignore cleanup failures during fallback.
+            }
+            if (shell.wrapper.isConnected)
+                shell.wrapper.replaceWith(originalPre.cloneNode(true));
+        };
+        pre.replaceWith(shell.wrapper);
+        helpers = monacoModule.useMonaco({
+            themes: ['vitesse-dark', 'vitesse-light'],
+            languages: Array.from(new Set([monacoLanguage, 'plaintext'])),
+            readOnly: true,
+            minimap: { enabled: false },
+            lineNumbers: 'on',
+            wordWrap: 'off',
+            revealDebounceMs: 75,
+            MAX_HEIGHT: 500,
+            fontSize: 13,
+            ...(options.monacoOptions || {}),
+        });
+        cleanupFns.push(restoreOriginalPre);
+        try {
+            // Vue/React wire Monaco diff editors through dedicated components.
+            // Svelte currently enhances static HTML after the fact, and the diff
+            // editor path in stream-monaco can leave an empty shell or raise
+            // "no diff result available" during worker setup. Prefer a stable
+            // single-editor fallback that still preserves the diff source text.
+            await helpers.createEditor(shell.body, source, renderLanguage);
+            if (!isActive()) {
+                restoreOriginalPre();
+                return;
+            }
+            await ((_b = helpers.setTheme) === null || _b === void 0 ? void 0 : _b.call(helpers, options.isDark ? 'vitesse-dark' : 'vitesse-light'));
+            if (!isActive()) {
+                restoreOriginalPre();
+                return;
+            }
+            await waitForRenderFrame();
+            if (!hasVisibleMonacoContent(shell.body, source))
+                throw new Error('Monaco editor rendered no visible code content.');
+            shell.wrapper.dataset.markstreamMonaco = '1';
+            if (diff)
+                shell.wrapper.dataset.markstreamMonacoDiff = '1';
+        }
+        catch {
+            restoreOriginalPre();
+        }
+    }
+}
+function createD2Instance(D2Ctor) {
+    if (typeof D2Ctor === 'function') {
+        const instance = new D2Ctor();
+        if (instance && typeof instance.compile === 'function')
+            return instance;
+        if (typeof D2Ctor.compile === 'function')
+            return D2Ctor;
+    }
+    if ((D2Ctor === null || D2Ctor === void 0 ? void 0 : D2Ctor.D2) && typeof D2Ctor.D2 === 'function')
+        return new D2Ctor.D2();
+    if (typeof (D2Ctor === null || D2Ctor === void 0 ? void 0 : D2Ctor.compile) === 'function')
+        return D2Ctor;
+    return null;
+}
+function resolveCodeLanguage(pre, codeNode) {
+    var _a;
+    const explicit = (_a = pre.dataset.markstreamLanguage) === null || _a === void 0 ? void 0 : _a.trim();
+    if (explicit)
+        return explicit;
+    const languageClass = Array.from(codeNode.classList).find(className => className.startsWith('language-'));
+    return languageClass ? languageClass.slice('language-'.length) : 'plaintext';
+}
+function resolveMonacoLanguage(language) {
+    const normalized = language.trim().toLowerCase();
+    return MONACO_LANGUAGE_ALIASES[normalized] || normalized || 'plaintext';
+}
+function estimateCodeBlockHeight(source, diff) {
+    const lineCount = Math.max(1, source.split('\n').length);
+    const perLine = diff ? 20 : 18;
+    const base = diff ? 180 : 96;
+    return Math.min(520, base + lineCount * perLine);
+}
+function hasVisibleMonacoContent(body, source) {
+    var _a;
+    const editor = body.querySelector('.monaco-editor');
+    if (!editor)
+        return false;
+    const rect = editor.getBoundingClientRect();
+    if (rect.width <= 0 || rect.height <= 0)
+        return false;
+    const expected = (_a = source.split('\n').find(line => line.trim())) === null || _a === void 0 ? void 0 : _a.trim();
+    if (!expected)
+        return true;
+    const normalizedVisible = normalizeVisibleCodeText(body.textContent || '');
+    const normalizedExpected = normalizeVisibleCodeText(expected);
+    return normalizedVisible.includes(normalizedExpected);
+}
+function normalizeVisibleCodeText(value) {
+    return value.replace(/\s+/g, '');
+}
+async function waitForRenderFrame() {
+    if (typeof window === 'undefined' || typeof window.requestAnimationFrame !== 'function')
+        return;
+    await new Promise(resolve => window.requestAnimationFrame(() => resolve()));
+}
+function decodeDataPayload(value) {
+    var _a, _b;
+    if (!value)
+        return '';
+    const globalBuffer = (_b = (_a = globalThis === null || globalThis === void 0 ? void 0 : globalThis.require) === null || _a === void 0 ? void 0 : _a.call(globalThis, 'buffer')) === null || _b === void 0 ? void 0 : _b.Buffer;
+    if (globalBuffer === null || globalBuffer === void 0 ? void 0 : globalBuffer.from)
+        return globalBuffer.from(value, 'base64').toString('utf8');
+    if (typeof globalThis.atob === 'function' && typeof TextDecoder !== 'undefined') {
+        const binary = globalThis.atob(value);
+        const bytes = Uint8Array.from(binary, char => char.charCodeAt(0));
+        return new TextDecoder().decode(bytes);
+    }
+    return '';
+}
+function createEnhancedBlockShell(kind, label, source, showSourceDetails, options, shellOptions = {}) {
+    const wrapper = document.createElement('div');
+    wrapper.className = `markstream-svelte-enhanced-block markstream-svelte-enhanced-block--${kind}`;
+    if (shellOptions.showHeader !== false) {
+        const header = document.createElement('div');
+        header.className = 'markstream-svelte-enhanced-block__header';
+        const badge = document.createElement('span');
+        badge.className = 'markstream-svelte-enhanced-block__badge';
+        badge.textContent = label;
+        header.appendChild(badge);
+        header.appendChild(createHeaderActions(source, options));
+        wrapper.appendChild(header);
+    }
+    const body = document.createElement('div');
+    body.className = 'markstream-svelte-enhanced-block__body';
+    wrapper.appendChild(body);
+    if (showSourceDetails) {
+        const details = document.createElement('details');
+        details.className = 'markstream-svelte-enhanced-block__details';
+        const summary = document.createElement('summary');
+        summary.textContent = 'Source';
+        details.appendChild(summary);
+        const sourcePre = document.createElement('pre');
+        sourcePre.className = 'markstream-svelte-enhanced-block__source';
+        const code = document.createElement('code');
+        code.textContent = source;
+        sourcePre.appendChild(code);
+        details.appendChild(sourcePre);
+        wrapper.appendChild(details);
+    }
+    return { wrapper, body };
+}
+function createHeaderActions(source, options) {
+    const actions = document.createElement('div');
+    actions.className = 'markstream-svelte-enhanced-block__actions';
+    const copyButton = document.createElement('button');
+    copyButton.type = 'button';
+    copyButton.className = 'markstream-svelte-enhanced-block__action';
+    copyButton.textContent = 'Copy';
+    if (options.showTooltips !== false)
+        copyButton.title = 'Copy source';
+    copyButton.addEventListener('click', () => {
+        var _a;
+        void copyText(source);
+        (_a = options.onCopy) === null || _a === void 0 ? void 0 : _a.call(options, source);
+    });
+    actions.appendChild(copyButton);
+    return actions;
+}
+function enhanceTooltips(root, cleanupFns, options) {
+    if (options.showTooltips === false)
+        return;
+    const targets = Array.from(root.querySelectorAll('[data-markstream-tooltip], [title]'));
+    if (targets.length === 0)
+        return;
+    for (const target of targets) {
+        if (target.matches('.footnote-link, .footnote-anchor'))
+            continue;
+        const title = target.getAttribute('title');
+        const text = (target.dataset.markstreamTooltip || title || '').trim();
+        if (!text)
+            continue;
+        if (title != null)
+            target.removeAttribute('title');
+        const show = () => showTooltipForAnchor(target, text, 'top', false, undefined, options.isDark);
+        const hide = () => hideTooltip();
+        target.addEventListener('mouseenter', show);
+        target.addEventListener('focus', show);
+        target.addEventListener('mouseleave', hide);
+        target.addEventListener('blur', hide);
+        cleanupFns.push(() => {
+            const ownsVisibleTooltip = target.getAttribute('aria-describedby') != null;
+            target.removeEventListener('mouseenter', show);
+            target.removeEventListener('focus', show);
+            target.removeEventListener('mouseleave', hide);
+            target.removeEventListener('blur', hide);
+            if (ownsVisibleTooltip)
+                hideTooltip(true);
+            if (title != null && target.getAttribute('title') == null)
+                target.setAttribute('title', title);
+        });
+    }
+}
+function enhanceFootnotes(root, cleanupFns) {
+    const links = Array.from(root.querySelectorAll('.footnote-reference .footnote-link[href^="#"]'));
+    for (const link of links) {
+        const handleClick = (event) => {
+            const href = link.getAttribute('href');
+            if (!href)
+                return;
+            event.preventDefault();
+            const target = document.getElementById(href.slice(1));
+            target === null || target === void 0 ? void 0 : target.scrollIntoView({ behavior: 'smooth', block: 'start' });
+        };
+        link.addEventListener('click', handleClick);
+        cleanupFns.push(() => link.removeEventListener('click', handleClick));
+    }
+}
+async function copyText(source) {
+    var _a;
+    try {
+        if (typeof navigator !== 'undefined' && ((_a = navigator.clipboard) === null || _a === void 0 ? void 0 : _a.writeText)) {
+            await navigator.clipboard.writeText(source);
+            return;
+        }
+    }
+    catch {
+        // Fall through to the textarea fallback below.
+    }
+    if (typeof document === 'undefined')
+        return;
+    const textarea = document.createElement('textarea');
+    textarea.value = source;
+    textarea.setAttribute('readonly', 'true');
+    textarea.style.position = 'fixed';
+    textarea.style.opacity = '0';
+    textarea.style.pointerEvents = 'none';
+    document.body.appendChild(textarea);
+    textarea.select();
+    try {
+        document.execCommand('copy');
+    }
+    catch {
+        // Ignore copy failures; the output callback still fires.
+    }
+    finally {
+        textarea.remove();
+    }
+}