@xjtlumedia/markdown-mcp-server 1.0.4 → 2.0.0

package/dist/markdown-repair.js

@@ -0,0 +1,263 @@
+// ── Markdown Repair / Linting ────────────────────────────────────────
+// Fixes common broken markdown from LLM output
+export function repairMarkdown(md) {
+    let out = md;
+    out = repairCodeFences(out);
+    out = repairBrokenTables(out);
+    out = repairStrayMarkers(out);
+    out = repairHeadings(out);
+    out = repairListIndentation(out);
+    out = repairBrokenLinks(out);
+    out = normalizeWhitespace(out);
+    return out;
+}
+// Fix unclosed or mismatched code fences
+export function repairCodeFences(md) {
+    const lines = md.split('\n');
+    const result = [];
+    let inFence = false;
+    let fenceChar = '`';
+    let fenceCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const backtickMatch = line.match(/^(`{3,})([\w]*)\s*$/);
+        const tildeMatch = line.match(/^(~{3,})([\w]*)\s*$/);
+        const match = backtickMatch || tildeMatch;
+        if (match) {
+            const char = match[1][0];
+            const count = match[1].length;
+            if (!inFence) {
+                inFence = true;
+                fenceChar = char;
+                fenceCount = count;
+                result.push(line);
+            }
+            else if (char === fenceChar && count >= fenceCount) {
+                inFence = false;
+                result.push(fenceChar.repeat(fenceCount));
+            }
+            else {
+                result.push(line);
+            }
+        }
+        else {
+            result.push(line);
+        }
+    }
+    // Close unclosed fence at end
+    if (inFence) {
+        result.push(fenceChar.repeat(fenceCount));
+    }
+    return result.join('\n');
+}
+// Fix broken tables (mismatched columns, missing separators)
+export function repairBrokenTables(md) {
+    const lines = md.split('\n');
+    const result = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        // Detect table start: line with pipes
+        if (line.trim().includes('|') && line.trim().startsWith('|')) {
+            const tableLines = [];
+            while (i < lines.length && lines[i].trim().includes('|') && lines[i].trim().startsWith('|')) {
+                tableLines.push(lines[i]);
+                i++;
+            }
+            if (tableLines.length >= 1) {
+                const repaired = repairTableBlock(tableLines);
+                result.push(...repaired);
+            }
+            continue;
+        }
+        result.push(line);
+        i++;
+    }
+    return result.join('\n');
+}
+function repairTableBlock(lines) {
+    // Parse cells and find max column count
+    const parsed = lines
+        .filter(l => !/^\|[\s-:]+\|[\s-:|]*$/.test(l.trim())) // remove existing separators
+        .map(l => l.split('|').slice(1, -1).map(c => c.trim()));
+    if (parsed.length === 0)
+        return lines;
+    const maxCols = Math.max(...parsed.map(r => r.length));
+    // Pad rows to have consistent column count
+    const padded = parsed.map(row => {
+        while (row.length < maxCols)
+            row.push('');
+        return row;
+    });
+    // Reconstruct table
+    const result = [];
+    result.push('| ' + padded[0].join(' | ') + ' |');
+    result.push('| ' + padded[0].map(() => '---').join(' | ') + ' |');
+    for (let i = 1; i < padded.length; i++) {
+        result.push('| ' + padded[i].join(' | ') + ' |');
+    }
+    return result;
+}
+// Fix stray emphasis markers (* or _ at start/end without matching)
+export function repairStrayMarkers(md) {
+    let out = md;
+    // Fix unmatched bold markers at line level
+    out = out.replace(/^(\*\*[^*]+)$/gm, (m) => {
+        if (!m.endsWith('**'))
+            return m + '**';
+        return m;
+    });
+    out = out.replace(/^([^*]+\*\*)$/gm, (m) => {
+        if (!m.startsWith('**'))
+            return '**' + m;
+        return m;
+    });
+    // Fix solo backticks (odd count of backticks on a line)
+    out = out.replace(/^((?:[^`]*`[^`]*){1,})$/gm, (line) => {
+        const count = (line.match(/`/g) || []).length;
+        if (count % 2 !== 0) {
+            // Find the last backtick and close it
+            return line + '`';
+        }
+        return line;
+    });
+    return out;
+}
+// Fix heading spacing and format
+export function repairHeadings(md) {
+    let out = md;
+    // Fix missing space after #: #Heading → # Heading
+    out = out.replace(/^(#{1,6})([^\s#])/gm, '$1 $2');
+    // Fix trailing hashes: # Heading # → # Heading
+    out = out.replace(/^(#{1,6}\s+.+?)\s*#+\s*$/gm, '$1');
+    // Ensure blank line before headings (unless at start of doc)
+    const lines = out.split('\n');
+    const result = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (i > 0 && /^#{1,6}\s/.test(lines[i]) && lines[i - 1].trim() !== '') {
+            result.push('');
+        }
+        result.push(lines[i]);
+    }
+    return result.join('\n');
+}
+// Fix inconsistent list indentation
+export function repairListIndentation(md) {
+    const lines = md.split('\n');
+    const result = [];
+    for (const line of lines) {
+        // Normalize tab-based indentation to spaces
+        let fixed = line.replace(/\t/g, '    ');
+        // Fix mixed list markers at same level to use consistent marker
+        if (/^\s*[+]\s/.test(fixed)) {
+            fixed = fixed.replace(/^(\s*)[+]\s/, '$1- ');
+        }
+        result.push(fixed);
+    }
+    return result.join('\n');
+}
+// Fix broken link syntax
+export function repairBrokenLinks(md) {
+    let out = md;
+    // Fix missing closing paren: [text](url → [text](url)
+    out = out.replace(/\[([^\]]+)\]\(([^)\s]+)(?=\s|$)/gm, '[$1]($2)');
+    // Fix missing closing bracket: [text(url) → [text](url)
+    out = out.replace(/\[([^\]]+)\(([^)]+)\)/g, '[$1]($2)');
+    return out;
+}
+// Normalize excessive whitespace
+export function normalizeWhitespace(md) {
+    let out = md;
+    // Remove trailing whitespace (except intentional line breaks: 2+ spaces)
+    out = out.replace(/([^ \n]) +$/gm, '$1');
+    // Collapse 3+ blank lines to 2
+    out = out.replace(/\n{4,}/g, '\n\n\n');
+    // Ensure file ends with single newline
+    out = out.replace(/\n*$/, '\n');
+    return out;
+}
+// ── Markdown Linting ─────────────────────────────────────────────────
+export function lintMarkdown(md) {
+    const issues = [];
+    const lines = md.split('\n');
+    let inCodeBlock = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNum = i + 1;
+        // Track code blocks
+        if (/^```/.test(line.trim())) {
+            inCodeBlock = !inCodeBlock;
+            continue;
+        }
+        if (inCodeBlock)
+            continue;
+        // Missing space after heading marker
+        if (/^#{1,6}[^\s#]/.test(line)) {
+            issues.push({
+                line: lineNum, column: 1, severity: 'error',
+                rule: 'heading-space', message: 'Missing space after heading marker (#)',
+                fixable: true
+            });
+        }
+        // Trailing whitespace
+        if (/\S +$/.test(line) && !/  $/.test(line)) {
+            issues.push({
+                line: lineNum, column: line.length, severity: 'warning',
+                rule: 'trailing-whitespace', message: 'Trailing whitespace',
+                fixable: true
+            });
+        }
+        // Inconsistent list markers
+        if (/^\s*[+]\s/.test(line)) {
+            issues.push({
+                line: lineNum, column: 1, severity: 'warning',
+                rule: 'list-marker', message: 'Inconsistent list marker (+), prefer - or *',
+                fixable: true
+            });
+        }
+        // Hard tabs
+        if (line.includes('\t')) {
+            issues.push({
+                line: lineNum, column: line.indexOf('\t') + 1, severity: 'warning',
+                rule: 'no-hard-tabs', message: 'Hard tab found, prefer spaces',
+                fixable: true
+            });
+        }
+        // Multiple blank lines
+        if (i > 1 && line.trim() === '' && lines[i - 1].trim() === '' && lines[i - 2]?.trim() === '') {
+            issues.push({
+                line: lineNum, column: 1, severity: 'info',
+                rule: 'no-multiple-blanks', message: 'Multiple consecutive blank lines',
+                fixable: true
+            });
+        }
+        // Bare URLs (not inside links or code)
+        if (/(?<!\(|<)https?:\/\/[^\s)>]+/.test(line) && !/\[.*\]\(/.test(line) && !/`/.test(line)) {
+            issues.push({
+                line: lineNum,
+                column: line.search(/https?:\/\//) + 1,
+                severity: 'info',
+                rule: 'bare-url', message: 'Bare URL found, consider wrapping in link syntax',
+                fixable: false
+            });
+        }
+        // Unclosed emphasis (simple heuristic)
+        const boldCount = (line.match(/\*\*/g) || []).length;
+        if (boldCount % 2 !== 0) {
+            issues.push({
+                line: lineNum, column: 1, severity: 'warning',
+                rule: 'unclosed-emphasis', message: 'Possible unclosed bold (**) markers',
+                fixable: true
+            });
+        }
+    }
+    // Check for unclosed code fences
+    if (inCodeBlock) {
+        issues.push({
+            line: lines.length, column: 1, severity: 'error',
+            rule: 'unclosed-code-fence', message: 'Unclosed code fence (```) at end of document',
+            fixable: true
+        });
+    }
+    return issues;
+}

package/dist/platform-converters.js

@@ -0,0 +1,419 @@
+// ── Slack mrkdwn ─────────────────────────────────────────────────────
+export function markdownToSlack(md) {
+    let out = md;
+    // Bold: **text** → *text*
+    out = out.replace(/\*\*([^*]+)\*\*/g, '*$1*');
+    // Italic: *text* or _text_ → _text_
+    out = out.replace(/(?<!\*)\*(?!\*)([^*]+)(?<!\*)\*(?!\*)/g, '_$1_');
+    // Strikethrough: ~~text~~ → ~text~
+    out = out.replace(/~~([^~]+)~~/g, '~$1~');
+    // Inline code stays as backtick
+    // Code blocks: ```lang\n...\n``` stays the same (Slack supports it)
+    // Links: [text](url) → <url|text>
+    out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<$2|$1>');
+    // Images: ![alt](url) → <url|alt>
+    out = out.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '<$2|$1>');
+    // Headers: # text → *text*
+    out = out.replace(/^#{1,6}\s+(.+)$/gm, '*$1*');
+    // Blockquotes: > text → > text (Slack supports >)
+    // Ordered lists: 1. text stays the same
+    // Unordered lists: - text stays the same
+    // Horizontal rule
+    out = out.replace(/^(-{3,}|\*{3,}|_{3,})$/gm, '───────────────');
+    return out;
+}
+// ── Discord markdown ─────────────────────────────────────────────────
+export function markdownToDiscord(md) {
+    let out = md;
+    // Discord supports most standard markdown, just a few tweaks:
+    // Headers: # text → **__text__** (Discord renders # only in certain contexts)
+    out = out.replace(/^# (.+)$/gm, '**__$1__**');
+    out = out.replace(/^## (.+)$/gm, '**$1**');
+    out = out.replace(/^### (.+)$/gm, '__$1__');
+    out = out.replace(/^#{4,6}\s+(.+)$/gm, '*$1*');
+    // Spoiler: no markdown equivalent, keep as-is
+    // Block quotes: > works in Discord
+    // Code blocks: ``` works in Discord
+    // Horizontal rules are not rendered in Discord
+    out = out.replace(/^(-{3,}|\*{3,}|_{3,})$/gm, '');
+    return out;
+}
+// ── JIRA wiki markup ─────────────────────────────────────────────────
+export function markdownToJira(md) {
+    let out = md;
+    // Headers: # → h1., ## → h2., etc.
+    out = out.replace(/^######\s+(.+)$/gm, 'h6. $1');
+    out = out.replace(/^#####\s+(.+)$/gm, 'h5. $1');
+    out = out.replace(/^####\s+(.+)$/gm, 'h4. $1');
+    out = out.replace(/^###\s+(.+)$/gm, 'h3. $1');
+    out = out.replace(/^##\s+(.+)$/gm, 'h2. $1');
+    out = out.replace(/^#\s+(.+)$/gm, 'h1. $1');
+    // Bold: **text** → *text*
+    out = out.replace(/\*\*([^*]+)\*\*/g, '*$1*');
+    // Italic: *text* → _text_
+    out = out.replace(/(?<!\*)\*(?!\*)([^*]+)(?<!\*)\*(?!\*)/g, '_$1_');
+    // Strikethrough: ~~text~~ → -text-
+    out = out.replace(/~~([^~]+)~~/g, '-$1-');
+    // Inline code: `code` → {{code}}
+    out = out.replace(/`([^`]+)`/g, '{{$1}}');
+    // Code blocks: ```lang → {code:lang} / ``` → {code}
+    out = out.replace(/```(\w+)?\n([\s\S]*?)```/g, (_m, lang, code) => lang ? `{code:${lang}}\n${code.trimEnd()}\n{code}` : `{code}\n${code.trimEnd()}\n{code}`);
+    // Links: [text](url) → [text|url]
+    out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '[$1|$2]');
+    // Images: ![alt](url) → !url!
+    out = out.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '!$2!');
+    // Unordered list: - text → * text  (JIRA uses *)
+    out = out.replace(/^(\s*)[-+]\s+/gm, (_m, indent) => {
+        const level = Math.floor(indent.length / 2) + 1;
+        return '*'.repeat(level) + ' ';
+    });
+    // Ordered list: 1. text → # text
+    out = out.replace(/^(\s*)\d+\.\s+/gm, (_m, indent) => {
+        const level = Math.floor(indent.length / 2) + 1;
+        return '#'.repeat(level) + ' ';
+    });
+    // Blockquote: > text → {quote}text{quote}
+    out = out.replace(/^>\s+(.+)$/gm, '{quote}$1{quote}');
+    // Horizontal rules
+    out = out.replace(/^(-{3,}|\*{3,}|_{3,})$/gm, '----');
+    // Tables: | A | B | → || A || B || for header, | a | b | for body
+    const lines = out.split('\n');
+    const result = [];
+    let headerDone = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.trim().startsWith('|') && line.trim().endsWith('|')) {
+            // Skip separator rows
+            if (/^\|[\s-:]+\|/.test(line.trim())) {
+                headerDone = true;
+                continue;
+            }
+            if (!headerDone) {
+                // Convert header cells: | A | B | → || A || B ||
+                result.push(line.replace(/\|/g, '||'));
+            }
+            else {
+                result.push(line);
+            }
+        }
+        else {
+            headerDone = false;
+            result.push(line);
+        }
+    }
+    return result.join('\n');
+}
+// ── Confluence wiki markup ───────────────────────────────────────────
+export function markdownToConfluence(md) {
+    let out = md;
+    // Headers
+    out = out.replace(/^######\s+(.+)$/gm, 'h6. $1');
+    out = out.replace(/^#####\s+(.+)$/gm, 'h5. $1');
+    out = out.replace(/^####\s+(.+)$/gm, 'h4. $1');
+    out = out.replace(/^###\s+(.+)$/gm, 'h3. $1');
+    out = out.replace(/^##\s+(.+)$/gm, 'h2. $1');
+    out = out.replace(/^#\s+(.+)$/gm, 'h1. $1');
+    // Bold, Italic, Strikethrough (same as JIRA)
+    out = out.replace(/\*\*([^*]+)\*\*/g, '*$1*');
+    out = out.replace(/(?<!\*)\*(?!\*)([^*]+)(?<!\*)\*(?!\*)/g, '_$1_');
+    out = out.replace(/~~([^~]+)~~/g, '-$1-');
+    // Inline code
+    out = out.replace(/`([^`]+)`/g, '{{$1}}');
+    // Code blocks
+    out = out.replace(/```(\w+)?\n([\s\S]*?)```/g, (_m, lang, code) => lang ? `{code:language=${lang}}\n${code.trimEnd()}\n{code}` : `{code}\n${code.trimEnd()}\n{code}`);
+    // Links
+    out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '[$1|$2]');
+    // Images
+    out = out.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '!$2!');
+    // Lists (same as JIRA)
+    out = out.replace(/^(\s*)[-+]\s+/gm, (_m, indent) => {
+        const level = Math.floor(indent.length / 2) + 1;
+        return '*'.repeat(level) + ' ';
+    });
+    out = out.replace(/^(\s*)\d+\.\s+/gm, (_m, indent) => {
+        const level = Math.floor(indent.length / 2) + 1;
+        return '#'.repeat(level) + ' ';
+    });
+    // Blockquote
+    out = out.replace(/^>\s+(.+)$/gm, '{quote}$1{quote}');
+    // Horizontal rules
+    out = out.replace(/^(-{3,}|\*{3,}|_{3,})$/gm, '----');
+    // Info/note panels from HTML comments
+    out = out.replace(/<!--\s*note:\s*([\s\S]*?)-->/gi, '{note}$1{note}');
+    out = out.replace(/<!--\s*info:\s*([\s\S]*?)-->/gi, '{info}$1{info}');
+    return out;
+}
+// ── AsciiDoc ─────────────────────────────────────────────────────────
+export function markdownToAsciiDoc(md) {
+    let out = md;
+    // Headers: # → =, ## → ==, etc.
+    out = out.replace(/^######\s+(.+)$/gm, '====== $1');
+    out = out.replace(/^#####\s+(.+)$/gm, '===== $1');
+    out = out.replace(/^####\s+(.+)$/gm, '==== $1');
+    out = out.replace(/^###\s+(.+)$/gm, '=== $1');
+    out = out.replace(/^##\s+(.+)$/gm, '== $1');
+    out = out.replace(/^#\s+(.+)$/gm, '= $1');
+    // Bold: **text** → *text*
+    out = out.replace(/\*\*([^*]+)\*\*/g, '*$1*');
+    // Italic: *text* → _text_
+    out = out.replace(/(?<!\*)\*(?!\*)([^*]+)(?<!\*)\*(?!\*)/g, '_$1_');
+    // Inline code stays as backtick (AsciiDoc uses + but backtick also works)
+    out = out.replace(/`([^`]+)`/g, '`$1`');
+    // Code blocks: ```lang → [source,lang]\n----\n...\n----
+    out = out.replace(/```(\w+)?\n([\s\S]*?)```/g, (_m, lang, code) => {
+        const attr = lang ? `[source,${lang}]\n` : '';
+        return `${attr}----\n${code.trimEnd()}\n----`;
+    });
+    // Links: [text](url) → url[text]
+    out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '$2[$1]');
+    // Images: ![alt](url) → image::url[alt]
+    out = out.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, 'image::$2[$1]');
+    // Blockquote: > text → [quote]\ntext\n
+    const lines = out.split('\n');
+    const result = [];
+    let inQuote = false;
+    for (const line of lines) {
+        if (line.startsWith('> ')) {
+            if (!inQuote) {
+                result.push('[quote]');
+                result.push('____');
+                inQuote = true;
+            }
+            result.push(line.slice(2));
+        }
+        else {
+            if (inQuote) {
+                result.push('____');
+                inQuote = false;
+            }
+            result.push(line);
+        }
+    }
+    if (inQuote)
+        result.push('____');
+    out = result.join('\n');
+    // Horizontal rules
+    out = out.replace(/^(-{3,}|\*{3,}|_{3,})$/gm, "'''");
+    // Unordered list marker stays as *
+    out = out.replace(/^(\s*)[-+]\s+/gm, '* ');
+    // Ordered list: 1. → .
+    out = out.replace(/^\d+\.\s+/gm, '. ');
+    return out;
+}
+// ── reStructuredText ─────────────────────────────────────────────────
+export function markdownToRST(md) {
+    let out = md;
+    // Code blocks: ```lang → .. code-block:: lang
+    out = out.replace(/```(\w+)?\n([\s\S]*?)```/g, (_m, lang, code) => {
+        const directive = lang ? `.. code-block:: ${lang}` : '.. code-block::';
+        const indented = code.split('\n').map((l) => '   ' + l).join('\n').trimEnd();
+        return `${directive}\n\n${indented}`;
+    });
+    // Bold: **text** → **text** (same in RST)
+    // Italic: *text* → *text* (same in RST)
+    // Inline code: `code` → ``code``
+    out = out.replace(/(?<!`)(`[^`]+`)(?!`)/g, '`$1`');
+    // Links: [text](url) → `text <url>`_
+    out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '`$1 <$2>`_');
+    // Images: ![alt](url) → .. image:: url\n   :alt: alt
+    out = out.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '.. image:: $2\n   :alt: $1');
+    // Headers: use underline characters
+    const lines = out.split('\n');
+    const result = [];
+    for (const line of lines) {
+        const h1 = line.match(/^#\s+(.+)$/);
+        const h2 = line.match(/^##\s+(.+)$/);
+        const h3 = line.match(/^###\s+(.+)$/);
+        const h4 = line.match(/^####\s+(.+)$/);
+        if (h1) {
+            result.push(h1[1], '='.repeat(h1[1].length));
+        }
+        else if (h2) {
+            result.push(h2[1], '-'.repeat(h2[1].length));
+        }
+        else if (h3) {
+            result.push(h3[1], '~'.repeat(h3[1].length));
+        }
+        else if (h4) {
+            result.push(h4[1], '^'.repeat(h4[1].length));
+        }
+        else {
+            result.push(line);
+        }
+    }
+    out = result.join('\n');
+    // Blockquote: > text → indented text
+    out = out.replace(/^>\s+(.+)$/gm, '   $1');
+    // Horizontal rules
+    out = out.replace(/^(-{3,}|\*{3,}|_{3,})$/gm, '----------');
+    // Ordered list: keep as-is (RST uses #.)
+    out = out.replace(/^(\d+)\.\s+/gm, '#. ');
+    return out;
+}
+// ── MediaWiki markup ─────────────────────────────────────────────────
+export function markdownToMediaWiki(md) {
+    let out = md;
+    // Headers: # text → == text ==
+    out = out.replace(/^######\s+(.+)$/gm, '======= $1 =======');
+    out = out.replace(/^#####\s+(.+)$/gm, '====== $1 ======');
+    out = out.replace(/^####\s+(.+)$/gm, '===== $1 =====');
+    out = out.replace(/^###\s+(.+)$/gm, '==== $1 ====');
+    out = out.replace(/^##\s+(.+)$/gm, '=== $1 ===');
+    out = out.replace(/^#\s+(.+)$/gm, '== $1 ==');
+    // Bold: **text** → '''text'''
+    out = out.replace(/\*\*([^*]+)\*\*/g, "'''$1'''");
+    // Italic: *text* → ''text''
+    out = out.replace(/(?<!\*)\*(?!\*)([^*]+)(?<!\*)\*(?!\*)/g, "''$1''");
+    // Inline code: `code` → <code>code</code>
+    out = out.replace(/`([^`]+)`/g, '<code>$1</code>');
+    // Code blocks
+    out = out.replace(/```(\w+)?\n([\s\S]*?)```/g, (_m, lang, code) => lang ? `<syntaxhighlight lang="${lang}">\n${code.trimEnd()}\n</syntaxhighlight>` :
+        `<pre>\n${code.trimEnd()}\n</pre>`);
+    // Links: [text](url) → [url text]
+    out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '[$2 $1]');
+    // Images: ![alt](url) → [[File:url|alt]]
+    out = out.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '[[File:$2|$1]]');
+    // Unordered list: - text → * text
+    out = out.replace(/^(\s*)[-+]\s+/gm, (_m, indent) => {
+        const level = Math.floor(indent.length / 2) + 1;
+        return '*'.repeat(level) + ' ';
+    });
+    // Ordered list
+    out = out.replace(/^(\s*)\d+\.\s+/gm, (_m, indent) => {
+        const level = Math.floor(indent.length / 2) + 1;
+        return '#'.repeat(level) + ' ';
+    });
+    // Blockquote
+    out = out.replace(/^>\s+(.+)$/gm, '<blockquote>$1</blockquote>');
+    // Horizontal rules
+    out = out.replace(/^(-{3,}|\*{3,}|_{3,})$/gm, '----');
+    // Tables
+    const lines = out.split('\n');
+    const result = [];
+    let inTable = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith('|') && line.endsWith('|')) {
+            if (/^\|[\s-:]+\|/.test(line))
+                continue; // skip separator
+            const cells = line.split('|').filter(c => c.trim()).map(c => c.trim());
+            if (!inTable) {
+                result.push('{| class="wikitable"');
+                inTable = true;
+                // First row as header
+                result.push('|-');
+                cells.forEach(c => result.push('! ' + c));
+            }
+            else {
+                result.push('|-');
+                cells.forEach(c => result.push('| ' + c));
+            }
+        }
+        else {
+            if (inTable) {
+                result.push('|}');
+                inTable = false;
+            }
+            result.push(lines[i]);
+        }
+    }
+    if (inTable)
+        result.push('|}');
+    return result.join('\n');
+}
+// ── BBCode ───────────────────────────────────────────────────────────
+export function markdownToBBCode(md) {
+    let out = md;
+    // Headers
+    out = out.replace(/^#{1,6}\s+(.+)$/gm, '[b][size=5]$1[/size][/b]');
+    // Bold
+    out = out.replace(/\*\*([^*]+)\*\*/g, '[b]$1[/b]');
+    // Italic
+    out = out.replace(/(?<!\*)\*(?!\*)([^*]+)(?<!\*)\*(?!\*)/g, '[i]$1[/i]');
+    // Strikethrough
+    out = out.replace(/~~([^~]+)~~/g, '[s]$1[/s]');
+    // Inline code
+    out = out.replace(/`([^`]+)`/g, '[code]$1[/code]');
+    // Code blocks
+    out = out.replace(/```(\w+)?\n([\s\S]*?)```/g, (_m, _lang, code) => `[code]\n${code.trimEnd()}\n[/code]`);
+    // Links
+    out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '[url=$2]$1[/url]');
+    // Images
+    out = out.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '[img]$2[/img]');
+    // Blockquote
+    out = out.replace(/^>\s+(.+)$/gm, '[quote]$1[/quote]');
+    // Unordered list
+    out = out.replace(/^[-*+]\s+(.+)$/gm, '[*]$1');
+    // Horizontal rules
+    out = out.replace(/^(-{3,}|\*{3,}|_{3,})$/gm, '[hr]');
+    return out;
+}
+// ── Textile ──────────────────────────────────────────────────────────
+export function markdownToTextile(md) {
+    let out = md;
+    // Headers: # → h1., ## → h2.
+    out = out.replace(/^######\s+(.+)$/gm, 'h6. $1');
+    out = out.replace(/^#####\s+(.+)$/gm, 'h5. $1');
+    out = out.replace(/^####\s+(.+)$/gm, 'h4. $1');
+    out = out.replace(/^###\s+(.+)$/gm, 'h3. $1');
+    out = out.replace(/^##\s+(.+)$/gm, 'h2. $1');
+    out = out.replace(/^#\s+(.+)$/gm, 'h1. $1');
+    // Bold: **text** → *text*
+    out = out.replace(/\*\*([^*]+)\*\*/g, '*$1*');
+    // Italic: *text* → _text_
+    out = out.replace(/(?<!\*)\*(?!\*)([^*]+)(?<!\*)\*(?!\*)/g, '_$1_');
+    // Strikethrough: ~~text~~ → -text-
+    out = out.replace(/~~([^~]+)~~/g, '-$1-');
+    // Inline code
+    out = out.replace(/`([^`]+)`/g, '@$1@');
+    // Code blocks
+    out = out.replace(/```(\w+)?\n([\s\S]*?)```/g, (_m, _lang, code) => `bc. ${code.trimEnd()}`);
+    // Links: [text](url) → "text":url
+    out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '"$1":$2');
+    // Images: ![alt](url) → !url(alt)!
+    out = out.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '!$2($1)!');
+    // Blockquote
+    out = out.replace(/^>\s+(.+)$/gm, 'bq. $1');
+    // Unordered list
+    out = out.replace(/^[-+]\s+/gm, '* ');
+    // Ordered list
+    out = out.replace(/^\d+\.\s+/gm, '# ');
+    // Horizontal rules
+    out = out.replace(/^(-{3,}|\*{3,}|_{3,})$/gm, '---');
+    return out;
+}
+// ── Org Mode ─────────────────────────────────────────────────────────
+export function markdownToOrgMode(md) {
+    let out = md;
+    // Headers: # → *, ## → **, etc.
+    out = out.replace(/^######\s+(.+)$/gm, '****** $1');
+    out = out.replace(/^#####\s+(.+)$/gm, '***** $1');
+    out = out.replace(/^####\s+(.+)$/gm, '**** $1');
+    out = out.replace(/^###\s+(.+)$/gm, '*** $1');
+    out = out.replace(/^##\s+(.+)$/gm, '** $1');
+    out = out.replace(/^#\s+(.+)$/gm, '* $1');
+    // Bold: **text** → *text*
+    out = out.replace(/\*\*([^*]+)\*\*/g, '*$1*');
+    // Italic: *text* → /text/
+    out = out.replace(/(?<!\*)\*(?!\*)([^*]+)(?<!\*)\*(?!\*)/g, '/$1/');
+    // Strikethrough: ~~text~~ → +text+
+    out = out.replace(/~~([^~]+)~~/g, '+$1+');
+    // Inline code: `code` → ~code~
+    out = out.replace(/`([^`]+)`/g, '~$1~');
+    // Code blocks: ```lang → #+BEGIN_SRC lang
+    out = out.replace(/```(\w+)?\n([\s\S]*?)```/g, (_m, lang, code) => lang ? `#+BEGIN_SRC ${lang}\n${code.trimEnd()}\n#+END_SRC` :
+        `#+BEGIN_SRC\n${code.trimEnd()}\n#+END_SRC`);
+    // Links: [text](url) → [[url][text]]
+    out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '[[$2][$1]]');
+    // Images: ![alt](url) → [[url]]
+    out = out.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '[[$2]]');
+    // Blockquote
+    out = out.replace(/^>\s+(.+)$/gm, '#+BEGIN_QUOTE\n$1\n#+END_QUOTE');
+    // Unordered list: - → -  (Org uses -)
+    // Ordered list stays similar
+    // Horizontal rules
+    out = out.replace(/^(-{3,}|\*{3,}|_{3,})$/gm, '-----');
+    // Task lists: - [ ] → - [ ], - [x] → - [X]
+    out = out.replace(/^- \[x\]/gm, '- [X]');
+    return out;
+}