formatferry 1.0.2 → 1.0.3

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

@@ -1,790 +0,0 @@
-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