formatferry 0.1.4 → 1.0.0

package/dist/src/shared/conversion-engine.js

@@ -0,0 +1,790 @@
+import TurndownService from 'turndown';
+import { sanitizeHTML } from '../shared/input-sanitizer';
+export class ConversionEngine {
+    githubService;
+    commonmarkService;
+    customService;
+    discordService;
+    redditService;
+    rmarkdownService;
+    constructor() {
+        this.initializeServices();
+    }
+    initializeServices() {
+        // GitHub Flavored Markdown configuration
+        this.githubService = new TurndownService({
+            headingStyle: 'atx',
+            hr: '---',
+            bulletListMarker: '-',
+            codeBlockStyle: 'fenced',
+            emDelimiter: '_',
+        });
+        // CommonMark configuration (more strict)
+        this.commonmarkService = new TurndownService({
+            headingStyle: 'atx',
+            hr: '***',
+            bulletListMarker: '*',
+            codeBlockStyle: 'indented',
+            emDelimiter: '*',
+        });
+        // Custom service (starts as GitHub, can be modified)
+        this.customService = new TurndownService({
+            headingStyle: 'atx',
+            hr: '---',
+            bulletListMarker: '-',
+            codeBlockStyle: 'fenced',
+            emDelimiter: '_',
+        });
+        // Add enhanced Google Docs formatting detection to all services
+        this.addGoogleDocsRules(this.githubService);
+        this.addGoogleDocsRules(this.commonmarkService);
+        this.addGoogleDocsRules(this.customService);
+        // Add table preservation rules
+        this.addTableRules(this.githubService);
+        this.addTableRules(this.commonmarkService);
+        this.addTableRules(this.customService);
+        // Add enhanced list rules
+        this.addListRules(this.githubService);
+        this.addListRules(this.commonmarkService);
+        this.addListRules(this.customService);
+        // Add PDF page marker rules (Req 3.5)
+        this.addPdfPageMarkerRules(this.githubService);
+        this.addPdfPageMarkerRules(this.commonmarkService);
+        this.addPdfPageMarkerRules(this.customService);
+        // Initialize platform-specific services
+        this.discordService = this.createDiscordService();
+        this.redditService = this.createRedditService();
+        this.rmarkdownService = this.createRMarkdownService();
+    }
+    /**
+     * Create Discord-optimized Turndown service
+     * - Underline support (__text__)
+     * - Heading limit (H1-H3 only)
+     * - Tables converted to code blocks
+     * - Images converted to links
+     */
+    createDiscordService() {
+        const service = new TurndownService({
+            headingStyle: 'atx',
+            hr: '---',
+            bulletListMarker: '-',
+            codeBlockStyle: 'fenced',
+            emDelimiter: '*',
+        });
+        // Apply shared rules
+        this.addGoogleDocsRules(service);
+        this.addListRules(service);
+        this.addPdfPageMarkerRules(service);
+        // Discord-specific: Underline support
+        service.addRule('discordUnderline', {
+            filter: ['u', 'ins'],
+            replacement: (content) => content.trim() ? `__${content}__` : content
+        });
+        // Discord-specific: Limit headings to H3
+        service.addRule('discordHeadingLimit', {
+            filter: ['h4', 'h5', 'h6'],
+            replacement: (content) => `### ${content.trim()}\n\n`
+        });
+        // Discord-specific: Tables to code blocks
+        service.addRule('discordTable', {
+            filter: 'table',
+            replacement: (_content, node) => {
+                const plainText = this.tableToPlainText(node);
+                return `\`\`\`\n${plainText}\n\`\`\`\n\n`;
+            }
+        });
+        // Discord-specific: Images to links
+        service.addRule('discordImage', {
+            filter: 'img',
+            replacement: (_content, node) => {
+                const element = node;
+                const src = element.getAttribute('src') || '';
+                const alt = element.getAttribute('alt') || 'image';
+                return `[${alt}](${src})`;
+            }
+        });
+        // Discord-specific: Task list checkboxes to emoji (HTML input)
+        service.addRule('discordTaskList', {
+            filter: (node) => {
+                return node.nodeName === 'INPUT' &&
+                    node.type === 'checkbox';
+            },
+            replacement: (_content, node) => {
+                const checked = node.checked;
+                return checked ? '☑ ' : '☐ ';
+            }
+        });
+        return service;
+    }
+    /**
+     * Apply format-specific post-processing for Unicode characters
+     * Handles checkboxes, superscript, and subscript Unicode characters
+     */
+    applyFormatPostProcessing(markdown, format) {
+        switch (format) {
+            case 'github':
+                return this.normalizeGitHubCheckboxes(markdown);
+            case 'discord':
+                return this.normalizeDiscordCheckboxes(markdown);
+            case 'reddit':
+                return this.normalizeRedditUnicode(markdown);
+            case 'rmarkdown':
+                return this.normalizeRMarkdownUnicode(markdown);
+            default:
+                return markdown;
+        }
+    }
+    /**
+     * Normalize checkbox patterns for GitHub task list syntax
+     * Converts Unicode checkboxes to [x] and [ ]
+     */
+    normalizeGitHubCheckboxes(markdown) {
+        let result = markdown;
+        // Convert checked Unicode checkboxes to [x]
+        result = result.replace(/^([-*]\s+)[☑✓✔■⬛]/gm, '$1[x]');
+        // Convert unchecked Unicode checkboxes to [ ]
+        result = result.replace(/^([-*]\s+)[☐✗✘□⬜]/gm, '$1[ ]');
+        return result;
+    }
+    /**
+     * Normalize checkbox patterns in markdown output for Discord
+     * Converts [x], [ ], and other checkbox patterns to emoji
+     */
+    normalizeDiscordCheckboxes(markdown) {
+        // Normalize checked checkbox patterns to ☑
+        let result = markdown.replace(/^([-*]\s+)\[x\]/gmi, '$1☑');
+        result = result.replace(/^([-*]\s+)[✓✔■⬛]/gm, '$1☑');
+        // Normalize unchecked checkbox patterns to ☐
+        result = result.replace(/^([-*]\s+)\[\s?\]/gm, '$1☐');
+        result = result.replace(/^([-*]\s+)[✗✘□⬜]/gm, '$1☐');
+        return result;
+    }
+    /**
+     * Normalize Unicode for Reddit format
+     * Converts Unicode superscript to ^text syntax
+     */
+    normalizeRedditUnicode(markdown) {
+        let result = markdown;
+        // Convert Unicode superscript digits to Reddit syntax
+        const superscriptMap = {
+            '⁰': '0', '¹': '1', '²': '2', '³': '3', '⁴': '4',
+            '⁵': '5', '⁶': '6', '⁷': '7', '⁸': '8', '⁹': '9',
+            'ⁿ': 'n', 'ⁱ': 'i'
+        };
+        // Replace Unicode superscripts with ^n format
+        for (const [unicode, digit] of Object.entries(superscriptMap)) {
+            result = result.replace(new RegExp(unicode, 'g'), `^${digit}`);
+        }
+        // Convert Unicode subscript digits to [n] format
+        const subscriptMap = {
+            '₀': '0', '₁': '1', '₂': '2', '₃': '3', '₄': '4',
+            '₅': '5', '₆': '6', '₇': '7', '₈': '8', '₉': '9'
+        };
+        for (const [unicode, digit] of Object.entries(subscriptMap)) {
+            result = result.replace(new RegExp(unicode, 'g'), `[${digit}]`);
+        }
+        return result;
+    }
+    /**
+     * Normalize Unicode for R Markdown format
+     * Converts Unicode superscript/subscript to Pandoc syntax
+     */
+    normalizeRMarkdownUnicode(markdown) {
+        let result = markdown;
+        // Convert Unicode superscript digits to Pandoc ^n^ format
+        const superscriptMap = {
+            '⁰': '0', '¹': '1', '²': '2', '³': '3', '⁴': '4',
+            '⁵': '5', '⁶': '6', '⁷': '7', '⁸': '8', '⁹': '9',
+            'ⁿ': 'n', 'ⁱ': 'i'
+        };
+        for (const [unicode, digit] of Object.entries(superscriptMap)) {
+            result = result.replace(new RegExp(unicode, 'g'), `^${digit}^`);
+        }
+        // Convert Unicode subscript digits to Pandoc ~n~ format
+        const subscriptMap = {
+            '₀': '0', '₁': '1', '₂': '2', '₃': '3', '₄': '4',
+            '₅': '5', '₆': '6', '₇': '7', '₈': '8', '₉': '9'
+        };
+        for (const [unicode, digit] of Object.entries(subscriptMap)) {
+            result = result.replace(new RegExp(unicode, 'g'), `~${digit}~`);
+        }
+        return result;
+    }
+    /**
+     * Create Reddit-optimized Turndown service
+     * - Superscript support (^text or ^(text with spaces))
+     * - Subscript to bracketed text
+     * - Fenced code blocks (new Reddit)
+     */
+    createRedditService() {
+        const service = new TurndownService({
+            headingStyle: 'atx',
+            hr: '---',
+            bulletListMarker: '-',
+            codeBlockStyle: 'fenced',
+            emDelimiter: '*',
+        });
+        // Apply all shared rules
+        this.addGoogleDocsRules(service);
+        this.addTableRules(service);
+        this.addListRules(service);
+        this.addPdfPageMarkerRules(service);
+        // Reddit-specific: Superscript (semantic tag)
+        service.addRule('redditSuperscript', {
+            filter: (node) => node.nodeName === 'SUP',
+            replacement: (content) => {
+                const trimmed = content.trim();
+                if (!trimmed)
+                    return '';
+                return trimmed.includes(' ') ? `^(${trimmed})` : `^${trimmed}`;
+            }
+        });
+        // Reddit-specific: Superscript (CSS vertical-align: super)
+        service.addRule('redditSuperscriptStyle', {
+            filter: (node) => {
+                if (node.nodeName !== 'SPAN')
+                    return false;
+                const style = node.getAttribute('style') || '';
+                return style.includes('vertical-align: super') ||
+                    style.includes('vertical-align:super');
+            },
+            replacement: (content) => {
+                const trimmed = content.trim();
+                if (!trimmed)
+                    return '';
+                return trimmed.includes(' ') ? `^(${trimmed})` : `^${trimmed}`;
+            }
+        });
+        // Reddit-specific: Subscript to brackets (semantic tag)
+        service.addRule('redditSubscript', {
+            filter: (node) => node.nodeName === 'SUB',
+            replacement: (content) => {
+                const trimmed = content.trim();
+                return trimmed ? `[${trimmed}]` : '';
+            }
+        });
+        // Reddit-specific: Subscript to brackets (CSS vertical-align: sub)
+        service.addRule('redditSubscriptStyle', {
+            filter: (node) => {
+                if (node.nodeName !== 'SPAN')
+                    return false;
+                const style = node.getAttribute('style') || '';
+                return style.includes('vertical-align: sub') ||
+                    style.includes('vertical-align:sub');
+            },
+            replacement: (content) => {
+                const trimmed = content.trim();
+                return trimmed ? `[${trimmed}]` : '';
+            }
+        });
+        return service;
+    }
+    /**
+     * Create R Markdown-optimized Turndown service
+     * - Pandoc superscript (^text^)
+     * - Pandoc subscript (~text~)
+     * - Math expression preservation
+     */
+    createRMarkdownService() {
+        const service = new TurndownService({
+            headingStyle: 'atx',
+            hr: '---',
+            bulletListMarker: '-',
+            codeBlockStyle: 'fenced',
+            emDelimiter: '*',
+        });
+        // Apply all shared rules
+        this.addGoogleDocsRules(service);
+        this.addTableRules(service);
+        this.addListRules(service);
+        this.addPdfPageMarkerRules(service);
+        // R Markdown-specific: Pandoc superscript (semantic tag)
+        service.addRule('rmdSuperscript', {
+            filter: (node) => node.nodeName === 'SUP',
+            replacement: (content) => {
+                const trimmed = content.trim();
+                return trimmed ? `^${trimmed}^` : '';
+            }
+        });
+        // R Markdown-specific: Pandoc superscript (CSS vertical-align: super)
+        service.addRule('rmdSuperscriptStyle', {
+            filter: (node) => {
+                if (node.nodeName !== 'SPAN')
+                    return false;
+                const style = node.getAttribute('style') || '';
+                return style.includes('vertical-align: super') ||
+                    style.includes('vertical-align:super');
+            },
+            replacement: (content) => {
+                const trimmed = content.trim();
+                return trimmed ? `^${trimmed}^` : '';
+            }
+        });
+        // R Markdown-specific: Pandoc subscript (semantic tag)
+        service.addRule('rmdSubscript', {
+            filter: (node) => node.nodeName === 'SUB',
+            replacement: (content) => {
+                const trimmed = content.trim();
+                return trimmed ? `~${trimmed}~` : '';
+            }
+        });
+        // R Markdown-specific: Pandoc subscript (CSS vertical-align: sub)
+        service.addRule('rmdSubscriptStyle', {
+            filter: (node) => {
+                if (node.nodeName !== 'SPAN')
+                    return false;
+                const style = node.getAttribute('style') || '';
+                return style.includes('vertical-align: sub') ||
+                    style.includes('vertical-align:sub');
+            },
+            replacement: (content) => {
+                const trimmed = content.trim();
+                return trimmed ? `~${trimmed}~` : '';
+            }
+        });
+        // R Markdown-specific: Preserve math expressions
+        service.addRule('rmdMath', {
+            filter: (node) => {
+                if (node.nodeName !== 'SPAN')
+                    return false;
+                return node.classList.contains('math') ||
+                    node.classList.contains('MathJax') ||
+                    node.hasAttribute('data-math');
+            },
+            replacement: (content, node) => {
+                const element = node;
+                const isDisplay = element.classList.contains('display');
+                const math = element.getAttribute('data-math') || content;
+                return isDisplay ? `$$${math}$$\n\n` : `$${math}$`;
+            }
+        });
+        return service;
+    }
+    /**
+     * Convert HTML table to plain text for Discord code blocks
+     */
+    tableToPlainText(table) {
+        const rows = Array.from(table.querySelectorAll('tr'));
+        if (rows.length === 0)
+            return '';
+        // Calculate column widths
+        const colWidths = [];
+        rows.forEach(row => {
+            const cells = Array.from(row.querySelectorAll('th, td'));
+            cells.forEach((cell, i) => {
+                const text = (cell.textContent || '').trim();
+                colWidths[i] = Math.max(colWidths[i] || 0, text.length);
+            });
+        });
+        // Build plain text table
+        const lines = [];
+        rows.forEach(row => {
+            const cells = Array.from(row.querySelectorAll('th, td'));
+            const cellTexts = cells.map((cell, i) => {
+                const text = (cell.textContent || '').trim();
+                return text.padEnd(colWidths[i] || 0);
+            });
+            lines.push(cellTexts.join('  '));
+        });
+        return lines.join('\n');
+    }
+    addGoogleDocsRules(service) {
+        // Enhanced Google Docs bold text detection
+        service.addRule('googleDocsBold', {
+            filter: (node) => {
+                if (node.nodeName !== 'SPAN')
+                    return false;
+                const style = node.getAttribute('style') || '';
+                // Check for font-weight: bold in the style
+                if (style.includes('font-weight: bold') || style.includes('font-weight:bold')) {
+                    return true;
+                }
+                // Check for bold font family names (Arial-BoldMT, etc)
+                const fontFamilyMatch = style.match(/font-family:\s*['"]*([^'"]+)['"]*[;]?/);
+                if (fontFamilyMatch && fontFamilyMatch[1].toLowerCase().includes('bold')) {
+                    return true;
+                }
+                // Check for font-weight numeric values >= 600
+                const fontWeightMatch = style.match(/font-weight:\s*(\d+)/);
+                if (fontWeightMatch && parseInt(fontWeightMatch[1]) >= 600) {
+                    return true;
+                }
+                return false;
+            },
+            replacement: (content) => {
+                return content.trim() ? `**${content}**` : content;
+            }
+        });
+        // Enhanced Google Docs italic text detection
+        service.addRule('googleDocsItalic', {
+            filter: (node) => {
+                if (node.nodeName !== 'SPAN')
+                    return false;
+                const style = node.getAttribute('style') || '';
+                // Check for font-style: italic
+                if (style.includes('font-style: italic') || style.includes('font-style:italic')) {
+                    return true;
+                }
+                // Check for italic font family names
+                const fontFamilyMatch = style.match(/font-family:\s*['"]*([^'"]+)['"]*[;]?/);
+                if (fontFamilyMatch && fontFamilyMatch[1].toLowerCase().includes('italic')) {
+                    return true;
+                }
+                return false;
+            },
+            replacement: (content) => {
+                return content.trim() ? `*${content}*` : content;
+            }
+        });
+        // Enhanced Google Docs headings detection
+        service.addRule('googleDocsHeadings', {
+            filter: (node) => {
+                if (node.nodeName === 'P' || node.nodeName === 'DIV') {
+                    const style = node.getAttribute('style') || '';
+                    // Check for large font sizes
+                    const fontSizeMatch = style.match(/font-size:\s*(\d+(?:\.\d+)?)px/);
+                    if (fontSizeMatch) {
+                        const fontSize = parseFloat(fontSizeMatch[1]);
+                        return fontSize > 16;
+                    }
+                    // Check for font-weight bold combined with larger text
+                    if (style.includes('font-weight: bold') || style.includes('font-weight:bold')) {
+                        const textContent = node.textContent || '';
+                        // If it's short and bold, likely a heading
+                        return textContent.length < 100 && textContent.trim().length > 0;
+                    }
+                }
+                return false;
+            },
+            replacement: (content, node) => {
+                const style = node?.getAttribute('style') || '';
+                const fontSizeMatch = style.match(/font-size:\s*(\d+(?:\.\d+)?)px/);
+                const fontSize = fontSizeMatch ? parseFloat(fontSizeMatch[1]) : 0;
+                // Determine heading level based on font size
+                let level = 3; // default to h3
+                if (fontSize >= 28)
+                    level = 1;
+                else if (fontSize >= 24)
+                    level = 2;
+                else if (fontSize >= 20)
+                    level = 3;
+                else if (fontSize >= 18)
+                    level = 4;
+                else
+                    level = 5;
+                const trimmedContent = content.trim();
+                return trimmedContent ? '\n' + '#'.repeat(level) + ' ' + trimmedContent + '\n\n' : content;
+            }
+        });
+        // Google Docs underline detection
+        service.addRule('googleDocsUnderline', {
+            filter: (node) => {
+                if (node.nodeName === 'SPAN') {
+                    const style = node.getAttribute('style') || '';
+                    return style.includes('text-decoration: underline') || style.includes('text-decoration:underline');
+                }
+                return false;
+            },
+            replacement: (content) => {
+                return content.trim() ? `<u>${content}</u>` : content;
+            }
+        });
+        // Strikethrough detection - semantic tags
+        service.addRule('strikethroughTags', {
+            filter: ['del', 's'],
+            replacement: (content) => {
+                return content.trim() ? `~~${content}~~` : content;
+            }
+        });
+        // Strikethrough detection - deprecated <strike> tag (filter as node check for TS compatibility)
+        service.addRule('strikethroughStrikeTag', {
+            filter: (node) => node.nodeName === 'STRIKE',
+            replacement: (content) => {
+                return content.trim() ? `~~${content}~~` : content;
+            }
+        });
+        // Strikethrough detection - CSS text-decoration: line-through
+        service.addRule('strikethroughStyle', {
+            filter: (node) => {
+                if (node.nodeName !== 'SPAN')
+                    return false;
+                const style = node.getAttribute('style') || '';
+                return style.includes('text-decoration: line-through') ||
+                    style.includes('text-decoration:line-through') ||
+                    style.includes('text-decoration-line: line-through') ||
+                    style.includes('text-decoration-line:line-through');
+            },
+            replacement: (content) => {
+                return content.trim() ? `~~${content}~~` : content;
+            }
+        });
+        // Inline code detection - CSS monospace font-family
+        service.addRule('monospaceCode', {
+            filter: (node) => {
+                if (node.nodeName !== 'SPAN')
+                    return false;
+                const style = node.getAttribute('style') || '';
+                const fontFamily = style.toLowerCase();
+                // Check for common monospace font indicators
+                return fontFamily.includes('monospace') ||
+                    fontFamily.includes('courier') ||
+                    fontFamily.includes('consolas') ||
+                    fontFamily.includes('monaco') ||
+                    fontFamily.includes('menlo') ||
+                    fontFamily.includes('source code') ||
+                    fontFamily.includes('fira code') ||
+                    fontFamily.includes('roboto mono') ||
+                    fontFamily.includes('ubuntu mono');
+            },
+            replacement: (content) => {
+                const trimmed = content.trim();
+                if (!trimmed)
+                    return content;
+                // Use backticks for inline code
+                // If content contains backticks, use double backticks
+                if (trimmed.includes('`')) {
+                    return `\`\` ${trimmed} \`\``;
+                }
+                return `\`${trimmed}\``;
+            }
+        });
+    }
+    addTableRules(service) {
+        // Enhanced table handling
+        service.addRule('enhancedTable', {
+            filter: 'table',
+            replacement: (content, node) => {
+                const table = node;
+                const rows = Array.from(table.querySelectorAll('tr'));
+                if (rows.length === 0)
+                    return content;
+                let markdown = '\n';
+                let headerProcessed = false;
+                rows.forEach((row, index) => {
+                    const cells = Array.from(row.querySelectorAll('th, td'));
+                    const cellContents = cells.map(cell => {
+                        const cellContent = cell.textContent || '';
+                        return cellContent.trim().replace(/\|/g, '\\|'); // Escape pipes
+                    });
+                    if (cellContents.length > 0) {
+                        markdown += '| ' + cellContents.join(' | ') + ' |\n';
+                        // Add header separator after first row if it contains th elements
+                        if (!headerProcessed && (row.querySelector('th') || index === 0)) {
+                            const separator = cellContents.map(() => '---').join(' | ');
+                            markdown += '| ' + separator + ' |\n';
+                            headerProcessed = true;
+                        }
+                    }
+                });
+                return markdown + '\n';
+            }
+        });
+    }
+    addListRules(service) {
+        // Enhanced nested list handling
+        service.addRule('enhancedList', {
+            filter: ['ul', 'ol'],
+            replacement: (content, node) => {
+                const listType = node?.nodeName.toLowerCase();
+                const items = Array.from(node.children).filter(child => child.nodeName.toLowerCase() === 'li');
+                if (items.length === 0)
+                    return content;
+                let markdown = '\n';
+                const isOrdered = listType === 'ol';
+                const marker = isOrdered ? '1.' : (service.options.bulletListMarker || '-');
+                items.forEach((item, index) => {
+                    const itemContent = this.processListItem(item, service);
+                    const actualMarker = isOrdered ? `${index + 1}.` : marker;
+                    markdown += `${actualMarker} ${itemContent}\n`;
+                });
+                return markdown + '\n';
+            }
+        });
+    }
+    processListItem(item, service, depth = 0) {
+        let content = '';
+        // Use numeric constants instead of Node.TEXT_NODE / Node.ELEMENT_NODE
+        // to avoid direct browser-global reference (Req 14.3)
+        const TEXT_NODE = 3;
+        const ELEMENT_NODE = 1;
+        Array.from(item.childNodes).forEach(child => {
+            if (child.nodeType === TEXT_NODE) {
+                content += child.textContent || '';
+            }
+            else if (child.nodeType === ELEMENT_NODE) {
+                const element = child;
+                if (element.nodeName.toLowerCase() === 'ul' || element.nodeName.toLowerCase() === 'ol') {
+                    // Handle nested lists, incrementing depth so indentation grows correctly
+                    const nestedContent = this.processNestedList(element, service, depth + 1);
+                    content += '\n' + nestedContent;
+                }
+                else {
+                    content += service.turndown(element.outerHTML);
+                }
+            }
+        });
+        return content.trim();
+    }
+    processNestedList(list, service, depth) {
+        const items = Array.from(list.children).filter(child => child.nodeName.toLowerCase() === 'li');
+        if (items.length === 0)
+            return '';
+        let markdown = '';
+        const isOrdered = list.nodeName.toLowerCase() === 'ol';
+        const indent = '  '.repeat(depth);
+        const marker = isOrdered ? '1.' : (service.options.bulletListMarker || '-');
+        items.forEach((item, index) => {
+            const itemContent = this.processListItem(item, service, depth);
+            const actualMarker = isOrdered ? `${index + 1}.` : marker;
+            markdown += `${indent}${actualMarker} ${itemContent}\n`;
+        });
+        return markdown;
+    }
+    /**
+     * Add PDF page marker rules to convert data-page-marker divs to Markdown comments
+     * This preserves page boundaries from PDF documents (Req 3.5)
+     */
+    addPdfPageMarkerRules(service) {
+        service.addRule('pdfPageMarker', {
+            filter: (node) => {
+                if (node.nodeName !== 'DIV')
+                    return false;
+                return node.hasAttribute('data-page-marker');
+            },
+            replacement: (_content, node) => {
+                const pageNumber = node.getAttribute('data-page-marker');
+                // Output as a Markdown comment-style marker that's visible in the output
+                return `\n\n---\n\n**[Page ${pageNumber}]**\n\n`;
+            }
+        });
+    }
+    async convert(html, options = {
+        format: 'github',
+        preserveTables: true,
+        preserveLists: true,
+        customRules: []
+    }) {
+        const startTime = performance.now();
+        const warnings = [];
+        const rulesApplied = [];
+        // Sanitize input
+        const sanitizedHtml = this.sanitize(html);
+        if (sanitizedHtml !== html) {
+            warnings.push('HTML content was sanitized for security');
+        }
+        // Validate input
+        const validation = this.validateInput(sanitizedHtml);
+        if (!validation.isValid) {
+            throw new Error(`Invalid input: ${validation.errors.join(', ')}`);
+        }
+        warnings.push(...validation.warnings);
+        // Select appropriate service
+        let service;
+        switch (options.format) {
+            case 'commonmark':
+                service = this.commonmarkService;
+                break;
+            case 'custom':
+                service = this.customService;
+                // Apply custom rules
+                options.customRules.forEach(rule => {
+                    service.addRule(rule.name, {
+                        filter: rule.filter,
+                        replacement: rule.replacement
+                    });
+                    rulesApplied.push(rule.name);
+                });
+                break;
+            case 'discord':
+                service = this.discordService;
+                break;
+            case 'reddit':
+                service = this.redditService;
+                break;
+            case 'rmarkdown':
+                service = this.rmarkdownService;
+                break;
+            case 'github':
+            default:
+                service = this.githubService;
+                break;
+        }
+        // Perform conversion
+        let markdown = service.turndown(sanitizedHtml);
+        // Apply format-specific post-processing for Unicode characters
+        markdown = this.applyFormatPostProcessing(markdown, options.format);
+        const endTime = performance.now();
+        const metadata = {
+            originalLength: html.length,
+            convertedLength: markdown.length,
+            processingTime: endTime - startTime,
+            formatUsed: options.format,
+            rulesApplied
+        };
+        return {
+            markdown,
+            warnings,
+            metadata
+        };
+    }
+    sanitize(html) {
+        // Use the centralized sanitization from input-sanitizer
+        return sanitizeHTML(html, {
+            level: 'moderate' // Use moderate level for conversion
+        });
+    }
+    validateInput(input) {
+        const errors = [];
+        const warnings = [];
+        if (!input || input.trim().length === 0) {
+            errors.push('Input is empty');
+        }
+        if (input.length > 1024 * 1024) { // 1MB limit
+            errors.push('Input exceeds maximum size limit');
+        }
+        if (input.length > 100 * 1024) { // 100KB warning
+            warnings.push('Large input detected, processing may take longer');
+        }
+        // Check for potentially problematic content
+        if (input.includes('<script')) {
+            warnings.push('Script tags detected and will be removed');
+        }
+        if (input.includes('javascript:')) {
+            warnings.push('JavaScript URLs detected and will be sanitized');
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+    // Method to get available format options
+    getAvailableFormats() {
+        return [
+            {
+                value: 'github',
+                label: 'GitHub Flavored Markdown',
+                description: 'Optimized for GitHub with fenced code blocks and dashes for lists'
+            },
+            {
+                value: 'commonmark',
+                label: 'CommonMark',
+                description: 'Strict CommonMark specification with indented code blocks'
+            },
+            {
+                value: 'custom',
+                label: 'Custom Rules',
+                description: 'GitHub base with additional custom conversion rules'
+            }
+        ];
+    }
+    // Method to create custom rules easily
+    createCustomRule(name, selector, replacement) {
+        return {
+            name,
+            filter: selector,
+            replacement
+        };
+    }
+}
+//# sourceMappingURL=conversion-engine.js.map