quikdown 1.0.3 → 1.0.4

package/dist/quikdown_bd.umd.js

@@ -0,0 +1,683 @@
+/**
+ * quikdown_bd - Bidirectional Markdown Parser
+ * @version 1.0.4
+ * @license BSD-2-Clause
+ * @copyright DeftIO 2025
+ */
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+    typeof define === 'function' && define.amd ? define(factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.quikdown_bd = factory());
+})(this, (function () { 'use strict';
+
+    /**
+     * quikdown_bd - Bidirectional markdown/HTML converter
+     * Standalone version with round-trip conversion support
+     * 
+     * Uses data-qd attributes to preserve original markdown syntax
+     * Enables HTML→Markdown conversion for quikdown-generated HTML
+     */
+
+    // Version - uses same version as core quikdown
+    const VERSION = '1.0.4';
+
+    // Helper to escape HTML (same as core)
+    const ESC_MAP = {'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'};
+    function escapeHtml(text) {
+        return text.replace(/[&<>"']/g, m => ESC_MAP[m]);
+    }
+
+    // Modified getAttr that adds data-qd attributes
+    function createGetAttrBD(inline_styles, styles) {
+        return function(tag, additionalStyle = '', sourceMarker = '') {
+            let attrs = '';
+            
+            // Add data-qd attribute if source marker provided
+            if (sourceMarker) {
+                attrs += ` data-qd="${escapeHtml(sourceMarker)}"`;
+            }
+            
+            // Add style or class
+            if (inline_styles) {
+                const style = styles[tag];
+                if (style || additionalStyle) {
+                    const fullStyle = additionalStyle ? (style ? `${style};${additionalStyle}` : additionalStyle) : style;
+                    attrs += ` style="${fullStyle}"`;
+                }
+            } else {
+                attrs += ` class="quikdown-${tag}"`;
+            }
+            
+            return attrs;
+        };
+    }
+
+    /**
+     * Enhanced markdown parser with bidirectional support
+     * Wraps the core parser and adds data-qd attributes
+     */
+    function quikdown_bd(markdown, options = {}) {
+        if (!markdown || typeof markdown !== 'string') {
+            return '';
+        }
+        
+        const { fence_plugin, inline_styles = false, bidirectional = true } = options;
+        
+        // If not bidirectional mode, process without data-qd attributes
+        if (!bidirectional) {
+            // Process without bidirectional tracking
+            options.bidirectional = false;
+        }
+        
+        // For bidirectional, we need to manually process with source tracking
+        // This is a custom implementation that adds data-qd attributes
+        
+        const QUIKDOWN_STYLES = {
+            h1: 'font-size:2em;font-weight:600;margin:.67em 0;text-align:left',
+            h2: 'font-size:1.5em;font-weight:600;margin:.83em 0',
+            h3: 'font-size:1.25em;font-weight:600;margin:1em 0',
+            h4: 'font-size:1em;font-weight:600;margin:1.33em 0',
+            h5: 'font-size:.875em;font-weight:600;margin:1.67em 0',
+            h6: 'font-size:.85em;font-weight:600;margin:2em 0',
+            pre: 'background:#f4f4f4;padding:10px;border-radius:4px;overflow-x:auto;margin:1em 0',
+            code: 'background:#f0f0f0;padding:2px 4px;border-radius:3px;font-family:monospace',
+            blockquote: 'border-left:4px solid #ddd;margin-left:0;padding-left:1em',
+            table: 'border-collapse:collapse;width:100%;margin:1em 0',
+            th: 'border:1px solid #ddd;padding:8px;background-color:#f2f2f2;font-weight:bold;text-align:left',
+            td: 'border:1px solid #ddd;padding:8px;text-align:left',
+            hr: 'border:none;border-top:1px solid #ddd;margin:1em 0',
+            img: 'max-width:100%;height:auto',
+            a: 'color:#06c;text-decoration:underline',
+            strong: 'font-weight:bold',
+            em: 'font-style:italic',
+            del: 'text-decoration:line-through',
+            ul: 'margin:.5em 0;padding-left:2em',
+            ol: 'margin:.5em 0;padding-left:2em',
+            li: 'margin:.25em 0',
+            'task-item': 'list-style:none',
+            'task-checkbox': 'margin-right:.5em'
+        };
+        
+        const getAttr = createGetAttrBD(inline_styles, QUIKDOWN_STYLES);
+        
+        // Process markdown with source tracking
+        let html = markdown;
+        
+        // Phase 1: Extract and protect code blocks
+        const codeBlocks = [];
+        const inlineCodes = [];
+        
+        // Extract fenced code blocks
+        html = html.replace(/^(```|~~~)([^\n]*)\n([\s\S]*?)^\1$/gm, (match, fence, lang, code) => {
+            const placeholder = `§CB${codeBlocks.length}§`;
+            codeBlocks.push({
+                fence,
+                lang: lang.trim(),
+                code: escapeHtml(code.trimEnd()),
+                original: match
+            });
+            return placeholder;
+        });
+        
+        // Extract inline code
+        html = html.replace(/`([^`]+)`/g, (match, code) => {
+            const placeholder = `§IC${inlineCodes.length}§`;
+            inlineCodes.push({
+                code: escapeHtml(code),
+                original: match
+            });
+            return placeholder;
+        });
+        
+        // Escape HTML
+        html = escapeHtml(html);
+        
+        // Process headings with source tracking
+        html = html.replace(/^(#{1,6})\s+(.+?)\s*#*$/gm, (match, hashes, content) => {
+            const level = hashes.length;
+            const sourceMarker = hashes;
+            return `<h${level}${getAttr('h' + level, '', sourceMarker)}>${content}</h${level}>`;
+        });
+        
+        // Process bold/italic/strikethrough with source tracking
+        html = html.replace(/\*\*(.+?)\*\*/g, `<strong${getAttr('strong', '', '**')}>$1</strong>`);
+        html = html.replace(/__(.+?)__/g, `<strong${getAttr('strong', '', '__')}>$1</strong>`);
+        html = html.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, `<em${getAttr('em', '', '*')}>$1</em>`);
+        html = html.replace(/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, `<em${getAttr('em', '', '_')}>$1</em>`);
+        html = html.replace(/~~(.+?)~~/g, `<del${getAttr('del', '', '~~')}>$1</del>`);
+        
+        // Process blockquotes
+        html = html.replace(/^&gt;\s+(.+)$/gm, `<blockquote${getAttr('blockquote', '', '>')}>$1</blockquote>`);
+        html = html.replace(/<\/blockquote>\n<blockquote[^>]*>/g, '\n');
+        
+        // Process horizontal rules
+        html = html.replace(/^---+$/gm, `<hr${getAttr('hr', '', '---')}>`);
+        
+        // Process lists (simplified for now)
+        html = processListsBD(html, getAttr);
+        
+        // Process links and images
+        html = html.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (match, alt, src) => {
+            return `<img${getAttr('img', '', '!')} src="${src}" alt="${alt}" data-qd-alt="${escapeHtml(alt)}" data-qd-src="${escapeHtml(src)}">`;
+        });
+        
+        html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (match, text, href) => {
+            return `<a${getAttr('a', '', '[')} href="${href}" data-qd-text="${escapeHtml(text)}">${text}</a>`;
+        });
+        
+        // Process tables
+        html = processTablesBD(html, getAttr);
+        
+        // Line breaks
+        html = html.replace(/  $/gm, '<br data-qd="  ">');
+        
+        // Paragraphs
+        html = html.replace(/\n\n+/g, '</p><p>');
+        html = '<p>' + html + '</p>';
+        
+        // Clean up empty paragraphs and unwrap block elements
+        html = html.replace(/<p><\/p>/g, '');
+        html = html.replace(/<p>(<h[1-6][^>]*>)/g, '$1');
+        html = html.replace(/(<\/h[1-6]>)<\/p>/g, '$1');
+        html = html.replace(/<p>(<blockquote[^>]*>)/g, '$1');
+        html = html.replace(/(<\/blockquote>)<\/p>/g, '$1');
+        html = html.replace(/<p>(<ul[^>]*>|<ol[^>]*>)/g, '$1');
+        html = html.replace(/(<\/ul>|<\/ol>)<\/p>/g, '$1');
+        html = html.replace(/<p>(<hr[^>]*>)<\/p>/g, '$1');
+        html = html.replace(/<p>(<table[^>]*>)/g, '$1');
+        html = html.replace(/(<\/table>)<\/p>/g, '$1');
+        
+        // Restore code blocks
+        codeBlocks.forEach((block, i) => {
+            const placeholder = `§CB${i}§`;
+            let replacement;
+            
+            if (fence_plugin && typeof fence_plugin === 'function') {
+                replacement = fence_plugin(block.code, block.lang);
+                if (replacement === undefined) {
+                    replacement = `<pre${getAttr('pre', '', block.fence)}><code data-qd-lang="${block.lang}">${block.code}</code></pre>`;
+                }
+            } else {
+                replacement = `<pre${getAttr('pre', '', block.fence)} data-qd-fence="${block.fence}" data-qd-lang="${block.lang}"><code>${block.code}</code></pre>`;
+            }
+            
+            html = html.replace(placeholder, replacement);
+        });
+        
+        // Restore inline codes
+        inlineCodes.forEach((item, i) => {
+            const placeholder = `§IC${i}§`;
+            html = html.replace(placeholder, `<code${getAttr('code', '', '`')}>${item.code}</code>`);
+        });
+        
+        return html.trim();
+    }
+
+    // Process lists with source tracking
+    function processListsBD(text, getAttr, inline_styles) {
+        const lines = text.split('\n');
+        const result = [];
+        let listStack = [];
+        
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const match = line.match(/^(\s*)([*\-+]|\d+\.)\s+(.+)$/);
+            
+            if (match) {
+                const [, indent, marker, content] = match;
+                const level = Math.floor(indent.length / 2);
+                const isOrdered = /^\d+\./.test(marker);
+                const listType = isOrdered ? 'ol' : 'ul';
+                const sourceMarker = isOrdered ? '1.' : marker;
+                
+                // Handle task lists
+                let listItemContent = content;
+                let taskAttrs = '';
+                const taskMatch = content.match(/^\[([x ])\]\s+(.*)$/i);
+                if (taskMatch && !isOrdered) {
+                    const [, checked, taskContent] = taskMatch;
+                    const isChecked = checked.toLowerCase() === 'x';
+                    listItemContent = `<input type="checkbox"${getAttr('task-checkbox', '', '[')}${isChecked ? ' checked' : ''}> ${taskContent}`;
+                    taskAttrs = getAttr('task-item', '', '- [ ]');
+                }
+                
+                // Close deeper levels
+                while (listStack.length > level + 1) {
+                    const list = listStack.pop();
+                    result.push(`</${list.type}>`);
+                }
+                
+                // Open new level if needed
+                if (listStack.length === level) {
+                    listStack.push({ type: listType, level, marker: sourceMarker });
+                    result.push(`<${listType}${getAttr(listType, '', sourceMarker)}>`);
+                }
+                
+                const liAttr = taskAttrs || getAttr('li', '', sourceMarker);
+                result.push(`<li${liAttr}>${listItemContent}</li>`);
+            } else {
+                // Close all lists
+                while (listStack.length > 0) {
+                    const list = listStack.pop();
+                    result.push(`</${list.type}>`);
+                }
+                result.push(line);
+            }
+        }
+        
+        // Close remaining lists
+        while (listStack.length > 0) {
+            const list = listStack.pop();
+            result.push(`</${list.type}>`);
+        }
+        
+        return result.join('\n');
+    }
+
+    // Process tables with source tracking
+    function processTablesBD(text, getAttr) {
+        const lines = text.split('\n');
+        const result = [];
+        let inTable = false;
+        let tableLines = [];
+        
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i].trim();
+            
+            if (line.includes('|')) {
+                if (!inTable) {
+                    inTable = true;
+                    tableLines = [];
+                }
+                tableLines.push(line);
+            } else {
+                if (inTable) {
+                    const tableHtml = buildTableBD(tableLines, getAttr);
+                    if (tableHtml) {
+                        result.push(tableHtml);
+                    } else {
+                        result.push(...tableLines);
+                    }
+                    inTable = false;
+                    tableLines = [];
+                }
+                result.push(lines[i]);
+            }
+        }
+        
+        if (inTable && tableLines.length > 0) {
+            const tableHtml = buildTableBD(tableLines, getAttr);
+            if (tableHtml) {
+                result.push(tableHtml);
+            } else {
+                result.push(...tableLines);
+            }
+        }
+        
+        return result.join('\n');
+    }
+
+    // Build table with source tracking
+    function buildTableBD(lines, getAttr) {
+        if (lines.length < 2) return null;
+        
+        // Find separator
+        let separatorIndex = -1;
+        let alignments = [];
+        
+        for (let i = 1; i < lines.length; i++) {
+            if (/^\|?[\s\-:|]+\|?$/.test(lines[i]) && lines[i].includes('-')) {
+                separatorIndex = i;
+                const cells = lines[i].replace(/^\|/, '').replace(/\|$/, '').split('|');
+                alignments = cells.map(cell => {
+                    const trimmed = cell.trim();
+                    if (trimmed.startsWith(':') && trimmed.endsWith(':')) return 'center';
+                    if (trimmed.endsWith(':')) return 'right';
+                    return 'left';
+                });
+                break;
+            }
+        }
+        
+        if (separatorIndex === -1) return null;
+        
+        let html = `<table${getAttr('table', '', '|')} data-qd-align="${alignments.join(',')}">\n`;
+        
+        // Headers
+        if (separatorIndex > 0) {
+            html += `<thead${getAttr('thead', '', '|')}>\n<tr${getAttr('tr', '', '|')}>\n`;
+            const cells = lines[0].replace(/^\|/, '').replace(/\|$/, '').split('|');
+            cells.forEach((cell, i) => {
+                const align = alignments[i] && alignments[i] !== 'left' ? `text-align:${alignments[i]}` : '';
+                html += `<th${getAttr('th', align, '|')} data-qd-align="${alignments[i] || 'left'}">${escapeHtml(cell.trim())}</th>\n`;
+            });
+            html += '</tr>\n</thead>\n';
+        }
+        
+        // Body
+        const bodyLines = lines.slice(separatorIndex + 1);
+        if (bodyLines.length > 0) {
+            html += `<tbody${getAttr('tbody', '', '|')}>\n`;
+            bodyLines.forEach(line => {
+                html += `<tr${getAttr('tr', '', '|')}>\n`;
+                const cells = line.replace(/^\|/, '').replace(/\|$/, '').split('|');
+                cells.forEach((cell, i) => {
+                    const align = alignments[i] && alignments[i] !== 'left' ? `text-align:${alignments[i]}` : '';
+                    html += `<td${getAttr('td', align, '|')} data-qd-align="${alignments[i] || 'left'}">${escapeHtml(cell.trim())}</td>\n`;
+                });
+                html += '</tr>\n';
+            });
+            html += '</tbody>\n';
+        }
+        
+        html += '</table>';
+        return html;
+    }
+
+    /**
+     * Convert HTML back to Markdown by walking the DOM tree
+     * Uses data-qd attributes when available, falls back to canonical forms
+     * Assumes browser environment with DOM API available
+     */
+    quikdown_bd.toMarkdown = function(htmlOrElement) {
+        // Accept either HTML string or DOM element
+        let container;
+        if (typeof htmlOrElement === 'string') {
+            container = document.createElement('div');
+            container.innerHTML = htmlOrElement;
+        } else if (htmlOrElement instanceof Element) {
+            container = htmlOrElement;
+        } else {
+            return '';
+        }
+        
+        // Walk the DOM tree and reconstruct markdown
+        function walkNode(node, parentContext = {}) {
+            if (node.nodeType === Node.TEXT_NODE) {
+                // Return text content, preserving whitespace where needed
+                return node.textContent;
+            }
+            
+            if (node.nodeType !== Node.ELEMENT_NODE) {
+                return '';
+            }
+            
+            const tag = node.tagName.toLowerCase();
+            const dataQd = node.getAttribute('data-qd');
+            const styles = window.getComputedStyle ? window.getComputedStyle(node) : {};
+            
+            // Process children with context
+            let childContent = '';
+            for (let child of node.childNodes) {
+                childContent += walkNode(child, { parentTag: tag, ...parentContext });
+            }
+            
+            // Determine markdown based on element and attributes
+            switch (tag) {
+                case 'h1':
+                case 'h2':
+                case 'h3':
+                case 'h4':
+                case 'h5':
+                case 'h6':
+                    const level = parseInt(tag[1]);
+                    const prefix = dataQd || '#'.repeat(level);
+                    return `${prefix} ${childContent.trim()}\n\n`;
+                    
+                case 'strong':
+                case 'b':
+                    // Check if it's bold through style too
+                    if (styles.fontWeight === 'bold' || styles.fontWeight >= 700 || tag === 'strong' || tag === 'b') {
+                        const boldMarker = dataQd || '**';
+                        return `${boldMarker}${childContent}${boldMarker}`;
+                    }
+                    return childContent;
+                    
+                case 'em':
+                case 'i':
+                    // Check for italic through style
+                    if (styles.fontStyle === 'italic' || tag === 'em' || tag === 'i') {
+                        const emMarker = dataQd || '*';
+                        return `${emMarker}${childContent}${emMarker}`;
+                    }
+                    return childContent;
+                    
+                case 'del':
+                case 's':
+                case 'strike':
+                    const delMarker = dataQd || '~~';
+                    return `${delMarker}${childContent}${delMarker}`;
+                    
+                case 'code':
+                    // Skip if inside pre (handled by pre)
+                    if (parentContext.parentTag === 'pre') {
+                        return childContent;
+                    }
+                    const codeMarker = dataQd || '`';
+                    return `${codeMarker}${childContent}${codeMarker}`;
+                    
+                case 'pre':
+                    const fence = node.getAttribute('data-qd-fence') || dataQd || '```';
+                    const lang = node.getAttribute('data-qd-lang') || '';
+                    // Look for code element child
+                    const codeEl = node.querySelector('code');
+                    const codeContent = codeEl ? codeEl.textContent : childContent;
+                    return `${fence}${lang}\n${codeContent.trimEnd()}\n${fence}\n\n`;
+                    
+                case 'blockquote':
+                    const quoteMarker = dataQd || '>';
+                    const lines = childContent.trim().split('\n');
+                    return lines.map(line => `${quoteMarker} ${line}`).join('\n') + '\n\n';
+                    
+                case 'hr':
+                    const hrMarker = dataQd || '---';
+                    return `${hrMarker}\n\n`;
+                    
+                case 'br':
+                    const brMarker = dataQd || '  ';
+                    return `${brMarker}\n`;
+                    
+                case 'a':
+                    const linkText = node.getAttribute('data-qd-text') || childContent.trim();
+                    const href = node.getAttribute('href') || '';
+                    // Check for autolinks
+                    if (linkText === href && !dataQd) {
+                        return `<${href}>`;
+                    }
+                    return `[${linkText}](${href})`;
+                    
+                case 'img':
+                    const alt = node.getAttribute('data-qd-alt') || node.getAttribute('alt') || '';
+                    const src = node.getAttribute('data-qd-src') || node.getAttribute('src') || '';
+                    const imgMarker = dataQd || '!';
+                    return `${imgMarker}[${alt}](${src})`;
+                    
+                case 'ul':
+                case 'ol':
+                    return walkList(node, tag === 'ol') + '\n';
+                    
+                case 'li':
+                    // Handled by list processor
+                    return childContent;
+                    
+                case 'table':
+                    return walkTable(node) + '\n\n';
+                    
+                case 'p':
+                    // Check if it's actually a paragraph or just a wrapper
+                    if (childContent.trim()) {
+                        return childContent.trim() + '\n\n';
+                    }
+                    return '';
+                    
+                case 'div':
+                    // Check if it's a mermaid container
+                    if (node.classList && node.classList.contains('mermaid-container')) {
+                        const fence = node.getAttribute('data-qd-fence') || '```';
+                        const lang = node.getAttribute('data-qd-lang') || 'mermaid';
+                        // Look for the source element
+                        const sourceElement = node.querySelector('.mermaid-source');
+                        if (sourceElement) {
+                            // Decode HTML entities
+                            const temp = document.createElement('div');
+                            temp.innerHTML = sourceElement.innerHTML;
+                            const code = temp.textContent;
+                            return `${fence}${lang}\n${code}\n${fence}\n\n`;
+                        }
+                        // Fallback: try to extract from the mermaid element
+                        const mermaidElement = node.querySelector('.mermaid');
+                        if (mermaidElement && mermaidElement.textContent.includes('graph')) {
+                            return `${fence}${lang}\n${mermaidElement.textContent.trim()}\n${fence}\n\n`;
+                        }
+                    }
+                    // Check if it's a standalone mermaid diagram (legacy)
+                    if (node.classList && node.classList.contains('mermaid')) {
+                        const fence = node.getAttribute('data-qd-fence') || '```';
+                        const lang = node.getAttribute('data-qd-lang') || 'mermaid';
+                        const code = node.textContent.trim();
+                        return `${fence}${lang}\n${code}\n${fence}\n\n`;
+                    }
+                    // Pass through other divs
+                    return childContent;
+                
+                case 'span':
+                    // Pass through container elements
+                    return childContent;
+                    
+                default:
+                    return childContent;
+            }
+        }
+        
+        // Walk list elements
+        function walkList(listNode, isOrdered, depth = 0) {
+            let result = '';
+            let index = 1;
+            const indent = '  '.repeat(depth);
+            
+            for (let child of listNode.children) {
+                if (child.tagName !== 'LI') continue;
+                
+                const dataQd = child.getAttribute('data-qd');
+                let marker = dataQd || (isOrdered ? `${index}.` : '-');
+                
+                // Check for task list checkbox
+                const checkbox = child.querySelector('input[type="checkbox"]');
+                if (checkbox) {
+                    const checked = checkbox.checked ? 'x' : ' ';
+                    marker = '-';
+                    // Get text without the checkbox
+                    let text = '';
+                    for (let node of child.childNodes) {
+                        if (node.nodeType === Node.TEXT_NODE) {
+                            text += node.textContent;
+                        } else if (node.tagName && node.tagName !== 'INPUT') {
+                            text += walkNode(node);
+                        }
+                    }
+                    result += `${indent}${marker} [${checked}] ${text.trim()}\n`;
+                } else {
+                    let itemContent = '';
+                    
+                    for (let node of child.childNodes) {
+                        if (node.tagName === 'UL' || node.tagName === 'OL') {
+                            itemContent += walkList(node, node.tagName === 'OL', depth + 1);
+                        } else {
+                            itemContent += walkNode(node);
+                        }
+                    }
+                    
+                    result += `${indent}${marker} ${itemContent.trim()}\n`;
+                }
+                
+                index++;
+            }
+            
+            return result;
+        }
+        
+        // Walk table elements
+        function walkTable(table) {
+            let result = '';
+            const alignData = table.getAttribute('data-qd-align');
+            const alignments = alignData ? alignData.split(',') : [];
+            
+            // Process header
+            const thead = table.querySelector('thead');
+            if (thead) {
+                const headerRow = thead.querySelector('tr');
+                if (headerRow) {
+                    const headers = [];
+                    for (let th of headerRow.querySelectorAll('th')) {
+                        headers.push(th.textContent.trim());
+                    }
+                    result += '| ' + headers.join(' | ') + ' |\n';
+                    
+                    // Add separator with alignment
+                    const separators = headers.map((_, i) => {
+                        const align = alignments[i] || th.getAttribute('data-qd-align') || 'left';
+                        if (align === 'center') return ':---:';
+                        if (align === 'right') return '---:';
+                        return '---';
+                    });
+                    result += '| ' + separators.join(' | ') + ' |\n';
+                }
+            }
+            
+            // Process body
+            const tbody = table.querySelector('tbody');
+            if (tbody) {
+                for (let row of tbody.querySelectorAll('tr')) {
+                    const cells = [];
+                    for (let td of row.querySelectorAll('td')) {
+                        cells.push(td.textContent.trim());
+                    }
+                    if (cells.length > 0) {
+                        result += '| ' + cells.join(' | ') + ' |\n';
+                    }
+                }
+            }
+            
+            return result.trim();
+        }
+        
+        // Process the DOM tree
+        let markdown = walkNode(container);
+        
+        // Clean up
+        markdown = markdown.replace(/\n{3,}/g, '\n\n'); // Remove excessive newlines
+        markdown = markdown.trim();
+        
+        return markdown;
+    };
+
+    // Add emitStyles method (same as core)
+    quikdown_bd.emitStyles = function(prefix = 'quikdown-', theme = 'light') {
+        // This would generate CSS based on the styles
+        // For now, returning empty string as placeholder
+        // In production, this would generate the full CSS
+        return '';
+    };
+
+    // Configure method
+    quikdown_bd.configure = function(options) {
+        return function(markdown) {
+            return quikdown_bd(markdown, options);
+        };
+    };
+
+    // Version property
+    quikdown_bd.version = VERSION;
+
+    // Export for both module and browser
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = quikdown_bd;
+    }
+
+    if (typeof window !== 'undefined') {
+        window.quikdown_bd = quikdown_bd;
+    }
+
+    return quikdown_bd;
+
+}));