@j0hanz/fetch-url-mcp 1.12.7 → 1.12.8

package/dist/transform/html-translators.d.ts

@@ -1,5 +0,0 @@
-export declare function extractLanguageFromClassName(className: string): string | undefined;
-export declare function resolveLanguageFromAttributes(className: string, dataLang: string): string | undefined;
-export declare function detectLanguageFromCode(code: string): string | undefined;
-export declare function translateHtmlFragmentToMarkdown(html: string): string;
-//# sourceMappingURL=html-translators.d.ts.map

package/dist/transform/html-translators.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"html-translators.d.ts","sourceRoot":"","sources":["../../src/transform/html-translators.ts"],"names":[],"mappings":"AAkVA,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,SAAS,CAkCpB;AAOD,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GACf,MAAM,GAAG,SAAS,CAKpB;AACD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKvE;AA0cD,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEpE"}

package/dist/transform/html-translators.js

@@ -1,697 +0,0 @@
-import { NodeHtmlMarkdown, } from 'node-html-markdown';
-import { isHtmlNode, isObject } from '../lib/utils.js';
-import { WP_PHOTON_HOST_PATTERN } from './dom-prep.js';
-// ---------------------------------------------------------------------------
-// Shared constant
-// ---------------------------------------------------------------------------
-const CODE_BLOCK = {
-    fence: '```',
-    format: (code, language = '') => `\`\`\`${language}\n${code}\n\`\`\``,
-};
-const MERMAID_POSTPROCESS = ({ content }) => `\n\n\`\`\`mermaid\n${content.trim()}\n\`\`\`\n\n`;
-const MERMAID_TRANSLATOR_CONFIG = {
-    noEscape: true,
-    preserveWhitespace: true,
-    postprocess: MERMAID_POSTPROCESS,
-};
-// ---------------------------------------------------------------------------
-// DOM helpers (translator-only)
-// ---------------------------------------------------------------------------
-function getTagName(node) {
-    if (!isHtmlNode(node))
-        return '';
-    const raw = node.tagName;
-    return typeof raw === 'string' ? raw.toUpperCase() : '';
-}
-function getNode(ctx) {
-    return isObject(ctx) ? ctx['node'] : undefined;
-}
-function getParent(ctx) {
-    return isObject(ctx) ? ctx['parent'] : undefined;
-}
-function getNodeAttr(node) {
-    if (!isHtmlNode(node) || typeof node.getAttribute !== 'function')
-        return undefined;
-    return node.getAttribute.bind(node);
-}
-// ---------------------------------------------------------------------------
-// Code translators
-// ---------------------------------------------------------------------------
-class DetectionContext {
-    code;
-    _lower;
-    _lines;
-    _trimmedStart;
-    constructor(code) {
-        this.code = code;
-    }
-    get lower() {
-        return (this._lower ??= this.code.toLowerCase());
-    }
-    get lines() {
-        return (this._lines ??= this.code.split(/\r?\n/));
-    }
-    get trimmedStart() {
-        return (this._trimmedStart ??= this.code.trimStart());
-    }
-}
-const BASH_COMMANDS = new Set([
-    'sudo',
-    'chmod',
-    'mkdir',
-    'cd',
-    'ls',
-    'cat',
-    'echo',
-]);
-const BASH_PACKAGE_MANAGERS = [
-    'npm',
-    'yarn',
-    'pnpm',
-    'npx',
-    'brew',
-    'apt',
-    'pip',
-    'cargo',
-    'go',
-];
-const TYPESCRIPT_HINTS = [
-    ': string',
-    ':string',
-    ': number',
-    ':number',
-    ': boolean',
-    ':boolean',
-    ': void',
-    ':void',
-    ': any',
-    ':any',
-    ': unknown',
-    ':unknown',
-    ': never',
-    ':never',
-];
-const HTML_TAGS = [
-    '<!doctype',
-    '<html',
-    '<head',
-    '<body',
-    '<div',
-    '<span',
-    '<p',
-    '<a',
-    '<script',
-    '<style',
-];
-function isBashLine(line) {
-    const trimmed = line.trimStart();
-    if (!trimmed)
-        return false;
-    if (trimmed.startsWith('#!') ||
-        trimmed.startsWith('$ ') ||
-        /^\s*\.\.\.\\?>\s+\S/m.test(trimmed)) {
-        return true;
-    }
-    const spaceIdx = trimmed.indexOf(' ');
-    const firstWord = spaceIdx === -1 ? trimmed : trimmed.slice(0, spaceIdx);
-    if (BASH_COMMANDS.has(firstWord))
-        return true;
-    return (spaceIdx !== -1 &&
-        BASH_PACKAGE_MANAGERS.includes(firstWord));
-}
-function detectBashIndicators(lines) {
-    return lines.some(isBashLine);
-}
-function detectCssStructure(lines) {
-    for (const line of lines) {
-        const trimmed = line.trimStart();
-        if (!trimmed || trimmed.startsWith('# ') || trimmed.startsWith('//')) {
-            continue;
-        }
-        if (/^[.#][A-Za-z_-][\w-]*\s*\{/.test(trimmed))
-            return true;
-        if (trimmed.includes(';') &&
-            /^\s*[a-z][\w-]*\s*:/.test(trimmed) &&
-            !trimmed.includes('(')) {
-            return true;
-        }
-    }
-    return false;
-}
-function detectYamlStructure(lines) {
-    for (const line of lines) {
-        const trimmed = line.trim();
-        const colonIdx = trimmed.indexOf(':');
-        if (colonIdx > 0) {
-            const after = trimmed[colonIdx + 1];
-            if (after === ' ' || after === '\t')
-                return true;
-        }
-    }
-    return false;
-}
-const LANGUAGES = [
-    {
-        lang: 'rust',
-        weight: 25,
-        match: (ctx) => ctx.lower.includes('let mut') ||
-            /\b(?:fn|impl|struct|enum)\b/.test(ctx.lower) ||
-            (ctx.lower.includes('use ') && ctx.lower.includes('::')),
-    },
-    {
-        lang: 'go',
-        weight: 22,
-        match: (ctx) => ctx.lower.includes('import "') || /\b(?:package|func)\b/.test(ctx.lower),
-    },
-    {
-        lang: 'jsx',
-        weight: 22,
-        match: (ctx) => {
-            const l = ctx.lower;
-            if (l.includes('classname=') ||
-                l.includes('jsx:') ||
-                l.includes("from 'react'") ||
-                l.includes('from "react"')) {
-                return true;
-            }
-            return /<\/?[A-Z][A-Za-z0-9]*(?:\s+[A-Za-z_:][\w:.-]*(?:\s*=\s*(?:"[^"]*"|'[^']*'|\{[^}]*\}))?)*\s*\/?>/m.test(ctx.code);
-        },
-    },
-    {
-        lang: 'typescript',
-        weight: 20,
-        match: (ctx) => /\b(?:interface|type)\b/.test(ctx.lower) ||
-            TYPESCRIPT_HINTS.some((hint) => ctx.lower.includes(hint)),
-    },
-    {
-        lang: 'sql',
-        weight: 20,
-        match: (ctx) => /\b(?:select\s+(?:.+?\s+from|[\d*@])|insert\s+into|update\s+.+?\s+set|delete\s+from|create\s+(?:table|database|index|view|function|procedure|trigger|user|role)|alter\s+(?:table|database|index|view))\b/.test(ctx.lower),
-    },
-    {
-        lang: 'html',
-        weight: 19,
-        match: (ctx) => HTML_TAGS.some((tag) => ctx.lower.includes(tag)),
-    },
-    {
-        lang: 'python',
-        weight: 18,
-        match: (ctx) => {
-            if (HTML_TAGS.some((tag) => ctx.lower.includes(tag)))
-                return false;
-            const l = ctx.lower;
-            const c = ctx.code;
-            if (/^\s*(?:>>>|\.\.\.)\s/m.test(c) ||
-                /<(?:QuerySet|[A-Z][A-Za-z0-9_]*:\s)|\bdatetime\.datetime\(|\bDoesNotExist:/.test(c) ||
-                /^\s*[A-Za-z_][\w.]*\s*=\s*[A-Z][\w.]*\(/m.test(c) ||
-                /^\s*[A-Za-z_][\w.]*\.[A-Za-z_][\w]*\s*$/m.test(c) ||
-                c.includes('None') ||
-                c.includes('True') ||
-                c.includes('False') ||
-                l.includes('print(') ||
-                l.includes('__name__') ||
-                l.includes('self.') ||
-                l.includes('elif ') ||
-                /\b(?:def |elif |except |finally:|yield |lambda |raise |pass$)/m.test(l)) {
-                return true;
-            }
-            const hasJsSignals = /\b(?:const |let |var |function |require\(|=>|===|!==|console\.)/.test(l) ||
-                l.includes('{') ||
-                l.includes("from '");
-            return /\b(?:import|from|class)\b/.test(l) && !hasJsSignals;
-        },
-    },
-    {
-        lang: 'css',
-        weight: 18,
-        match: (ctx) => /@media|@import|@keyframes|@theme\b|@utility\b|@layer\b|@apply\b|@variant\b|@custom-variant\b|@reference\b|@source\b/.test(ctx.lower) || detectCssStructure(ctx.lines),
-    },
-    { lang: 'bash', weight: 15, match: (ctx) => detectBashIndicators(ctx.lines) },
-    { lang: 'yaml', weight: 15, match: (ctx) => detectYamlStructure(ctx.lines) },
-    {
-        lang: 'javascript',
-        weight: 15,
-        match: (ctx) => /\b(?:const|let|var|function|class|async|await|export|import)\b/.test(ctx.lower),
-    },
-    {
-        lang: 'json',
-        weight: 10,
-        match: (ctx) => ctx.trimmedStart.startsWith('{') || ctx.trimmedStart.startsWith('['),
-    },
-];
-const KNOWN_LANG_PREFIXES = new Set([
-    'css',
-    'javascript',
-    'js',
-    'typescript',
-    'ts',
-    'python',
-    'py',
-    'html',
-    'xml',
-    'sql',
-    'bash',
-    'sh',
-    'yaml',
-    'json',
-    'ruby',
-    'go',
-    'rust',
-    'java',
-    'php',
-    'c',
-    'cpp',
-    'swift',
-    'kotlin',
-    'scss',
-    'sass',
-    'less',
-    'graphql',
-    'markdown',
-    'md',
-]);
-export function extractLanguageFromClassName(className) {
-    if (!className)
-        return undefined;
-    // Split by whitespace and check for language indicators
-    const tokens = className.match(/\S+/g);
-    if (!tokens)
-        return undefined;
-    // Fast path: check for prefixes
-    for (const token of tokens) {
-        const lower = token.toLowerCase();
-        if (lower.startsWith('language-'))
-            return token.slice(9);
-        if (lower.startsWith('lang-'))
-            return token.slice(5);
-        if (lower.startsWith('highlight-'))
-            return token.slice(10);
-    }
-    // Special handling for hljs which often appears with a separate language class
-    if (tokens.includes('hljs')) {
-        const langClass = tokens.find((t) => {
-            const l = t.toLowerCase();
-            return l !== 'hljs' && !l.startsWith('hljs-');
-        });
-        if (langClass)
-            return langClass;
-    }
-    // Last resort: look for any known language prefix followed by a dash
-    for (const token of tokens) {
-        const dashIdx = token.indexOf('-');
-        if (dashIdx > 0) {
-            const prefix = token.slice(0, dashIdx).toLowerCase();
-            if (KNOWN_LANG_PREFIXES.has(prefix))
-                return prefix;
-        }
-    }
-    return undefined;
-}
-function resolveLanguageFromDataAttribute(dataLang) {
-    const trimmed = dataLang.trim();
-    return /^\w+$/.test(trimmed) ? trimmed : undefined;
-}
-export function resolveLanguageFromAttributes(className, dataLang) {
-    return (extractLanguageFromClassName(className) ??
-        resolveLanguageFromDataAttribute(dataLang));
-}
-export function detectLanguageFromCode(code) {
-    if (!code || !/\S/.test(code))
-        return undefined;
-    const ctx = new DetectionContext(code);
-    return LANGUAGES.find((def) => def.match(ctx))?.lang;
-}
-function buildInlineCode(content) {
-    const trimmed = content.trim();
-    if (!trimmed)
-        return '``';
-    const matches = trimmed.match(/`+/g);
-    const maxBackticks = matches ? Math.max(...matches.map((m) => m.length)) : 0;
-    const delimiter = '`'.repeat(maxBackticks + 1);
-    const padding = trimmed.startsWith('`') || trimmed.endsWith('`') ? ' ' : '';
-    return `${delimiter}${padding}${trimmed}${padding}${delimiter}`;
-}
-function isCodeBlock(parent) {
-    const tagName = getTagName(parent);
-    return tagName === 'PRE' || tagName === 'WRAPPED-PRE';
-}
-function resolveAttributeLanguage(node) {
-    const getAttribute = getNodeAttr(node);
-    const className = getAttribute?.('class') ?? '';
-    const dataLanguage = getAttribute?.('data-language') ?? '';
-    return resolveLanguageFromAttributes(className, dataLanguage);
-}
-function findLanguageFromCodeChild(node) {
-    if (!isHtmlNode(node))
-        return undefined;
-    const childNodes = Array.from(node.childNodes ?? []);
-    for (const child of childNodes) {
-        if (!isHtmlNode(child))
-            continue;
-        const raw = child.rawTagName;
-        const tagName = typeof raw === 'string' ? raw.toUpperCase() : '';
-        if (tagName === 'CODE')
-            return resolveAttributeLanguage(child);
-    }
-    return undefined;
-}
-function createCodeBlockPostprocessor(language) {
-    return ({ content }) => {
-        const trimmed = content.trim();
-        if (!trimmed)
-            return '';
-        const resolvedLanguage = language ?? detectLanguageFromCode(trimmed) ?? '';
-        return CODE_BLOCK.format(trimmed, resolvedLanguage);
-    };
-}
-function buildInlineCodeTranslator() {
-    return {
-        spaceIfRepeatingChar: true,
-        noEscape: true,
-        postprocess: ({ content }) => buildInlineCode(content),
-    };
-}
-function buildCodeTranslator(ctx) {
-    const inlineCodeTranslator = buildInlineCodeTranslator();
-    if (!isCodeBlock(getParent(ctx)))
-        return inlineCodeTranslator;
-    return { noEscape: true, preserveWhitespace: true };
-}
-// ---------------------------------------------------------------------------
-// Image translators
-// ---------------------------------------------------------------------------
-function extractFirstSrcsetUrl(srcset) {
-    return srcset.split(',')[0]?.trim().split(/\s+/)[0] ?? '';
-}
-const LAZY_SRC_ATTRIBUTES = [
-    'data-src',
-    'data-lazy-src',
-    'data-lazy',
-    'data-original',
-    'data-echo',
-    'data-srcset',
-];
-function isDataUri(value) {
-    return value.startsWith('data:');
-}
-const PLACEHOLDER_FILENAME_PATTERN = /(?:^|\/)(?:blank|spacer|placeholder|grey|gray|pixel|loading|lazy|transparent|empty|dummy)\.[a-z]{3,4}$/i;
-function isPlaceholderSrc(value) {
-    if (isDataUri(value))
-        return true;
-    const parsed = URL.parse(value) ?? URL.parse(value, 'http://localhost');
-    if (!parsed)
-        return false;
-    return PLACEHOLDER_FILENAME_PATTERN.test(parsed.pathname);
-}
-function extractNonDataSrcsetUrl(value) {
-    const url = extractFirstSrcsetUrl(value);
-    return url && !isDataUri(url) ? url : undefined;
-}
-function resolveLazySrc(getAttribute) {
-    for (const attr of LAZY_SRC_ATTRIBUTES) {
-        const lazy = getAttribute(attr);
-        if (!lazy || isDataUri(lazy))
-            continue;
-        if (attr === 'data-srcset') {
-            const url = extractNonDataSrcsetUrl(lazy);
-            if (url)
-                return url;
-            continue;
-        }
-        return lazy;
-    }
-    return undefined;
-}
-// Some sites (notably WordPress with Photon CDN) use a CDN proxy URL in img src while keeping the original same-domain URL in srcset.
-// Since the converter prefers srcset URLs for CDN-hosted images, we need to detect this pattern and extract the canonical URL from srcset to ensure images are correctly resolved, especially when migrating content to a new domain.
-function isWpPhotonUrl(src) {
-    const parsed = URL.parse(src);
-    return parsed !== null && WP_PHOTON_HOST_PATTERN.test(parsed.hostname);
-}
-function resolveImageSrc(getAttribute) {
-    if (!getAttribute)
-        return '';
-    const srcRaw = getAttribute('src') ?? '';
-    const srcsetUrl = extractNonDataSrcsetUrl(getAttribute('srcset') ?? '');
-    // When src is a CDN proxy URL, prefer srcset which usually has the
-    // canonical same-domain URL that survives domain migrations.
-    if (srcRaw && isWpPhotonUrl(srcRaw) && srcsetUrl)
-        return srcsetUrl;
-    if (srcRaw && !isPlaceholderSrc(srcRaw))
-        return srcRaw;
-    // First check common lazy-loading attributes that may contain non-data URLs before falling back to the native srcset, as some sites use data URIs in lazy attributes while still providing valid URLs in srcset.
-    const lazySrc = resolveLazySrc(getAttribute);
-    if (lazySrc)
-        return lazySrc;
-    // If the src is a data URI or missing, check srcset for a valid URL. Some sites use srcset with data URIs in src and actual URLs in srcset for responsive images.
-    if (srcsetUrl)
-        return srcsetUrl;
-    return '';
-}
-function deriveAltFromImageUrl(src) {
-    if (!src)
-        return '';
-    const absoluteParsed = URL.parse(src);
-    const parsed = absoluteParsed ?? URL.parse(src, 'http://localhost');
-    if (!parsed)
-        return '';
-    if (absoluteParsed &&
-        parsed.protocol !== 'http:' &&
-        parsed.protocol !== 'https:') {
-        return '';
-    }
-    const match = /\/([^/]+?)(?:\.[^/.]+)?$/.exec(parsed.pathname);
-    if (!match?.[1])
-        return '';
-    return match[1].replace(/[_-]+/g, ' ').trim();
-}
-function buildImageTranslator(ctx) {
-    const getAttribute = getNodeAttr(getNode(ctx));
-    const src = resolveImageSrc(getAttribute);
-    const existingAlt = getAttribute?.('alt') ?? '';
-    if (!src) {
-        return { content: existingAlt.trim() };
-    }
-    const alt = existingAlt.trim() || deriveAltFromImageUrl(src);
-    return { content: `![${alt}](${src})` };
-}
-// ---------------------------------------------------------------------------
-// Pre / Mermaid translators
-// ---------------------------------------------------------------------------
-function buildPreTranslator(ctx) {
-    const node = getNode(ctx);
-    if (!node)
-        return {};
-    const attributeLanguage = resolveAttributeLanguage(node) ?? findLanguageFromCodeChild(node);
-    return {
-        noEscape: true,
-        preserveWhitespace: true,
-        postprocess: createCodeBlockPostprocessor(attributeLanguage),
-    };
-}
-function buildMermaidPreTranslator(ctx) {
-    const node = getNode(ctx);
-    const getAttribute = getNodeAttr(node);
-    const className = getAttribute?.('class') ?? '';
-    if (className.includes('mermaid'))
-        return MERMAID_TRANSLATOR_CONFIG;
-    return buildPreTranslator(ctx);
-}
-// ---------------------------------------------------------------------------
-// Block-level translators (div, section, span, table, dl, etc.)
-// ---------------------------------------------------------------------------
-const GFM_ALERT_MAP = new Map([
-    ['note', 'NOTE'],
-    ['info', 'NOTE'],
-    ['tip', 'TIP'],
-    ['hint', 'TIP'],
-    ['warning', 'WARNING'],
-    ['warn', 'WARNING'],
-    ['caution', 'CAUTION'],
-    ['danger', 'CAUTION'],
-    ['important', 'IMPORTANT'],
-]);
-function resolveGfmAlertType(className) {
-    const tokens = className.toLowerCase().split(/\s+/);
-    for (const token of tokens) {
-        const mapped = GFM_ALERT_MAP.get(token);
-        if (mapped)
-            return mapped;
-    }
-    return undefined;
-}
-function buildAdmonitionConfig(className, alertType, getAttribute) {
-    const isAdmonition = className.includes('admonition') ||
-        className.includes('callout') ||
-        className.includes('custom-block') ||
-        getAttribute('role') === 'alert' ||
-        alertType !== undefined;
-    if (!isAdmonition)
-        return undefined;
-    return {
-        postprocess: ({ content }) => {
-            const lines = content.trim().split('\n');
-            const header = alertType ? `> [!${alertType}]\n` : '';
-            return `\n\n${header}> ${lines.join('\n> ')}\n\n`;
-        },
-    };
-}
-function buildTypeSpacingConfig() {
-    return {
-        postprocess: ({ content }) => {
-            const lines = content.split('\n');
-            const separated = [];
-            for (let i = 0; i < lines.length; i++) {
-                const line = lines[i] ?? '';
-                separated.push(line);
-                const nextLine = lines[i + 1];
-                if (nextLine !== undefined &&
-                    line.trim() &&
-                    nextLine.trim() &&
-                    line.includes(':') &&
-                    nextLine.includes(':') &&
-                    !line.startsWith(' ') &&
-                    !nextLine.startsWith(' ')) {
-                    separated.push('');
-                }
-            }
-            return separated.join('\n');
-        },
-    };
-}
-function buildDivTranslator(ctx) {
-    const getAttribute = getNodeAttr(getNode(ctx));
-    if (!getAttribute)
-        return {};
-    const className = getAttribute('class') ?? '';
-    if (className.includes('mermaid'))
-        return MERMAID_TRANSLATOR_CONFIG;
-    const alertType = resolveGfmAlertType(className);
-    const admonition = buildAdmonitionConfig(className, alertType, getAttribute);
-    if (admonition)
-        return admonition;
-    if (!className.includes('type'))
-        return {};
-    return buildTypeSpacingConfig();
-}
-function buildSectionTranslator(ctx) {
-    const getAttribute = getNodeAttr(getNode(ctx));
-    if (getAttribute?.('class')?.includes('tsd-member')) {
-        return {
-            postprocess: ({ content }) => `\n\n&nbsp;\n\n${content}\n\n`,
-        };
-    }
-    return {
-        postprocess: ({ content }) => `\n\n${content}\n\n`,
-    };
-}
-function buildSpanTranslator(ctx) {
-    const getAttribute = getNodeAttr(getNode(ctx));
-    if (getAttribute?.('data-as') === 'p') {
-        return {
-            postprocess: ({ content }) => `\n\n${content.trim()}\n\n`,
-        };
-    }
-    return {};
-}
-// ---------------------------------------------------------------------------
-// DL helpers
-// ---------------------------------------------------------------------------
-function normalizeDefinitionListContent(content) {
-    const lines = content
-        .split('\n')
-        .map((line) => line.trim())
-        .filter(Boolean);
-    if (lines.length === 0)
-        return '';
-    const normalized = [];
-    for (const line of lines) {
-        const isDefinition = line.startsWith(': ');
-        const previous = normalized[normalized.length - 1];
-        if (previous &&
-            previous.length > 0 &&
-            !previous.startsWith(': ') &&
-            !isDefinition) {
-            normalized.push('');
-        }
-        normalized.push(line);
-    }
-    return normalized.join('\n');
-}
-// ---------------------------------------------------------------------------
-// Simple tag translators
-// ---------------------------------------------------------------------------
-function buildDlTranslator() {
-    return {
-        postprocess: ({ content }) => {
-            const normalized = normalizeDefinitionListContent(content);
-            return normalized ? `\n\n${normalized}\n\n` : '';
-        },
-    };
-}
-function buildDtTranslator() {
-    return {
-        postprocess: ({ content }) => `${content.trim()}\n`,
-    };
-}
-function buildDdTranslator() {
-    return {
-        postprocess: ({ content }) => content.trim() ? `: ${content.trim()}\n` : '',
-    };
-}
-function wrapTranslator(prefix, suffix) {
-    return () => ({
-        postprocess: ({ content }) => `${prefix}${content}${suffix}`,
-    });
-}
-function buildDetailsTranslator() {
-    return {
-        postprocess: ({ content }) => {
-            const trimmed = content.trim();
-            if (!trimmed)
-                return '';
-            return `\n\n${trimmed}\n\n`;
-        },
-    };
-}
-function buildSummaryTranslator() {
-    return {
-        postprocess: ({ content }) => `${content.trim()}\n\n`,
-    };
-}
-// ---------------------------------------------------------------------------
-// Translator registry + converter singleton
-// ---------------------------------------------------------------------------
-function createCustomTranslators() {
-    return {
-        code: buildCodeTranslator,
-        img: buildImageTranslator,
-        dl: buildDlTranslator,
-        dt: buildDtTranslator,
-        dd: buildDdTranslator,
-        div: buildDivTranslator,
-        kbd: wrapTranslator('`', '`'),
-        mark: wrapTranslator('==', '=='),
-        sub: wrapTranslator('~', '~'),
-        sup: wrapTranslator('^', '^'),
-        section: buildSectionTranslator,
-        details: buildDetailsTranslator,
-        summary: buildSummaryTranslator,
-        span: buildSpanTranslator,
-        pre: buildMermaidPreTranslator,
-    };
-}
-let markdownConverter = null;
-function getMarkdownConverter() {
-    markdownConverter ??= new NodeHtmlMarkdown({
-        codeFence: CODE_BLOCK.fence,
-        codeBlockStyle: 'fenced',
-        emDelimiter: '_',
-        bulletMarker: '-',
-        globalEscape: [/[\\`*_~]/gm, '\\$&'],
-    }, createCustomTranslators());
-    return markdownConverter;
-}
-export function translateHtmlFragmentToMarkdown(html) {
-    return getMarkdownConverter().translate(html).trim();
-}