@xjtlumedia/markdown-mcp-server 2.1.1 → 2.2.0

package/dist/email-html.js

@@ -7,6 +7,29 @@ import remarkGfm from 'remark-gfm';
 import remarkRehype from 'remark-rehype';
 import rehypeStringify from 'rehype-stringify';
 export async function markdownToEmailHtml(md) {
+    // Pre-process highlight syntax (==text==) → <mark> since remark-gfm doesn't handle it
+    let processed = md.replace(/==([^=]+)==/g, '<mark>$1</mark>');
+    // Pre-process footnotes: collect definitions, convert refs to superscript, append endnotes
+    const footnoteDefRegex = /^\[\^(\w+)\]:\s*(.+)$/gm;
+    const footnotes = [];
+    let fnMatch;
+    while ((fnMatch = footnoteDefRegex.exec(processed)) !== null) {
+        footnotes.push({ label: fnMatch[1], text: fnMatch[2] });
+    }
+    if (footnotes.length > 0) {
+        // Remove footnote definitions from body
+        processed = processed.replace(/^\[\^(\w+)\]:\s*(.+)$/gm, '');
+        // Replace footnote references with superscript numbers
+        for (let idx = 0; idx < footnotes.length; idx++) {
+            const label = footnotes[idx].label;
+            processed = processed.replace(new RegExp(`\\[\\^${label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\]`, 'g'), `<sup>[${idx + 1}]</sup>`);
+        }
+        // Append endnotes section
+        processed += '\n\n---\n\n';
+        for (let idx = 0; idx < footnotes.length; idx++) {
+            processed += `${idx + 1}. ${footnotes[idx].text}\n`;
+        }
+    }
     // First convert to basic HTML
     const htmlFile = await unified()
         .use(remarkParse)
@@ -15,7 +38,7 @@ export async function markdownToEmailHtml(md) {
         .use(remarkRehype)
         // @ts-ignore
         .use(rehypeStringify)
-        .process(md);
+        .process(processed);
     let html = String(htmlFile);
     // Inline all styles for email client compatibility
     html = inlineEmailStyles(html);
@@ -90,5 +113,16 @@ function inlineEmailStyles(html) {
     // Strong and em (just ensure they work)
     out = out.replace(/<strong([^>]*)>/gi, '<strong$1 style="font-weight:bold;">');
     out = out.replace(/<em([^>]*)>/gi, '<em$1 style="font-style:italic;">');
+    // Strikethrough
+    out = out.replace(/<del([^>]*)>/gi, '<del$1 style="text-decoration:line-through;color:#999999;">');
+    // Highlight / mark
+    out = out.replace(/<mark([^>]*)>/gi, '<mark$1 style="background-color:#fff3cd;padding:1px 4px;border-radius:2px;">');
+    // Superscript and subscript
+    out = out.replace(/<sup([^>]*)>/gi, '<sup$1 style="font-size:75%;line-height:0;position:relative;vertical-align:baseline;top:-0.5em;">');
+    out = out.replace(/<sub([^>]*)>/gi, '<sub$1 style="font-size:75%;line-height:0;position:relative;vertical-align:baseline;bottom:-0.25em;">');
+    // Task list checkboxes
+    out = out.replace(/<input[^>]*checked[^>]*disabled[^>]*\/?>/gi, '&#9745; ');
+    out = out.replace(/<input[^>]*disabled[^>]*checked[^>]*\/?>/gi, '&#9745; ');
+    out = out.replace(/<input[^>]*type="checkbox"[^>]*\/?>/gi, '&#9744; ');
     return out;
 }

package/dist/html-import.js

@@ -44,6 +44,15 @@ export function htmlToMarkdown(html) {
     md = md.replace(/<(em|i)[^>]*>([\s\S]*?)<\/\1>/gi, '*$2*');
     // Strikethrough
     md = md.replace(/<(del|s|strike)[^>]*>([\s\S]*?)<\/\1>/gi, '~~$2~~');
+    // Highlight / mark
+    md = md.replace(/<mark[^>]*>([\s\S]*?)<\/mark>/gi, '==$1==');
+    // Keyboard
+    md = md.replace(/<kbd[^>]*>([\s\S]*?)<\/kbd>/gi, '`$1`');
+    // Superscript / subscript
+    md = md.replace(/<sup[^>]*>([\s\S]*?)<\/sup>/gi, '^$1^');
+    md = md.replace(/<sub[^>]*>([\s\S]*?)<\/sub>/gi, '~$1~');
+    // Abbreviations — just keep the text
+    md = md.replace(/<abbr[^>]*>([\s\S]*?)<\/abbr>/gi, '$1');
     // Code
     md = md.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, '`$1`');
     // Links
@@ -52,6 +61,40 @@ export function htmlToMarkdown(html) {
     md = md.replace(/<img[^>]*src="([^"]*)"[^>]*alt="([^"]*)"[^>]*\/?>/gi, '![$2]($1)');
     md = md.replace(/<img[^>]*alt="([^"]*)"[^>]*src="([^"]*)"[^>]*\/?>/gi, '![$1]($2)');
     md = md.replace(/<img[^>]*src="([^"]*)"[^>]*\/?>/gi, '![]($1)');
+    // Definition lists
+    md = md.replace(/<dl[^>]*>([\s\S]*?)<\/dl>/gi, (_m, content) => {
+        let result = '\n';
+        const dtRegex = /<dt[^>]*>([\s\S]*?)<\/dt>/gi;
+        const ddRegex = /<dd[^>]*>([\s\S]*?)<\/dd>/gi;
+        let dtMatch;
+        const dts = [];
+        const dds = [];
+        while ((dtMatch = dtRegex.exec(content)) !== null)
+            dts.push(dtMatch[1].replace(/<[^>]+>/g, '').trim());
+        let ddMatch;
+        while ((ddMatch = ddRegex.exec(content)) !== null)
+            dds.push(ddMatch[1].replace(/<[^>]+>/g, '').trim());
+        for (let i = 0; i < Math.max(dts.length, dds.length); i++) {
+            if (i < dts.length)
+                result += `${dts[i]}\n`;
+            if (i < dds.length)
+                result += `: ${dds[i]}\n`;
+        }
+        return result + '\n';
+    });
+    // Details/summary → blockquote with bold summary
+    md = md.replace(/<details[^>]*>\s*<summary[^>]*>([\s\S]*?)<\/summary>([\s\S]*?)<\/details>/gi, (_m, summary, content) => `\n> **${summary.replace(/<[^>]+>/g, '').trim()}**\n> ${content.replace(/<[^>]+>/g, '').trim()}\n`);
+    // Figure/figcaption
+    md = md.replace(/<figure[^>]*>([\s\S]*?)<\/figure>/gi, (_m, content) => {
+        const imgMatch = content.match(/<img[^>]*src="([^"]*)"[^>]*\/?>/i);
+        const captionMatch = content.match(/<figcaption[^>]*>([\s\S]*?)<\/figcaption>/i);
+        const src = imgMatch ? imgMatch[1] : '';
+        const caption = captionMatch ? captionMatch[1].replace(/<[^>]+>/g, '').trim() : '';
+        return src ? `\n![${caption}](${src})\n` : '';
+    });
+    // Task list checkboxes inside list items (already converted to - items)
+    md = md.replace(/- <input[^>]*checked[^>]*\/?>\s*/gi, '- [x] ');
+    md = md.replace(/- <input[^>]*type="checkbox"[^>]*\/?>\s*/gi, '- [ ] ');
     // Remove remaining HTML tags
     md = md.replace(/<[^>]+>/g, '');
     // Decode HTML entities

package/dist/index.js

@@ -1143,10 +1143,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             return handleOutput(latex, outputPath);
         }
         if (name === "convert_to_docx") {
-            const elements = parseMarkdownToDocx(markdown);
-            const doc = new ((await import("docx")).Document)({
+            const { elements, footnotes } = parseMarkdownToDocx(markdown);
+            const docOptions = {
                 sections: [{ children: elements }]
-            });
+            };
+            if (Object.keys(footnotes).length > 0) {
+                docOptions.footnotes = footnotes;
+            }
+            const doc = new ((await import("docx")).Document)(docOptions);
             const buffer = await Packer.toBuffer(doc);
             return handleOutput(buffer, outputPath, {
                 format: 'docx',

package/dist/markdown-repair.js

@@ -8,6 +8,7 @@ export function repairMarkdown(md) {
     out = repairHeadings(out);
     out = repairListIndentation(out);
     out = repairBrokenLinks(out);
+    out = repairBrokenTaskLists(out);
     out = normalizeWhitespace(out);
     return out;
 }
@@ -165,6 +166,17 @@ export function repairBrokenLinks(md) {
     out = out.replace(/\[([^\]]+)\(([^)]+)\)/g, '[$1]($2)');
     return out;
 }
+// Fix broken task list syntax from LLM output
+export function repairBrokenTaskLists(md) {
+    let out = md;
+    // Fix missing space in checkbox: - [] → - [ ]
+    out = out.replace(/^(\s*[-*+])\s+\[\](\s+)/gm, '$1 [ ]$2');
+    // Fix uppercase X: - [X] → - [x]
+    out = out.replace(/^(\s*[-*+]\s+)\[X\]/gm, '$1[x]');
+    // Fix no space after checkbox: - [x]text → - [x] text
+    out = out.replace(/^(\s*[-*+]\s+\[[ xX]\])([^\s])/gm, '$1 $2');
+    return out;
+}
 // Normalize excessive whitespace
 export function normalizeWhitespace(md) {
     let out = md;
@@ -250,6 +262,14 @@ export function lintMarkdown(md) {
                 fixable: true
             });
         }
+        // Broken task list syntax
+        if (/^\s*[-*+]\s+\[\]/.test(line)) {
+            issues.push({
+                line: lineNum, column: 1, severity: 'warning',
+                rule: 'broken-task-list', message: 'Missing space in task list checkbox: [] should be [ ]',
+                fixable: true
+            });
+        }
     }
     // Check for unclosed code fences
     if (inCodeBlock) {

package/dist/platform-converters.js

@@ -1,6 +1,35 @@
+// ── Shared pre-processing helpers ────────────────────────────────────
+function collectFootnotes(text) {
+    const footnoteMap = {};
+    const cleaned = text.replace(/^\[\^(\w+)\]:\s*(.+)$/gm, (_m, label, content) => {
+        footnoteMap[label] = content;
+        return '';
+    });
+    return { cleaned, footnoteMap };
+}
+function appendEndnotes(text, footnoteMap, formatRef = (n) => `[${n}]`, separator = '\n\n---\n') {
+    const labels = Object.keys(footnoteMap);
+    if (labels.length === 0)
+        return text;
+    let out = text;
+    // Replace refs with formatted numbers
+    for (let i = 0; i < labels.length; i++) {
+        const escaped = labels[i].replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        out = out.replace(new RegExp(`\\[\\^${escaped}\\]`, 'g'), formatRef(i + 1));
+    }
+    // Append endnotes section
+    out += separator;
+    for (let i = 0; i < labels.length; i++) {
+        out += `\n${i + 1}. ${footnoteMap[labels[i]]}`;
+    }
+    return out;
+}
 // ── Slack mrkdwn ─────────────────────────────────────────────────────
 export function markdownToSlack(md) {
-    let out = md;
+    const { cleaned, footnoteMap } = collectFootnotes(md);
+    let out = cleaned;
+    // Highlight: ==text== → *text* (bold as closest Slack approximation)
+    out = out.replace(/==([^=]+)==/g, '*$1*');
     // Bold: **text** → *text*
     out = out.replace(/\*\*([^*]+)\*\*/g, '*$1*');
     // Italic: *text* or _text_ → _text_
@@ -15,32 +44,43 @@ export function markdownToSlack(md) {
     out = out.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '<$2|$1>');
     // Headers: # text → *text*
     out = out.replace(/^#{1,6}\s+(.+)$/gm, '*$1*');
+    // Task lists
+    out = out.replace(/^\s*[-*+]\s+\[x\]\s+(.+)$/gim, '☑ $1');
+    out = out.replace(/^\s*[-*+]\s+\[ \]\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;
+    return appendEndnotes(out, footnoteMap);
 }
 // ── Discord markdown ─────────────────────────────────────────────────
 export function markdownToDiscord(md) {
-    let out = md;
+    const { cleaned, footnoteMap } = collectFootnotes(md);
+    let out = cleaned;
+    // Highlight: ==text== → **text** (bold as closest Discord approximation)
+    out = out.replace(/==([^=]+)==/g, '**$1**');
     // 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
+    // Task lists
+    out = out.replace(/^\s*[-*+]\s+\[x\]\s+(.+)$/gim, '- ☑ $1');
+    out = out.replace(/^\s*[-*+]\s+\[ \]\s+(.+)$/gm, '- ☐ $1');
     // 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;
+    return appendEndnotes(out, footnoteMap);
 }
 // ── JIRA wiki markup ─────────────────────────────────────────────────
 export function markdownToJira(md) {
-    let out = md;
+    const { cleaned, footnoteMap } = collectFootnotes(md);
+    let out = cleaned;
+    // Highlight: ==text== → {color:yellow}text{color}
+    out = out.replace(/==([^=]+)==/g, '{color:yellow}$1{color}');
     // Headers: # → h1., ## → h2., etc.
     out = out.replace(/^######\s+(.+)$/gm, 'h6. $1');
     out = out.replace(/^#####\s+(.+)$/gm, 'h5. $1');
@@ -72,6 +112,15 @@ export function markdownToJira(md) {
         const level = Math.floor(indent.length / 2) + 1;
         return '#'.repeat(level) + ' ';
     });
+    // Task lists
+    out = out.replace(/^(\s*)[-*+]\s+\[x\]\s+/gim, (_m, indent) => {
+        const level = Math.floor(indent.length / 2) + 1;
+        return '*'.repeat(level) + ' (/) ';
+    });
+    out = out.replace(/^(\s*)[-*+]\s+\[ \]\s+/gm, (_m, indent) => {
+        const level = Math.floor(indent.length / 2) + 1;
+        return '*'.repeat(level) + ' (x) ';
+    });
     // Blockquote: > text → {quote}text{quote}
     out = out.replace(/^>\s+(.+)$/gm, '{quote}$1{quote}');
     // Horizontal rules
@@ -101,11 +150,14 @@ export function markdownToJira(md) {
             result.push(line);
         }
     }
-    return result.join('\n');
+    return appendEndnotes(result.join('\n'), footnoteMap, (n) => `^[${n}]^`, '\n\n----\n');
 }
 // ── Confluence wiki markup ───────────────────────────────────────────
 export function markdownToConfluence(md) {
-    let out = md;
+    const { cleaned, footnoteMap } = collectFootnotes(md);
+    let out = cleaned;
+    // Highlight: ==text== → {color:yellow}text{color}
+    out = out.replace(/==([^=]+)==/g, '{color:yellow}$1{color}');
     // Headers
     out = out.replace(/^######\s+(.+)$/gm, 'h6. $1');
     out = out.replace(/^#####\s+(.+)$/gm, 'h5. $1');
@@ -138,14 +190,31 @@ export function markdownToConfluence(md) {
     out = out.replace(/^>\s+(.+)$/gm, '{quote}$1{quote}');
     // Horizontal rules
     out = out.replace(/^(-{3,}|\*{3,}|_{3,})$/gm, '----');
+    // Task lists
+    out = out.replace(/^(\s*)[-*+]\s+\[x\]\s+/gim, (_m, indent) => {
+        const level = Math.floor(indent.length / 2) + 1;
+        return '*'.repeat(level) + ' (/) ';
+    });
+    out = out.replace(/^(\s*)[-*+]\s+\[ \]\s+/gm, (_m, indent) => {
+        const level = Math.floor(indent.length / 2) + 1;
+        return '*'.repeat(level) + ' (x) ';
+    });
     // 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;
+    return appendEndnotes(out, footnoteMap, (n) => `^[${n}]^`, '\n\n----\n');
 }
 // ── AsciiDoc ─────────────────────────────────────────────────────────
 export function markdownToAsciiDoc(md) {
-    let out = md;
+    const { cleaned, footnoteMap } = collectFootnotes(md);
+    let out = cleaned;
+    // Highlight: ==text== → [.mark]#text#
+    out = out.replace(/==([^=]+)==/g, '[.mark]#$1#');
+    // Footnote refs → native AsciiDoc inline footnotes
+    for (const [label, text] of Object.entries(footnoteMap)) {
+        const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        out = out.replace(new RegExp(`\\[\\^${escaped}\\]`, 'g'), `footnote:[${text}]`);
+    }
     // Headers: # → =, ## → ==, etc.
     out = out.replace(/^######\s+(.+)$/gm, '====== $1');
     out = out.replace(/^#####\s+(.+)$/gm, '===== $1');
@@ -194,15 +263,58 @@ export function markdownToAsciiDoc(md) {
     out = result.join('\n');
     // Horizontal rules
     out = out.replace(/^(-{3,}|\*{3,}|_{3,})$/gm, "'''");
+    // Task lists
+    out = out.replace(/^(\s*)[-*+]\s+\[x\]\s+/gim, '* [*] ');
+    out = out.replace(/^(\s*)[-*+]\s+\[ \]\s+/gm, '* [ ] ');
     // Unordered list marker stays as *
     out = out.replace(/^(\s*)[-+]\s+/gm, '* ');
     // Ordered list: 1. → .
     out = out.replace(/^\d+\.\s+/gm, '. ');
+    // Tables
+    out = convertMarkdownTableToAsciiDoc(out);
     return out;
 }
+function convertMarkdownTableToAsciiDoc(text) {
+    const lines = text.split('\n');
+    const result = [];
+    let inTable = false;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('|') && trimmed.endsWith('|')) {
+            if (/^\|[\s-:]+\|/.test(trimmed))
+                continue;
+            const cells = trimmed.split('|').filter(c => c.trim()).map(c => c.trim());
+            if (!inTable) {
+                result.push(`[cols="${cells.map(() => '1').join(',')}",options="header"]`);
+                result.push('|===');
+                inTable = true;
+            }
+            result.push(cells.map(c => '| ' + c).join(' '));
+        }
+        else {
+            if (inTable) {
+                result.push('|===');
+                inTable = false;
+            }
+            result.push(line);
+        }
+    }
+    if (inTable)
+        result.push('|===');
+    return result.join('\n');
+}
 // ── reStructuredText ─────────────────────────────────────────────────
 export function markdownToRST(md) {
-    let out = md;
+    const { cleaned, footnoteMap } = collectFootnotes(md);
+    let out = cleaned;
+    // Highlight: ==text== → **text** (RST has no native highlight)
+    out = out.replace(/==([^=]+)==/g, '**$1**');
+    // Footnote refs → RST native footnotes [#label]_
+    const fnLabels = Object.keys(footnoteMap);
+    for (const label of fnLabels) {
+        const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        out = out.replace(new RegExp(`\\[\\^${escaped}\\]`, 'g'), ` [#fn_${label}]_`);
+    }
     // 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::';
@@ -248,11 +360,78 @@ export function markdownToRST(md) {
     out = out.replace(/^(-{3,}|\*{3,}|_{3,})$/gm, '----------');
     // Ordered list: keep as-is (RST uses #.)
     out = out.replace(/^(\d+)\.\s+/gm, '#. ');
+    // Task lists
+    out = out.replace(/^-\s+\[x\]\s+/gim, '- ☑ ');
+    out = out.replace(/^-\s+\[ \]\s+/gm, '- ☐ ');
+    // Tables
+    out = convertMarkdownTableToRST(out);
+    // Append RST footnote definitions
+    if (fnLabels.length > 0) {
+        out += '\n\n';
+        for (const label of fnLabels) {
+            out += `.. [#fn_${label}] ${footnoteMap[label]}\n`;
+        }
+    }
     return out;
 }
+function convertMarkdownTableToRST(text) {
+    const lines = text.split('\n');
+    const result = [];
+    const tableRows = [];
+    let isCollecting = false;
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith('|') && trimmed.endsWith('|')) {
+            if (/^\|[\s-:]+\|/.test(trimmed))
+                continue;
+            const cells = trimmed.split('|').filter(c => c.trim()).map(c => c.trim());
+            tableRows.push(cells);
+            isCollecting = true;
+        }
+        else {
+            if (isCollecting && tableRows.length > 0) {
+                result.push(...renderRSTTable(tableRows));
+                tableRows.length = 0;
+                isCollecting = false;
+            }
+            result.push(lines[i]);
+        }
+    }
+    if (tableRows.length > 0)
+        result.push(...renderRSTTable(tableRows));
+    return result.join('\n');
+}
+function renderRSTTable(rows) {
+    if (rows.length === 0)
+        return [];
+    const colCount = Math.max(...rows.map(r => r.length));
+    const colWidths = Array(colCount).fill(3);
+    for (const row of rows) {
+        for (let j = 0; j < row.length; j++) {
+            colWidths[j] = Math.max(colWidths[j], (row[j] || '').length + 2);
+        }
+    }
+    const sep = '+' + colWidths.map(w => '-'.repeat(w)).join('+') + '+';
+    const headSep = '+' + colWidths.map(w => '='.repeat(w)).join('+') + '+';
+    const result = [sep];
+    for (let i = 0; i < rows.length; i++) {
+        const line = '|' + colWidths.map((w, j) => (' ' + (rows[i][j] || '') + ' ').padEnd(w)).join('|') + '|';
+        result.push(line);
+        result.push(i === 0 ? headSep : sep);
+    }
+    return result;
+}
 // ── MediaWiki markup ─────────────────────────────────────────────────
 export function markdownToMediaWiki(md) {
-    let out = md;
+    const { cleaned, footnoteMap } = collectFootnotes(md);
+    let out = cleaned;
+    // Highlight: ==text== → <mark>text</mark>
+    out = out.replace(/==([^=]+)==/g, '<mark>$1</mark>');
+    // Footnote refs → MediaWiki native <ref>text</ref>
+    for (const [label, text] of Object.entries(footnoteMap)) {
+        const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        out = out.replace(new RegExp(`\\[\\^${escaped}\\]`, 'g'), `<ref>${text}</ref>`);
+    }
     // Headers: # text → == text ==
     out = out.replace(/^######\s+(.+)$/gm, '======= $1 =======');
     out = out.replace(/^#####\s+(.+)$/gm, '====== $1 ======');
@@ -319,11 +498,19 @@ export function markdownToMediaWiki(md) {
     }
     if (inTable)
         result.push('|}');
-    return result.join('\n');
+    let mwOut = result.join('\n');
+    // Append <references/> if there were footnotes
+    if (Object.keys(footnoteMap).length > 0) {
+        mwOut += '\n\n== References ==\n<references/>';
+    }
+    return mwOut;
 }
 // ── BBCode ───────────────────────────────────────────────────────────
 export function markdownToBBCode(md) {
-    let out = md;
+    const { cleaned, footnoteMap } = collectFootnotes(md);
+    let out = cleaned;
+    // Highlight: ==text== → [color=yellow]text[/color]
+    out = out.replace(/==([^=]+)==/g, '[color=yellow]$1[/color]');
     // Headers
     out = out.replace(/^#{1,6}\s+(.+)$/gm, '[b][size=5]$1[/size][/b]');
     // Bold
@@ -342,15 +529,66 @@ export function markdownToBBCode(md) {
     out = out.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '[img]$2[/img]');
     // Blockquote
     out = out.replace(/^>\s+(.+)$/gm, '[quote]$1[/quote]');
+    // Task lists
+    out = out.replace(/^[-*+]\s+\[x\]\s+(.+)$/gim, '[*]☑ $1');
+    out = out.replace(/^[-*+]\s+\[ \]\s+(.+)$/gm, '[*]☐ $1');
     // Unordered list
     out = out.replace(/^[-*+]\s+(.+)$/gm, '[*]$1');
+    // Tables
+    out = convertMarkdownTableToBBCode(out);
     // Horizontal rules
     out = out.replace(/^(-{3,}|\*{3,}|_{3,})$/gm, '[hr]');
-    return out;
+    return appendEndnotes(out, footnoteMap, (n) => `[sup][${n}][/sup]`, '\n\n[hr]\n');
+}
+function convertMarkdownTableToBBCode(text) {
+    const lines = text.split('\n');
+    const result = [];
+    let inTable = false;
+    let isHeader = true;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('|') && trimmed.endsWith('|')) {
+            if (/^\|[\s-:]+\|/.test(trimmed)) {
+                isHeader = false;
+                continue;
+            }
+            const cells = trimmed.split('|').filter(c => c.trim()).map(c => c.trim());
+            if (!inTable) {
+                result.push('[table]');
+                inTable = true;
+            }
+            if (isHeader) {
+                result.push('[tr]' + cells.map(c => `[th]${c}[/th]`).join('') + '[/tr]');
+            }
+            else {
+                result.push('[tr]' + cells.map(c => `[td]${c}[/td]`).join('') + '[/tr]');
+            }
+        }
+        else {
+            if (inTable) {
+                result.push('[/table]');
+                inTable = false;
+                isHeader = true;
+            }
+            result.push(line);
+        }
+    }
+    if (inTable)
+        result.push('[/table]');
+    return result.join('\n');
 }
 // ── Textile ──────────────────────────────────────────────────────────
 export function markdownToTextile(md) {
-    let out = md;
+    const { cleaned, footnoteMap } = collectFootnotes(md);
+    let out = cleaned;
+    // Highlight: ==text== → %{background:yellow}text%
+    out = out.replace(/==([^=]+)==/g, '%{background:yellow}$1%');
+    // Footnote refs → Textile native [N]
+    const fnLabels = Object.keys(footnoteMap);
+    for (let i = 0; i < fnLabels.length; i++) {
+        const escaped = fnLabels[i].replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        out = out.replace(new RegExp(`\\[\\^${escaped}\\]`, 'g'), `[${i + 1}]`);
+    }
     // Headers: # → h1., ## → h2.
     out = out.replace(/^######\s+(.+)$/gm, 'h6. $1');
     out = out.replace(/^#####\s+(.+)$/gm, 'h5. $1');
@@ -374,17 +612,63 @@ export function markdownToTextile(md) {
     out = out.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '!$2($1)!');
     // Blockquote
     out = out.replace(/^>\s+(.+)$/gm, 'bq. $1');
+    // Task lists
+    out = out.replace(/^[-*+]\s+\[x\]\s+/gim, '* ☑ ');
+    out = out.replace(/^[-*+]\s+\[ \]\s+/gm, '* ☐ ');
     // Unordered list
     out = out.replace(/^[-+]\s+/gm, '* ');
     // Ordered list
     out = out.replace(/^\d+\.\s+/gm, '# ');
+    // Tables
+    out = convertMarkdownTableToTextile(out);
     // Horizontal rules
     out = out.replace(/^(-{3,}|\*{3,}|_{3,})$/gm, '---');
+    // Append Textile footnote definitions
+    if (fnLabels.length > 0) {
+        out += '\n\n';
+        for (let i = 0; i < fnLabels.length; i++) {
+            out += `fn${i + 1}. ${footnoteMap[fnLabels[i]]}\n`;
+        }
+    }
     return out;
 }
+function convertMarkdownTableToTextile(text) {
+    const lines = text.split('\n');
+    const result = [];
+    let isHeader = true;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('|') && trimmed.endsWith('|')) {
+            if (/^\|[\s-:]+\|/.test(trimmed)) {
+                isHeader = false;
+                continue;
+            }
+            const cells = trimmed.split('|').filter(c => c.trim()).map(c => c.trim());
+            if (isHeader) {
+                result.push('|_. ' + cells.join(' |_. ') + ' |');
+            }
+            else {
+                result.push('| ' + cells.join(' | ') + ' |');
+            }
+        }
+        else {
+            isHeader = true;
+            result.push(line);
+        }
+    }
+    return result.join('\n');
+}
 // ── Org Mode ─────────────────────────────────────────────────────────
 export function markdownToOrgMode(md) {
-    let out = md;
+    const { cleaned, footnoteMap } = collectFootnotes(md);
+    let out = cleaned;
+    // Highlight: ==text== → *text* (Org has no native highlight, use bold)
+    out = out.replace(/==([^=]+)==/g, '*$1*');
+    // Footnote refs → Org Mode native [fn:label]
+    for (const [label, text] of Object.entries(footnoteMap)) {
+        const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        out = out.replace(new RegExp(`\\[\\^${escaped}\\]`, 'g'), `[fn:${label}]`);
+    }
     // Headers: # → *, ## → **, etc.
     out = out.replace(/^######\s+(.+)$/gm, '****** $1');
     out = out.replace(/^#####\s+(.+)$/gm, '***** $1');
@@ -409,11 +693,43 @@ export function markdownToOrgMode(md) {
     out = out.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '[[$2]]');
     // Blockquote
     out = out.replace(/^>\s+(.+)$/gm, '#+BEGIN_QUOTE\n$1\n#+END_QUOTE');
+    // Task lists: - [ ] → - [ ], - [x] → - [X]
+    out = out.replace(/^- \[x\]/gm, '- [X]');
     // Unordered list: - → -  (Org uses -)
     // Ordered list stays similar
+    // Tables
+    out = convertMarkdownTableToOrg(out);
     // Horizontal rules
     out = out.replace(/^(-{3,}|\*{3,}|_{3,})$/gm, '-----');
-    // Task lists: - [ ] → - [ ], - [x] → - [X]
-    out = out.replace(/^- \[x\]/gm, '- [X]');
+    // Append Org Mode footnote definitions
+    if (Object.keys(footnoteMap).length > 0) {
+        out += '\n\n';
+        for (const [label, text] of Object.entries(footnoteMap)) {
+            out += `[fn:${label}] ${text}\n`;
+        }
+    }
     return out;
 }
+function convertMarkdownTableToOrg(text) {
+    const lines = text.split('\n');
+    const result = [];
+    let isFirstRow = true;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('|') && trimmed.endsWith('|')) {
+            if (/^\|[\s-:]+\|/.test(trimmed)) {
+                // Convert separator to org separator
+                const cells = trimmed.split('|').filter(c => c.trim());
+                result.push('|' + cells.map(c => '-'.repeat(c.trim().length + 2)).join('+') + '|');
+                isFirstRow = false;
+                continue;
+            }
+            result.push(trimmed);
+        }
+        else {
+            isFirstRow = true;
+            result.push(line);
+        }
+    }
+    return result.join('\n');
+}