@xjtlumedia/markdown-mcp-server 2.1.1 → 2.2.0

package/dist/core-exports.js

@@ -1,4 +1,4 @@
-import { Paragraph, TextRun, HeadingLevel, Table, TableRow, TableCell, WidthType, BorderStyle, AlignmentType } from 'docx';
+import { Paragraph, TextRun, HeadingLevel, Table, TableRow, TableCell, WidthType, BorderStyle, AlignmentType, ExternalHyperlink, FootnoteReferenceRun } from 'docx';
 import * as XLSX from 'xlsx';
 // ... (previous code)
 /**
@@ -92,13 +92,16 @@ export function stripMarkdown(text) {
     // 4. Block Level: Blockquotes & ATX Headings
     clean = clean.replace(/^[\s\t]*>+\s?/gm, '');
     clean = clean.replace(/^#{1,6}\s+/gm, '');
-    // 5. Inline: Multi-pass Emphasis (Bold, Italic, Strikethrough)
+    // 5. Inline: Multi-pass Emphasis (Bold, Italic, Strikethrough, Highlight)
     for (let i = 0; i < 3; i++) {
         clean = clean.replace(/[*_]{3}([^*_]+)[*_]{3}/g, '$1');
         clean = clean.replace(/[*_]{2}([^*_]+)[*_]{2}/g, '$1');
         clean = clean.replace(/[*_]{1}([^*_]+)[*_]{1}/g, '$1');
         clean = clean.replace(/~~([^~]+)~~/g, '$1');
+        clean = clean.replace(/==([^=]+)==/g, '$1');
     }
+    // 5b. Block Level: Footnote definitions
+    clean = clean.replace(/^\[\^[^\]]+\]:\s+.*$/gm, '');
     // 6. Inline: Math, Links, Images, and Extended Syntax
     clean = clean.replace(/\$\$(.*?)\$\$/gs, '$1');
     clean = clean.replace(/\$(.*?)\$/g, '$1');
@@ -145,31 +148,254 @@ export function parseMarkdownTable(tableText) {
 export function cleanMarkdownText(text) {
     return stripMarkdown(text);
 }
+/**
+ * Escape LaTeX special characters in text (not in commands)
+ */
+function escapeLatex(text) {
+    return text
+        .replace(/\\/g, '\\textbackslash{}')
+        .replace(/([&%$#_{}])/g, '\\$1')
+        .replace(/~/g, '\\textasciitilde{}')
+        .replace(/\^/g, '\\textasciicircum{}');
+}
+/**
+ * Collect footnote definitions from markdown content.
+ * Returns a map of label → text and the content with definitions removed.
+ */
+function collectFootnoteDefinitions(content) {
+    const footnoteMap = {};
+    const cleaned = content.replace(/^\[\^([^\]]+)\]:\s+(.+)$/gm, (_m, label, text) => {
+        footnoteMap[label] = text;
+        return '';
+    });
+    return { footnoteMap, cleaned };
+}
+/**
+ * Convert inline markdown to LaTeX (with optional footnote resolution)
+ */
+function convertInlineLatex(text, footnoteMap = {}) {
+    let out = text;
+    // Extract math blocks first to protect them from escaping
+    const mathBlocks = [];
+    out = out.replace(/\$\$(.*?)\$\$/gs, (_m, math) => {
+        mathBlocks.push(`\\[${math}\\]`);
+        return `%%MATH${mathBlocks.length - 1}%%`;
+    });
+    out = out.replace(/\$(.*?)\$/g, (_m, math) => {
+        mathBlocks.push(`$${math}$`);
+        return `%%MATH${mathBlocks.length - 1}%%`;
+    });
+    // Inline code → \texttt{}
+    out = out.replace(/`([^`]+)`/g, (_m, code) => `\\texttt{${escapeLatex(code)}}`);
+    // Bold+Italic
+    out = out.replace(/\*\*\*([^*]+)\*\*\*/g, '\\textbf{\\textit{$1}}');
+    out = out.replace(/___([^_]+)___/g, '\\textbf{\\textit{$1}}');
+    // Bold
+    out = out.replace(/\*\*([^*]+)\*\*/g, '\\textbf{$1}');
+    out = out.replace(/__([^_]+)__/g, '\\textbf{$1}');
+    // Italic
+    out = out.replace(/\*([^*]+)\*/g, '\\textit{$1}');
+    out = out.replace(/_([^_]+)_/g, '\\textit{$1}');
+    // Strikethrough
+    out = out.replace(/~~([^~]+)~~/g, '\\sout{$1}');
+    // Highlight
+    out = out.replace(/==([^=]+)==/g, '\\hl{$1}');
+    // Raw HTML inline tags
+    out = out.replace(/<sup>([^<]+)<\/sup>/gi, '\\textsuperscript{$1}');
+    out = out.replace(/<sub>([^<]+)<\/sub>/gi, '\\textsubscript{$1}');
+    out = out.replace(/<mark>([^<]+)<\/mark>/gi, '\\hl{$1}');
+    out = out.replace(/<kbd>([^<]+)<\/kbd>/gi, '\\texttt{$1}');
+    // Links: [text](url)
+    out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '\\href{$2}{$1}');
+    // Images: ![alt](url)
+    out = out.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '\\includegraphics[width=\\linewidth]{$2}');
+    // Footnote references: [^label] → \footnote{text} if definition exists, else superscript label
+    out = out.replace(/\[\^([^\]]+)\]/g, (_m, label) => {
+        const fnText = footnoteMap[label];
+        return fnText ? `\\footnote{${fnText}}` : `\\textsuperscript{${label}}`;
+    });
+    // Escape remaining special chars that aren't part of LaTeX commands
+    out = out.replace(/(?<!\\)&/g, '\\&');
+    out = out.replace(/(?<!\\)%/g, '\\%');
+    out = out.replace(/(?<!\\)#/g, '\\#');
+    // Restore math blocks
+    for (let idx = 0; idx < mathBlocks.length; idx++) {
+        out = out.replace(`%%MATH${idx}%%`, mathBlocks[idx]);
+    }
+    return out;
+}
+/**
+ * Convert markdown table to LaTeX tabular
+ */
+function convertTableToLatex(tableLines, footnoteMap = {}) {
+    const rows = tableLines.filter(l => !/^\|[\s-:]+\|/.test(l.trim()));
+    if (rows.length === 0)
+        return '';
+    const firstRow = rows[0].split('|').slice(1, -1).map(c => c.trim());
+    const cols = firstRow.length;
+    const colSpec = firstRow.map(() => 'l').join(' | ');
+    let latex = `\\begin{tabular}{| ${colSpec} |}\n\\hline\n`;
+    for (let r = 0; r < rows.length; r++) {
+        const cells = rows[r].split('|').slice(1, -1).map(c => convertInlineLatex(c.trim(), footnoteMap));
+        while (cells.length < cols)
+            cells.push('');
+        latex += cells.join(' & ') + ' \\\\\n\\hline\n';
+    }
+    latex += `\\end{tabular}`;
+    return latex;
+}
 /**
  * Parse markdown content to LaTeX
  */
 export function parseMarkdownToLaTeX(content) {
-    let processed = content
-        .replace(/^# (.*)$/gm, '\\section{$1}')
-        .replace(/^## (.*)$/gm, '\\subsection{$1}')
-        .replace(/^### (.*)$/gm, '\\subsubsection{$1}')
-        .replace(/\*\*(.*)\*\*/g, '\\textbf{$1}')
-        .replace(/\*(.*)\*/g, '\\textit{$1}')
-        .replace(/\$\$(.*?)\$\$/gs, '\\begin{equation}\n$1\n\\end{equation}')
-        .replace(/\$(.*?)\$/g, '$ $1 $')
-        .replace(/^-\s(.*)$/gm, '\\begin{itemize}\n\\item $1\n\\end{itemize}')
-        .replace(/\\end{itemize}\n\\begin{itemize}/g, '');
-    // Escape LaTeX special chars but try not to break our commands
-    processed = processed.replace(/([_%$&~^\\{}])/g, (m) => m === '\\' ? m : `\\${m}`);
-    // Final pass to remove any markdown-only artifacts (hashes, backticks, pipe)
-    return processed.replace(/[*#`|]/g, '');
+    // Pre-process: collect footnote definitions and strip them
+    const { footnoteMap, cleaned } = collectFootnoteDefinitions(content);
+    const lines = cleaned.split('\n');
+    const result = [];
+    let i = 0;
+    let inCodeBlock = false;
+    let codeBlockContent = [];
+    let inItemize = false;
+    let inEnumerate = false;
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Code blocks
+        if (trimmed.startsWith('```')) {
+            if (inCodeBlock) {
+                result.push(`\\begin{verbatim}`);
+                result.push(codeBlockContent.join('\n'));
+                result.push(`\\end{verbatim}`);
+                codeBlockContent = [];
+                inCodeBlock = false;
+            }
+            else {
+                inCodeBlock = true;
+            }
+            i++;
+            continue;
+        }
+        if (inCodeBlock) {
+            codeBlockContent.push(line);
+            i++;
+            continue;
+        }
+        // Blank line — close open list environments
+        if (!trimmed) {
+            if (inItemize) {
+                result.push('\\end{itemize}');
+                inItemize = false;
+            }
+            if (inEnumerate) {
+                result.push('\\end{enumerate}');
+                inEnumerate = false;
+            }
+            result.push('');
+            i++;
+            continue;
+        }
+        // Horizontal rules
+        if (/^(\*\*\*|---|__{3,})\s*$/.test(trimmed)) {
+            result.push('\\begin{center}\\rule{0.5\\linewidth}{0.5pt}\\end{center}');
+            i++;
+            continue;
+        }
+        // Headings
+        if (trimmed.startsWith('###### ')) {
+            result.push(`\\textbf{${convertInlineLatex(trimmed.slice(7), footnoteMap)}}\\\\`);
+        }
+        else if (trimmed.startsWith('##### ')) {
+            result.push(`\\subparagraph{${convertInlineLatex(trimmed.slice(6), footnoteMap)}}`);
+        }
+        else if (trimmed.startsWith('#### ')) {
+            result.push(`\\paragraph{${convertInlineLatex(trimmed.slice(5), footnoteMap)}}`);
+        }
+        else if (trimmed.startsWith('### ')) {
+            result.push(`\\subsubsection{${convertInlineLatex(trimmed.slice(4), footnoteMap)}}`);
+        }
+        else if (trimmed.startsWith('## ')) {
+            result.push(`\\subsection{${convertInlineLatex(trimmed.slice(3), footnoteMap)}}`);
+        }
+        else if (trimmed.startsWith('# ')) {
+            result.push(`\\section{${convertInlineLatex(trimmed.slice(2), footnoteMap)}}`);
+        }
+        // Blockquotes
+        else if (trimmed.startsWith('>')) {
+            const text = trimmed.replace(/^>+\s*/, '');
+            result.push(`\\begin{quote}`);
+            result.push(convertInlineLatex(text, footnoteMap));
+            result.push(`\\end{quote}`);
+        }
+        // Task lists
+        else if (/^\s*[-*+]\s+\[[ xX]\]\s+/.test(line)) {
+            if (!inItemize) {
+                result.push('\\begin{itemize}');
+                inItemize = true;
+            }
+            const checked = /\[x\]/i.test(line);
+            const text = line.replace(/^\s*[-*+]\s+\[[ xX]\]\s+/, '');
+            result.push(`\\item[${checked ? '$\\boxtimes$' : '$\\square$'}] ${convertInlineLatex(text, footnoteMap)}`);
+        }
+        // Unordered lists
+        else if (/^\s*[-*+]\s+/.test(line)) {
+            if (!inItemize) {
+                result.push('\\begin{itemize}');
+                inItemize = true;
+            }
+            const text = line.replace(/^\s*[-*+]\s+/, '');
+            result.push(`\\item ${convertInlineLatex(text, footnoteMap)}`);
+        }
+        // Ordered lists
+        else if (/^\s*\d+\.\s+/.test(line)) {
+            if (!inEnumerate) {
+                result.push('\\begin{enumerate}');
+                inEnumerate = true;
+            }
+            const text = line.replace(/^\s*\d+\.\s+/, '');
+            result.push(`\\item ${convertInlineLatex(text, footnoteMap)}`);
+        }
+        // Tables
+        else if (trimmed.startsWith('|') && trimmed.endsWith('|')) {
+            const tableLines = [];
+            while (i < lines.length && lines[i].trim().startsWith('|')) {
+                tableLines.push(lines[i]);
+                i++;
+            }
+            result.push(convertTableToLatex(tableLines, footnoteMap));
+            continue;
+        }
+        // Regular paragraph
+        else {
+            if (inItemize) {
+                result.push('\\end{itemize}');
+                inItemize = false;
+            }
+            if (inEnumerate) {
+                result.push('\\end{enumerate}');
+                inEnumerate = false;
+            }
+            result.push(convertInlineLatex(trimmed, footnoteMap));
+        }
+        i++;
+    }
+    // Close any open environments
+    if (inItemize)
+        result.push('\\end{itemize}');
+    if (inEnumerate)
+        result.push('\\end{enumerate}');
+    if (inCodeBlock) {
+        result.push('\\begin{verbatim}');
+        result.push(codeBlockContent.join('\n'));
+        result.push('\\end{verbatim}');
+    }
+    return result.join('\n');
 }
 /**
  * Parse text with inline formatting to TextRuns
  */
-export function parseInlineFormatting(text) {
+export function parseInlineFormatting(text, footnoteIdMap) {
     const runs = [];
-    const regex = /(\$\$.*?\$\$|\$.*?\$|\*\*\*[^*]+\*\*\*|\*\*[^*]+\*\*|\*[^*]+\*|___[^_]+___|__[^_]+__|_[^_]+_|`[^`]+`|<br\s*\/?>)/g;
+    const regex = /(\$\$.*?\$\$|\$.*?\$|\*\*\*[^*]+\*\*\*|\*\*[^*]+\*\*|\*[^*]+\*|___[^_]+___|__[^_]+__|_[^_]+_|~~[^~]+~~|==[^=]+=+|`[^`]+`|!\[[^\]]*\]\([^)]+\)|\[[^\]]+\]\([^)]+\)|\[\^[^\]]+\]|<sup>[^<]+<\/sup>|<sub>[^<]+<\/sub>|<mark>[^<]+<\/mark>|<kbd>[^<]+<\/kbd>|<br\s*\/?>)/gi;
     const parts = text.split(regex);
     for (const part of parts) {
         if (!part)
@@ -192,6 +418,12 @@ export function parseInlineFormatting(text) {
         else if (part.startsWith('__') && part.endsWith('__')) {
             runs.push(new TextRun({ text: part.slice(2, -2), bold: true }));
         }
+        else if (part.startsWith('~~') && part.endsWith('~~')) {
+            runs.push(new TextRun({ text: part.slice(2, -2), strike: true }));
+        }
+        else if (part.startsWith('==') && part.endsWith('==')) {
+            runs.push(new TextRun({ text: part.slice(2, -2), highlight: 'yellow' }));
+        }
         else if (part.startsWith('*') && part.endsWith('*')) {
             runs.push(new TextRun({ text: part.slice(1, -1), italics: true }));
         }
@@ -201,6 +433,46 @@ export function parseInlineFormatting(text) {
         else if (part.startsWith('`') && part.endsWith('`')) {
             runs.push(new TextRun({ text: part.slice(1, -1), font: 'Consolas', shading: { fill: 'F0F0F0' } }));
         }
+        else if (/^<sup>/i.test(part)) {
+            const m = part.match(/<sup>([^<]+)<\/sup>/i);
+            if (m)
+                runs.push(new TextRun({ text: m[1], superScript: true }));
+        }
+        else if (/^<sub>/i.test(part)) {
+            const m = part.match(/<sub>([^<]+)<\/sub>/i);
+            if (m)
+                runs.push(new TextRun({ text: m[1], subScript: true }));
+        }
+        else if (/^<mark>/i.test(part)) {
+            const m = part.match(/<mark>([^<]+)<\/mark>/i);
+            if (m)
+                runs.push(new TextRun({ text: m[1], highlight: 'yellow' }));
+        }
+        else if (/^<kbd>/i.test(part)) {
+            const m = part.match(/<kbd>([^<]+)<\/kbd>/i);
+            if (m)
+                runs.push(new TextRun({ text: m[1], font: 'Consolas', shading: { fill: 'E5E7EB' } }));
+        }
+        else if (/^\[\^/.test(part)) {
+            const m = part.match(/^\[\^([^\]]+)\]$/);
+            if (m && footnoteIdMap && footnoteIdMap[m[1]] !== undefined) {
+                runs.push(new FootnoteReferenceRun(footnoteIdMap[m[1]]));
+            }
+            else if (m) {
+                runs.push(new TextRun({ text: m[1], superScript: true }));
+            }
+        }
+        else if (/^!\[/.test(part)) {
+            const m = part.match(/^!\[([^\]]*)\]\(([^)]+)\)/);
+            if (m)
+                runs.push(new TextRun({ text: m[1] ? `[Image: ${m[1]}]` : '[Image]', italics: true, color: '6B7280' }));
+        }
+        else if (/^\[/.test(part)) {
+            const m = part.match(/^\[([^\]]+)\]\(([^)]+)\)/);
+            if (m) {
+                runs.push(new ExternalHyperlink({ children: [new TextRun({ text: m[1], color: '2563EB', underline: { type: 'single' } })], link: m[2] }));
+            }
+        }
         else if (part.match(/<br\s*\/?>/i)) {
             runs.push(new TextRun({ text: '', break: 1 }));
         }
@@ -213,7 +485,7 @@ export function parseInlineFormatting(text) {
 /**
  * Create a Word table from parsed markdown table data
  */
-export function createDocxTable(headers, rows) {
+export function createDocxTable(headers, rows, footnoteIdMap) {
     const allRows = [];
     if (headers.length > 0) {
         allRows.push(new TableRow({
@@ -225,7 +497,7 @@ export function createDocxTable(headers, rows) {
     }
     for (const row of rows) {
         allRows.push(new TableRow({
-            children: row.map(cell => new TableCell({ children: [new Paragraph({ children: parseInlineFormatting(cell) })] }))
+            children: row.map(cell => new TableCell({ children: [new Paragraph({ children: parseInlineFormatting(cell, footnoteIdMap) })] }))
         }));
     }
     return new Table({
@@ -242,11 +514,24 @@ export function createDocxTable(headers, rows) {
     });
 }
 /**
- * Parse markdown content to docx elements
+ * Parse markdown content to docx elements with footnote support
  */
 export function parseMarkdownToDocx(content) {
+    // Pre-process: collect footnote definitions
+    const { footnoteMap, cleaned } = collectFootnoteDefinitions(content);
+    // Assign numeric IDs to footnotes (docx requires numeric IDs starting from 1)
+    const footnoteIdMap = {};
+    const docxFootnotes = {};
+    let fnId = 1;
+    for (const label of Object.keys(footnoteMap)) {
+        footnoteIdMap[label] = fnId;
+        docxFootnotes[fnId] = {
+            children: [new Paragraph({ children: [new TextRun({ text: footnoteMap[label] })] })]
+        };
+        fnId++;
+    }
     const elements = [];
-    const lines = content.split('\n');
+    const lines = cleaned.split('\n');
     let i = 0;
     let inCodeBlock = false;
     let codeBlockContent = [];
@@ -278,12 +563,12 @@ export function parseMarkdownToDocx(content) {
         if (i + 1 < lines.length) {
             const nextLine = lines[i + 1].trim();
             if (/^={3,}\s*$/.test(nextLine)) {
-                elements.push(new Paragraph({ heading: HeadingLevel.HEADING_1, children: parseInlineFormatting(trimmed), spacing: { before: 400, after: 200 } }));
+                elements.push(new Paragraph({ heading: HeadingLevel.HEADING_1, children: parseInlineFormatting(trimmed, footnoteIdMap), spacing: { before: 400, after: 200 } }));
                 i += 2;
                 continue;
             }
             else if (/^-{3,}\s*$/.test(nextLine)) {
-                elements.push(new Paragraph({ heading: HeadingLevel.HEADING_2, children: parseInlineFormatting(trimmed), spacing: { before: 300, after: 150 } }));
+                elements.push(new Paragraph({ heading: HeadingLevel.HEADING_2, children: parseInlineFormatting(trimmed, footnoteIdMap), spacing: { before: 300, after: 150 } }));
                 i += 2;
                 continue;
             }
@@ -297,7 +582,7 @@ export function parseMarkdownToDocx(content) {
             if (tableLines.length >= 2) {
                 const { headers, rows } = parseMarkdownTable(tableLines.join('\n'));
                 if (headers.length > 0) {
-                    elements.push(createDocxTable(headers, rows));
+                    elements.push(createDocxTable(headers, rows, footnoteIdMap));
                     elements.push(new Paragraph({ spacing: { after: 200 } }));
                 }
             }
@@ -308,17 +593,42 @@ export function parseMarkdownToDocx(content) {
             i++;
             continue;
         }
+        // Skip blank lines from footnote def removal
+        if (/^\[\^[^\]]+\]:\s+/.test(trimmed)) {
+            i++;
+            continue;
+        }
         if (trimmed.startsWith('# ')) {
-            elements.push(new Paragraph({ heading: HeadingLevel.HEADING_1, children: parseInlineFormatting(trimmed.slice(2)), spacing: { before: 400, after: 200 } }));
+            elements.push(new Paragraph({ heading: HeadingLevel.HEADING_1, children: parseInlineFormatting(trimmed.slice(2), footnoteIdMap), spacing: { before: 400, after: 200 } }));
         }
         else if (trimmed.startsWith('## ')) {
-            elements.push(new Paragraph({ heading: HeadingLevel.HEADING_2, children: parseInlineFormatting(trimmed.slice(3)), spacing: { before: 300, after: 150 } }));
+            elements.push(new Paragraph({ heading: HeadingLevel.HEADING_2, children: parseInlineFormatting(trimmed.slice(3), footnoteIdMap), spacing: { before: 300, after: 150 } }));
         }
         else if (trimmed.startsWith('### ')) {
-            elements.push(new Paragraph({ heading: HeadingLevel.HEADING_3, children: parseInlineFormatting(trimmed.slice(4)), spacing: { before: 250, after: 100 } }));
+            elements.push(new Paragraph({ heading: HeadingLevel.HEADING_3, children: parseInlineFormatting(trimmed.slice(4), footnoteIdMap), spacing: { before: 250, after: 100 } }));
         }
         else if (trimmed.startsWith('#### ')) {
-            elements.push(new Paragraph({ heading: HeadingLevel.HEADING_4, children: parseInlineFormatting(trimmed.slice(5)), spacing: { before: 200, after: 100 } }));
+            elements.push(new Paragraph({ heading: HeadingLevel.HEADING_4, children: parseInlineFormatting(trimmed.slice(5), footnoteIdMap), spacing: { before: 200, after: 100 } }));
+        }
+        else if (trimmed.startsWith('##### ')) {
+            elements.push(new Paragraph({ heading: HeadingLevel.HEADING_5, children: parseInlineFormatting(trimmed.slice(6), footnoteIdMap), spacing: { before: 200, after: 80 } }));
+        }
+        else if (trimmed.startsWith('###### ')) {
+            elements.push(new Paragraph({ heading: HeadingLevel.HEADING_6, children: parseInlineFormatting(trimmed.slice(7), footnoteIdMap), spacing: { before: 150, after: 80 } }));
+        }
+        else if (/^\s*[-*+]\s+\[[ xX]\]\s+/.test(line)) {
+            const checked = /\[[xX]\]/.test(line);
+            const text = line.replace(/^\s*[-*+]\s+\[[ xX]\]\s+/, '');
+            const match = line.match(/^(\s*)/);
+            const indent = match ? Math.floor(match[1].length / 4) : 0;
+            elements.push(new Paragraph({
+                indent: { left: (indent + 1) * 360 },
+                children: [
+                    new TextRun({ text: checked ? '☑ ' : '☐ ', font: 'Segoe UI Symbol' }),
+                    ...parseInlineFormatting(text, footnoteIdMap)
+                ],
+                spacing: { after: 80 }
+            }));
         }
         else if (trimmed.startsWith('>')) {
             const level = (trimmed.match(/^>+/g) || ['>'])[0].length;
@@ -329,23 +639,23 @@ export function parseMarkdownToDocx(content) {
             const match = line.match(/^(\s*)([-*+]\s+)/);
             const indent = match ? Math.floor(match[1].length / 4) : 0;
             const text = line.replace(/^\s*[-*+]\s+/, '');
-            elements.push(new Paragraph({ bullet: { level: indent }, children: parseInlineFormatting(text), spacing: { after: 80 } }));
+            elements.push(new Paragraph({ bullet: { level: indent }, children: parseInlineFormatting(text, footnoteIdMap), spacing: { after: 80 } }));
         }
         else if (/^(\s*)\d+\.\s+/.test(line)) {
             const match = line.match(/^(\s*)(\d+\.\s+)/);
             const indent = match ? Math.floor(match[1].length / 4) : 0;
             const text = line.replace(/^\s*\d+\.\s+/, '');
-            elements.push(new Paragraph({ numbering: { reference: 'default-numbering', level: indent }, children: parseInlineFormatting(text), spacing: { after: 80 } }));
+            elements.push(new Paragraph({ numbering: { reference: 'default-numbering', level: indent }, children: parseInlineFormatting(text, footnoteIdMap), spacing: { after: 80 } }));
         }
         else {
-            const paragraphChildren = parseInlineFormatting(trimmed);
+            const paragraphChildren = parseInlineFormatting(trimmed, footnoteIdMap);
             if (line.endsWith('  '))
                 paragraphChildren.push(new TextRun({ text: '', break: 1 }));
             elements.push(new Paragraph({ children: paragraphChildren, spacing: { after: 150 } }));
         }
         i++;
     }
-    return elements;
+    return { elements, footnotes: docxFootnotes };
 }
 /**
  * RTF Helper: Encode string with Unicode support and RTF escaping
@@ -369,8 +679,8 @@ export function encodeRTFText(str) {
 /**
  * RTF Helper: Parse inline markdown to RTF codes
  */
-export function parseInlineToRTF(text) {
-    const regex = /(\$\$.*?\$\$|\$.*?\$|\*\*\*[^*]+\*\*\*|\*\*[^*]+\*\*|\*[^*]+\*|___[^_]+___|__[^_]+__|_[^_]+_|`[^`]+`|<br\s*\/?>)/g;
+export function parseInlineToRTF(text, footnoteMap) {
+    const regex = /(\$\$.*?\$\$|\$.*?\$|\*\*\*[^*]+\*\*\*|\*\*[^*]+\*\*|\*[^*]+\*|___[^_]+___|__[^_]+__|_[^_]+_|~~[^~]+~~|==[^=]+=+|`[^`]+`|!\[[^\]]*\]\([^)]+\)|\[[^\]]+\]\([^)]+\)|\[\^[^\]]+\]|<sup>[^<]+<\/sup>|<sub>[^<]+<\/sub>|<mark>[^<]+<\/mark>|<kbd>[^<]+<\/kbd>|<br\s*\/?>)/gi;
     const parts = text.split(regex);
     let result = "";
     for (const part of parts) {
@@ -394,6 +704,12 @@ export function parseInlineToRTF(text) {
         else if (part.startsWith('__') && part.endsWith('__')) {
             result += `{\\b ${encodeRTFText(part.slice(2, -2))}}`;
         }
+        else if (part.startsWith('~~') && part.endsWith('~~')) {
+            result += `{\\strike ${encodeRTFText(part.slice(2, -2))}}`;
+        }
+        else if (part.startsWith('==') && part.endsWith('==')) {
+            result += `{\\highlight7 ${encodeRTFText(part.slice(2, -2))}}`;
+        }
         else if (part.startsWith('*') && part.endsWith('*')) {
             result += `{\\i ${encodeRTFText(part.slice(1, -1))}}`;
         }
@@ -403,6 +719,45 @@ export function parseInlineToRTF(text) {
         else if (part.startsWith('`') && part.endsWith('`')) {
             result += `{\\f1\\highlight3 ${encodeRTFText(part.slice(1, -1))}}`;
         }
+        else if (/^<sup>/i.test(part)) {
+            const m = part.match(/<sup>([^<]+)<\/sup>/i);
+            if (m)
+                result += `{\\super ${encodeRTFText(m[1])}}`;
+        }
+        else if (/^<sub>/i.test(part)) {
+            const m = part.match(/<sub>([^<]+)<\/sub>/i);
+            if (m)
+                result += `{\\sub ${encodeRTFText(m[1])}}`;
+        }
+        else if (/^<mark>/i.test(part)) {
+            const m = part.match(/<mark>([^<]+)<\/mark>/i);
+            if (m)
+                result += `{\\highlight7 ${encodeRTFText(m[1])}}`;
+        }
+        else if (/^<kbd>/i.test(part)) {
+            const m = part.match(/<kbd>([^<]+)<\/kbd>/i);
+            if (m)
+                result += `{\\f1\\highlight3 ${encodeRTFText(m[1])}}`;
+        }
+        else if (/^\[\^/.test(part)) {
+            const m = part.match(/^\[\^([^\]]+)\]$/);
+            if (m && footnoteMap && footnoteMap[m[1]]) {
+                result += `{\\super ${encodeRTFText(m[1])}}{\\*\\footnote\\pard\\plain\\s99\\f0\\fs20 {\\super ${encodeRTFText(m[1])}} ${encodeRTFText(footnoteMap[m[1]])}}`;
+            }
+            else if (m) {
+                result += `{\\super ${encodeRTFText(m[1])}}`;
+            }
+        }
+        else if (/^!\[/.test(part)) {
+            const m = part.match(/^!\[([^\]]*)\]\(([^)]+)\)/);
+            if (m)
+                result += `{\\i\\cf2 [Image: ${encodeRTFText(m[1] || 'image')}]}`;
+        }
+        else if (/^\[/.test(part)) {
+            const m = part.match(/^\[([^\]]+)\]\(([^)]+)\)/);
+            if (m)
+                result += `{\\field{\\*\\fldinst HYPERLINK "${m[2]}"}{\\fldrslt\\ul\\cf1 ${encodeRTFText(m[1])}}}`;
+        }
         else if (part.match(/<br\s*\/?>/i)) {
             result += "\\line ";
         }
@@ -416,7 +771,9 @@ export function parseInlineToRTF(text) {
  * RTF Helper: Main parser for Markdown to RTF conversion
  */
 export function parseMarkdownToRTF(content) {
-    const lines = content.split('\n');
+    // Pre-process: collect footnote definitions
+    const { footnoteMap, cleaned } = collectFootnoteDefinitions(content);
+    const lines = cleaned.split('\n');
     let rtf = "";
     let i = 0;
     let inCodeBlock = false;
@@ -452,12 +809,12 @@ export function parseMarkdownToRTF(content) {
         if (i + 1 < lines.length) {
             const nextLine = lines[i + 1].trim();
             if (/^={3,}\s*$/.test(nextLine)) {
-                rtf += "{\\pard\\b\\fs40\\sb400\\sa200 " + parseInlineToRTF(trimmed) + "\\par}\n";
+                rtf += "{\\pard\\b\\fs40\\sb400\\sa200 " + parseInlineToRTF(trimmed, footnoteMap) + "\\par}\n";
                 i += 2;
                 continue;
             }
             else if (/^-{3,}\s*$/.test(nextLine)) {
-                rtf += "{\\pard\\b\\fs32\\sb300\\sa150 " + parseInlineToRTF(trimmed) + "\\par}\n";
+                rtf += "{\\pard\\b\\fs32\\sb300\\sa150 " + parseInlineToRTF(trimmed, footnoteMap) + "\\par}\n";
                 i += 2;
                 continue;
             }
@@ -480,7 +837,7 @@ export function parseMarkdownToRTF(content) {
                     }
                     rtf += "\\pard\\intbl\\ql ";
                     for (const h of headers) {
-                        rtf += "{\\b " + parseInlineToRTF(h) + "}\\cell ";
+                        rtf += "{\\b " + parseInlineToRTF(h, footnoteMap) + "}\\cell ";
                     }
                     rtf += "\\row\n";
                     // Data Rows
@@ -491,7 +848,7 @@ export function parseMarkdownToRTF(content) {
                         }
                         rtf += "\\pard\\intbl\\ql ";
                         for (const cell of row) {
-                            rtf += parseInlineToRTF(cell) + "\\cell ";
+                            rtf += parseInlineToRTF(cell, footnoteMap) + "\\cell ";
                         }
                         rtf += "\\row\n";
                     }
@@ -507,37 +864,50 @@ export function parseMarkdownToRTF(content) {
         }
         // Headings
         if (trimmed.startsWith('# ')) {
-            rtf += "{\\pard\\b\\fs40\\sb400\\sa200 " + parseInlineToRTF(trimmed.slice(2)) + "\\par}\n";
+            rtf += "{\\pard\\b\\fs40\\sb400\\sa200 " + parseInlineToRTF(trimmed.slice(2), footnoteMap) + "\\par}\n";
         }
         else if (trimmed.startsWith('## ')) {
-            rtf += "{\\pard\\b\\fs32\\sb300\\sa150 " + parseInlineToRTF(trimmed.slice(3)) + "\\par}\n";
+            rtf += "{\\pard\\b\\fs32\\sb300\\sa150 " + parseInlineToRTF(trimmed.slice(3), footnoteMap) + "\\par}\n";
         }
         else if (trimmed.startsWith('### ')) {
-            rtf += "{\\pard\\b\\fs28\\sb250\\sa100 " + parseInlineToRTF(trimmed.slice(4)) + "\\par}\n";
+            rtf += "{\\pard\\b\\fs28\\sb250\\sa100 " + parseInlineToRTF(trimmed.slice(4), footnoteMap) + "\\par}\n";
         }
         else if (trimmed.startsWith('#### ')) {
-            rtf += "{\\pard\\b\\fs26\\sb200\\sa100 " + parseInlineToRTF(trimmed.slice(5)) + "\\par}\n";
+            rtf += "{\\pard\\b\\fs26\\sb200\\sa100 " + parseInlineToRTF(trimmed.slice(5), footnoteMap) + "\\par}\n";
+        }
+        else if (trimmed.startsWith('##### ')) {
+            rtf += "{\\pard\\b\\fs24\\sb200\\sa80 " + parseInlineToRTF(trimmed.slice(6), footnoteMap) + "\\par}\n";
+        }
+        else if (trimmed.startsWith('###### ')) {
+            rtf += "{\\pard\\b\\fs22\\sb150\\sa80 " + parseInlineToRTF(trimmed.slice(7), footnoteMap) + "\\par}\n";
+        }
+        else if (/^\s*[-*+]\s+\[[ xX]\]\s+/.test(line)) {
+            const checked = /\[[xX]\]/.test(line);
+            const text = line.replace(/^\s*[-*+]\s+\[[ xX]\]\s+/, '');
+            const match = line.match(/^(\s*)/);
+            const indent = match ? Math.floor(match[1].length / 4) : 0;
+            rtf += `{\\pard\\li${(indent + 1) * 360}\\fi-360 ${checked ? '\\u9745?' : '\\u9744?'}\\tab ` + parseInlineToRTF(text, footnoteMap) + "\\par}\n";
         }
         else if (trimmed.startsWith('>')) {
             const level = (trimmed.match(/^>+/g) || ['>'])[0].length;
             const text = trimmed.replace(/^>+\s*/, '');
-            rtf += `{\\pard\\li${level * 720}\\cf2\\i\\sa100 ` + parseInlineToRTF(text) + "\\par}\n";
+            rtf += `{\\pard\\li${level * 720}\\cf2\\i\\sa100 ` + parseInlineToRTF(text, footnoteMap) + "\\par}\n";
         }
         else if (/^(\s*)[-*+]\s+/.test(line)) {
             const match = line.match(/^(\s*)([-*+]\s+)/);
             const indent = match ? Math.floor(match[1].length / 4) : 0;
             const text = line.replace(/^\s*[-*+]\s+/, '');
-            rtf += `{\\pard\\li${(indent + 1) * 360}\\fi-360\\'b7\\tab ` + parseInlineToRTF(text) + "\\par}\n";
+            rtf += `{\\pard\\li${(indent + 1) * 360}\\fi-360\\'b7\\tab ` + parseInlineToRTF(text, footnoteMap) + "\\par}\n";
         }
         else if (/^(\s*)\d+\.\s+/.test(line)) {
             const match = line.match(/^(\s*)(\d+\.\s+)/);
             const indent = match ? Math.floor(match[1].length / 4) : 0;
             const number = match ? match[2] : "1. ";
             const text = line.replace(/^\s*\d+\.\s+/, '');
-            rtf += `{\\pard\\li${(indent + 1) * 360}\\fi-360 ${number}\\tab ` + parseInlineToRTF(text) + "\\par}\n";
+            rtf += `{\\pard\\li${(indent + 1) * 360}\\fi-360 ${number}\\tab ` + parseInlineToRTF(text, footnoteMap) + "\\par}\n";
         }
         else {
-            rtf += "{\\pard\\sa150 " + parseInlineToRTF(trimmed) + "\\par}\n";
+            rtf += "{\\pard\\sa150 " + parseInlineToRTF(trimmed, footnoteMap) + "\\par}\n";
         }
         i++;
     }