quikdown 1.0.4 → 1.1.0

package/dist/quikdown_bd.umd.js

@@ -1,6 +1,6 @@
 /**
  * quikdown_bd - Bidirectional Markdown Parser
- * @version 1.0.4
+ * @version 1.1.0
  * @license BSD-2-Clause
  * @copyright DeftIO 2025
  */
@@ -11,271 +11,379 @@
 })(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
+     * quikdown - A minimal markdown parser optimized for chat/LLM output
+     * Supports tables, code blocks, lists, and common formatting
+     * @param {string} markdown - The markdown source text
+     * @param {Object} options - Optional configuration object
+     * @param {Function} options.fence_plugin - Custom renderer for fenced code blocks
+     *                   (content, fence_string) => html string
+     * @param {boolean} options.inline_styles - If true, uses inline styles instead of classes
+     * @param {boolean} options.bidirectional - If true, adds data-qd attributes for source tracking
+     * @param {boolean} options.lazy_linefeeds - If true, single newlines become <br> tags
+     * @returns {string} - The rendered HTML
      */
 
-    // Version - uses same version as core quikdown
-    const VERSION = '1.0.4';
+    // Version will be injected at build time  
+    const quikdownVersion = '1.1.0';
 
-    // Helper to escape HTML (same as core)
+    // Constants for reuse
+    const CLASS_PREFIX = 'quikdown-';
+    const PLACEHOLDER_CB = '§CB';
+    const PLACEHOLDER_IC = '§IC';
+
+    // Escape map at module level
     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
+    // Single source of truth for all style definitions - optimized
+    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 list specific styles
+        'task-item': 'list-style:none',
+        'task-checkbox': 'margin-right:.5em'
+    };
+
+    // Factory function to create getAttr for a given context
+    function createGetAttr(inline_styles, styles) {
+        return function(tag, additionalStyle = '') {
             if (inline_styles) {
-                const style = styles[tag];
-                if (style || additionalStyle) {
-                    const fullStyle = additionalStyle ? (style ? `${style};${additionalStyle}` : additionalStyle) : style;
-                    attrs += ` style="${fullStyle}"`;
+                let style = styles[tag];
+                if (!style && !additionalStyle) return '';
+                
+                // Remove default text-align if we're adding a different alignment
+                if (additionalStyle && additionalStyle.includes('text-align') && style && style.includes('text-align')) {
+                    style = style.replace(/text-align:[^;]+;?/, '').trim();
+                    if (style && !style.endsWith(';')) style += ';';
                 }
+                
+                /* istanbul ignore next - defensive: additionalStyle without style doesn't occur with current tags */
+                const fullStyle = additionalStyle ? (style ? `${style}${additionalStyle}` : additionalStyle) : style;
+                return ` style="${fullStyle}"`;
             } else {
-                attrs += ` class="quikdown-${tag}"`;
+                const classAttr = ` class="${CLASS_PREFIX}${tag}"`;
+                // Apply inline styles for alignment even when using CSS classes
+                if (additionalStyle) {
+                    return `${classAttr} style="${additionalStyle}"`;
+                }
+                return classAttr;
             }
-            
-            return attrs;
         };
     }
 
-    /**
-     * Enhanced markdown parser with bidirectional support
-     * Wraps the core parser and adds data-qd attributes
-     */
-    function quikdown_bd(markdown, options = {}) {
+    function quikdown(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;
+        const { fence_plugin, inline_styles = false, bidirectional = false, lazy_linefeeds = false } = options;
+        const styles = QUIKDOWN_STYLES; // Use module-level styles
+        const getAttr = createGetAttr(inline_styles, styles); // Create getAttr once
+
+        // Escape HTML entities to prevent XSS
+        function escapeHtml(text) {
+            return text.replace(/[&<>"']/g, m => ESC_MAP[m]);
         }
         
-        // 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);
+        // Helper to add data-qd attributes for bidirectional support
+        const dataQd = bidirectional ? (marker) => ` data-qd="${escapeHtml(marker)}"` : () => '';
         
-        // Process markdown with source tracking
+        // Sanitize URLs to prevent XSS attacks
+        function sanitizeUrl(url, allowUnsafe = false) {
+            /* istanbul ignore next - defensive programming, regex ensures url is never empty */
+            if (!url) return '';
+            
+            // If unsafe URLs are explicitly allowed, return as-is
+            if (allowUnsafe) return url;
+            
+            const trimmedUrl = url.trim();
+            const lowerUrl = trimmedUrl.toLowerCase();
+            
+            // Block dangerous protocols
+            const dangerousProtocols = ['javascript:', 'vbscript:', 'data:'];
+            
+            for (const protocol of dangerousProtocols) {
+                if (lowerUrl.startsWith(protocol)) {
+                    // Exception: Allow data:image/* for images
+                    if (protocol === 'data:' && lowerUrl.startsWith('data:image/')) {
+                        return trimmedUrl;
+                    }
+                    // Return safe empty link for dangerous protocols
+                    return '#';
+                }
+            }
+            
+            return trimmedUrl;
+        }
+
+        // Process the markdown in phases
         let html = markdown;
         
-        // Phase 1: Extract and protect code blocks
+        // Phase 1: Extract and protect code blocks and inline code
         const codeBlocks = [];
         const inlineCodes = [];
         
-        // Extract fenced code blocks
+        // Extract fenced code blocks first (supports both ``` and ~~~)
+        // Match paired fences - ``` with ``` and ~~~ with ~~~
+        // Fence must be at start of line
         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
-            });
+            const placeholder = `${PLACEHOLDER_CB}${codeBlocks.length}§`;
+            
+            // Trim the language specification
+            const langTrimmed = lang ? lang.trim() : '';
+            
+            // If custom fence plugin is provided, use it (v1.1.0: object format required)
+            if (fence_plugin && fence_plugin.render && typeof fence_plugin.render === 'function') {
+                codeBlocks.push({
+                    lang: langTrimmed,
+                    code: code.trimEnd(),
+                    custom: true,
+                    fence: fence,
+                    hasReverse: !!fence_plugin.reverse
+                });
+            } else {
+                codeBlocks.push({
+                    lang: langTrimmed,
+                    code: escapeHtml(code.trimEnd()),
+                    custom: false,
+                    fence: fence
+                });
+            }
             return placeholder;
         });
         
         // Extract inline code
         html = html.replace(/`([^`]+)`/g, (match, code) => {
-            const placeholder = `§IC${inlineCodes.length}§`;
-            inlineCodes.push({
-                code: escapeHtml(code),
-                original: match
-            });
+            const placeholder = `${PLACEHOLDER_IC}${inlineCodes.length}§`;
+            inlineCodes.push(escapeHtml(code));
             return placeholder;
         });
         
-        // Escape HTML
+        // Now escape HTML in the rest of the content
         html = escapeHtml(html);
         
-        // Process headings with source tracking
+        // Phase 2: Process block elements
+        
+        // Process tables
+        html = processTable(html, getAttr);
+        
+        // Process headings (supports optional trailing #'s)
         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}>`;
+            return `<h${level}${getAttr('h' + level)}${dataQd(hashes)}>${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 (must handle escaped > since we already escaped HTML)
+        html = html.replace(/^&gt;\s+(.+)$/gm, `<blockquote${getAttr('blockquote')}>$1</blockquote>`);
+        // Merge consecutive blockquotes
+        html = html.replace(/<\/blockquote>\n<blockquote>/g, '\n');
         
-        // Process blockquotes
-        html = html.replace(/^&gt;\s+(.+)$/gm, `<blockquote${getAttr('blockquote', '', '>')}>$1</blockquote>`);
-        html = html.replace(/<\/blockquote>\n<blockquote[^>]*>/g, '\n');
+        // Process horizontal rules (allow trailing spaces)
+        html = html.replace(/^---+\s*$/gm, `<hr${getAttr('hr')}>`);
         
-        // Process horizontal rules
-        html = html.replace(/^---+$/gm, `<hr${getAttr('hr', '', '---')}>`);
+        // Process lists
+        html = processLists(html, getAttr, inline_styles, bidirectional);
         
-        // Process lists (simplified for now)
-        html = processListsBD(html, getAttr);
+        // Phase 3: Process inline elements
         
-        // Process links and images
+        // Images (must come before links, with URL sanitization)
         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)}">`;
+            const sanitizedSrc = sanitizeUrl(src, options.allow_unsafe_urls);
+            const altAttr = bidirectional && alt ? ` data-qd-alt="${escapeHtml(alt)}"` : '';
+            const srcAttr = bidirectional ? ` data-qd-src="${escapeHtml(src)}"` : '';
+            return `<img${getAttr('img')} src="${sanitizedSrc}" alt="${alt}"${altAttr}${srcAttr}${dataQd('!')}>`;
         });
         
+        // Links (with URL sanitization)
         html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (match, text, href) => {
-            return `<a${getAttr('a', '', '[')} href="${href}" data-qd-text="${escapeHtml(text)}">${text}</a>`;
+            // Sanitize URL to prevent XSS
+            const sanitizedHref = sanitizeUrl(href, options.allow_unsafe_urls);
+            const isExternal = /^https?:\/\//i.test(sanitizedHref);
+            const rel = isExternal ? ' rel="noopener noreferrer"' : '';
+            const textAttr = bidirectional ? ` data-qd-text="${escapeHtml(text)}"` : '';
+            return `<a${getAttr('a')} href="${sanitizedHref}"${rel}${textAttr}${dataQd('[')}>${text}</a>`;
         });
         
-        // Process tables
-        html = processTablesBD(html, getAttr);
+        // Autolinks - convert bare URLs to clickable links
+        html = html.replace(/(^|\s)(https?:\/\/[^\s<]+)/g, (match, prefix, url) => {
+            const sanitizedUrl = sanitizeUrl(url, options.allow_unsafe_urls);
+            return `${prefix}<a${getAttr('a')} href="${sanitizedUrl}" rel="noopener noreferrer">${url}</a>`;
+        });
         
-        // Line breaks
-        html = html.replace(/  $/gm, '<br data-qd="  ">');
+        // Process inline formatting (bold, italic, strikethrough)
+        const inlinePatterns = [
+            [/\*\*(.+?)\*\*/g, 'strong', '**'],
+            [/__(.+?)__/g, 'strong', '__'],
+            [/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, 'em', '*'],
+            [/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, 'em', '_'],
+            [/~~(.+?)~~/g, 'del', '~~']
+        ];
         
-        // Paragraphs
-        html = html.replace(/\n\n+/g, '</p><p>');
-        html = '<p>' + html + '</p>';
+        inlinePatterns.forEach(([pattern, tag, marker]) => {
+            html = html.replace(pattern, `<${tag}${getAttr(tag)}${dataQd(marker)}>$1</${tag}>`);
+        });
+        
+        // Line breaks
+        if (lazy_linefeeds) {
+            // Lazy linefeeds: single newline becomes <br> (except between paragraphs and after/before block elements)
+            const blocks = [];
+            let bi = 0;
+            
+            // Protect tables and lists  
+            html = html.replace(/<(table|[uo]l)[^>]*>[\s\S]*?<\/\1>/g, m => {
+                blocks[bi] = m;
+                return `§B${bi++}§`;
+            });
+            
+            // Handle paragraphs and block elements
+            html = html.replace(/\n\n+/g, '§P§')
+                // After block elements
+                .replace(/(<\/(?:h[1-6]|blockquote|pre)>)\n/g, '$1§N§')
+                .replace(/(<(?:h[1-6]|blockquote|pre|hr)[^>]*>)\n/g, '$1§N§')
+                // Before block elements  
+                .replace(/\n(<(?:h[1-6]|blockquote|pre|hr)[^>]*>)/g, '§N§$1')
+                .replace(/\n(§B\d+§)/g, '§N§$1')
+                .replace(/(§B\d+§)\n/g, '$1§N§')
+                // Convert remaining newlines
+                .replace(/\n/g, `<br${getAttr('br')}>`)
+                // Restore
+                .replace(/§N§/g, '\n')
+                .replace(/§P§/g, '</p><p>');
+            
+            // Restore protected blocks
+            blocks.forEach((b, i) => html = html.replace(`§B${i}§`, b));
+            
+            html = '<p>' + html + '</p>';
+        } else {
+            // Standard: two spaces at end of line for line breaks
+            html = html.replace(/  $/gm, `<br${getAttr('br')}>`);
+            
+            // Paragraphs (double newlines)
+            // Don't add </p> after block elements (they're not in paragraphs)
+            html = html.replace(/\n\n+/g, (match, offset) => {
+                // Check if we're after a block element closing tag
+                const before = html.substring(0, offset);
+                if (before.match(/<\/(h[1-6]|blockquote|ul|ol|table|pre|hr)>$/)) {
+                    return '<p>';  // Just open a new paragraph
+                }
+                return '</p><p>';  // Normal paragraph break
+            });
+            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');
+        const cleanupPatterns = [
+            [/<p><\/p>/g, ''],
+            [/<p>(<h[1-6][^>]*>)/g, '$1'],
+            [/(<\/h[1-6]>)<\/p>/g, '$1'],
+            [/<p>(<blockquote[^>]*>)/g, '$1'],
+            [/(<\/blockquote>)<\/p>/g, '$1'],
+            [/<p>(<ul[^>]*>|<ol[^>]*>)/g, '$1'],
+            [/(<\/ul>|<\/ol>)<\/p>/g, '$1'],
+            [/<p>(<hr[^>]*>)<\/p>/g, '$1'],
+            [/<p>(<table[^>]*>)/g, '$1'],
+            [/(<\/table>)<\/p>/g, '$1'],
+            [/<p>(<pre[^>]*>)/g, '$1'],
+            [/(<\/pre>)<\/p>/g, '$1'],
+            [new RegExp(`<p>(${PLACEHOLDER_CB}\\d+§)<\/p>`, 'g'), '$1']
+        ];
+        
+        cleanupPatterns.forEach(([pattern, replacement]) => {
+            html = html.replace(pattern, replacement);
+        });
+        
+        // Fix orphaned closing </p> tags after block elements
+        // When a paragraph follows a block element, ensure it has opening <p>
+        html = html.replace(/(<\/(?:h[1-6]|blockquote|ul|ol|table|pre|hr)>)\n([^<])/g, '$1\n<p>$2');
+        
+        // Phase 4: Restore code blocks and inline code
         
         // 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 (block.custom && fence_plugin && fence_plugin.render) {
+                // Use custom fence plugin (v1.1.0: object format with render function)
+                replacement = fence_plugin.render(block.code, block.lang);
+                
+                // If plugin returns undefined, fall back to default rendering
                 if (replacement === undefined) {
-                    replacement = `<pre${getAttr('pre', '', block.fence)}><code data-qd-lang="${block.lang}">${block.code}</code></pre>`;
+                    const langClass = !inline_styles && block.lang ? ` class="language-${block.lang}"` : '';
+                    const codeAttr = inline_styles ? getAttr('code') : langClass;
+                    const langAttr = bidirectional && block.lang ? ` data-qd-lang="${escapeHtml(block.lang)}"` : '';
+                    const fenceAttr = bidirectional ? ` data-qd-fence="${escapeHtml(block.fence)}"` : '';
+                    replacement = `<pre${getAttr('pre')}${fenceAttr}${langAttr}><code${codeAttr}>${escapeHtml(block.code)}</code></pre>`;
+                } else if (bidirectional) {
+                    // If bidirectional and plugin provided HTML, add data attributes for roundtrip
+                    replacement = replacement.replace(/^<(\w+)/, 
+                        `<$1 data-qd-fence="${escapeHtml(block.fence)}" data-qd-lang="${escapeHtml(block.lang)}" data-qd-source="${escapeHtml(block.code)}"`);
                 }
             } else {
-                replacement = `<pre${getAttr('pre', '', block.fence)} data-qd-fence="${block.fence}" data-qd-lang="${block.lang}"><code>${block.code}</code></pre>`;
+                // Default rendering
+                const langClass = !inline_styles && block.lang ? ` class="language-${block.lang}"` : '';
+                const codeAttr = inline_styles ? getAttr('code') : langClass;
+                const langAttr = bidirectional && block.lang ? ` data-qd-lang="${escapeHtml(block.lang)}"` : '';
+                const fenceAttr = bidirectional ? ` data-qd-fence="${escapeHtml(block.fence)}"` : '';
+                replacement = `<pre${getAttr('pre')}${fenceAttr}${langAttr}><code${codeAttr}>${block.code}</code></pre>`;
             }
             
+            const placeholder = `${PLACEHOLDER_CB}${i}§`;
             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>`);
+        // Restore inline code
+        inlineCodes.forEach((code, i) => {
+            const placeholder = `${PLACEHOLDER_IC}${i}§`;
+            html = html.replace(placeholder, `<code${getAttr('code')}${dataQd('`')}>${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 = [];
+    /**
+     * Process inline markdown formatting
+     */
+    function processInlineMarkdown(text, getAttr) {
         
-        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);
-            }
-        }
+        // Process inline formatting patterns
+        const patterns = [
+            [/\*\*(.+?)\*\*/g, 'strong'],
+            [/__(.+?)__/g, 'strong'],
+            [/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, 'em'],
+            [/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, 'em'],
+            [/~~(.+?)~~/g, 'del'],
+            [/`([^`]+)`/g, 'code']
+        ];
         
-        // Close remaining lists
-        while (listStack.length > 0) {
-            const list = listStack.pop();
-            result.push(`</${list.type}>`);
-        }
+        patterns.forEach(([pattern, tag]) => {
+            text = text.replace(pattern, `<${tag}${getAttr(tag)}>$1</${tag}>`);
+        });
         
-        return result.join('\n');
+        return text;
     }
 
-    // Process tables with source tracking
-    function processTablesBD(text, getAttr) {
+    /**
+     * Process markdown tables
+     */
+    function processTable(text, getAttr) {
         const lines = text.split('\n');
         const result = [];
         let inTable = false;
@@ -284,18 +392,22 @@
         for (let i = 0; i < lines.length; i++) {
             const line = lines[i].trim();
             
-            if (line.includes('|')) {
+            // Check if this line looks like a table row (with or without trailing |)
+            if (line.includes('|') && (line.startsWith('|') || /[^\\|]/.test(line))) {
                 if (!inTable) {
                     inTable = true;
                     tableLines = [];
                 }
                 tableLines.push(line);
             } else {
+                // Not a table line
                 if (inTable) {
-                    const tableHtml = buildTableBD(tableLines, getAttr);
+                    // Process the accumulated table
+                    const tableHtml = buildTable(tableLines, getAttr);
                     if (tableHtml) {
                         result.push(tableHtml);
                     } else {
+                        // Not a valid table, restore original lines
                         result.push(...tableLines);
                     }
                     inTable = false;
@@ -305,8 +417,9 @@
             }
         }
         
+        // Handle table at end of text
         if (inTable && tableLines.length > 0) {
-            const tableHtml = buildTableBD(tableLines, getAttr);
+            const tableHtml = buildTable(tableLines, getAttr);
             if (tableHtml) {
                 result.push(tableHtml);
             } else {
@@ -317,53 +430,68 @@
         return result.join('\n');
     }
 
-    // Build table with source tracking
-    function buildTableBD(lines, getAttr) {
+    /**
+     * Build an HTML table from markdown table lines
+     */
+    function buildTable(lines, getAttr) {
+        
         if (lines.length < 2) return null;
         
-        // Find separator
+        // Check for separator line (second line should be the separator)
         let separatorIndex = -1;
-        let alignments = [];
-        
         for (let i = 1; i < lines.length; i++) {
+            // Support separator with or without leading/trailing pipes
             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`;
+        const headerLines = lines.slice(0, separatorIndex);
+        const bodyLines = lines.slice(separatorIndex + 1);
         
-        // 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';
-        }
+        // Parse alignment from separator
+        const separator = lines[separatorIndex];
+        // Handle pipes at start/end or not
+        const separatorCells = separator.trim().replace(/^\|/, '').replace(/\|$/, '').split('|');
+        const alignments = separatorCells.map(cell => {
+            const trimmed = cell.trim();
+            if (trimmed.startsWith(':') && trimmed.endsWith(':')) return 'center';
+            if (trimmed.endsWith(':')) return 'right';
+            return 'left';
+        });
         
-        // Body
-        const bodyLines = lines.slice(separatorIndex + 1);
+        let html = `<table${getAttr('table')}>\n`;
+        
+        // Build header
+        // Note: headerLines will always have length > 0 since separatorIndex starts from 1
+        html += `<thead${getAttr('thead')}>\n`;
+        headerLines.forEach(line => {
+                html += `<tr${getAttr('tr')}>\n`;
+                // Handle pipes at start/end or not
+                const cells = line.trim().replace(/^\|/, '').replace(/\|$/, '').split('|');
+                cells.forEach((cell, i) => {
+                    const alignStyle = alignments[i] && alignments[i] !== 'left' ? `text-align:${alignments[i]}` : '';
+                    const processedCell = processInlineMarkdown(cell.trim(), getAttr);
+                    html += `<th${getAttr('th', alignStyle)}>${processedCell}</th>\n`;
+                });
+                html += '</tr>\n';
+        });
+        html += '</thead>\n';
+        
+        // Build body
         if (bodyLines.length > 0) {
-            html += `<tbody${getAttr('tbody', '', '|')}>\n`;
+            html += `<tbody${getAttr('tbody')}>\n`;
             bodyLines.forEach(line => {
-                html += `<tr${getAttr('tr', '', '|')}>\n`;
-                const cells = line.replace(/^\|/, '').replace(/\|$/, '').split('|');
+                html += `<tr${getAttr('tr')}>\n`;
+                // Handle pipes at start/end or not
+                const cells = line.trim().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`;
+                    const alignStyle = alignments[i] && alignments[i] !== 'left' ? `text-align:${alignments[i]}` : '';
+                    const processedCell = processInlineMarkdown(cell.trim(), getAttr);
+                    html += `<td${getAttr('td', alignStyle)}>${processedCell}</td>\n`;
                 });
                 html += '</tr>\n';
             });
@@ -375,17 +503,201 @@
     }
 
     /**
-     * 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
+     * Process markdown lists (ordered and unordered)
+     */
+    function processLists(text, getAttr, inline_styles, bidirectional) {
+        
+        const lines = text.split('\n');
+        const result = [];
+        let listStack = []; // Track nested lists
+        
+        // Helper to escape HTML for data-qd attributes
+        const escapeHtml = (text) => text.replace(/[&<>"']/g, m => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'})[m]);
+        const dataQd = bidirectional ? (marker) => ` data-qd="${escapeHtml(marker)}"` : () => '';
+        
+        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';
+                
+                // Check for task list items
+                let listItemContent = content;
+                let taskListClass = '';
+                const taskMatch = content.match(/^\[([x ])\]\s+(.*)$/i);
+                if (taskMatch && !isOrdered) {
+                    const [, checked, taskContent] = taskMatch;
+                    const isChecked = checked.toLowerCase() === 'x';
+                    const checkboxAttr = inline_styles 
+                        ? ' style="margin-right:.5em"' 
+                        : ` class="${CLASS_PREFIX}task-checkbox"`;
+                    listItemContent = `<input type="checkbox"${checkboxAttr}${isChecked ? ' checked' : ''} disabled> ${taskContent}`;
+                    taskListClass = inline_styles ? ' style="list-style:none"' : ` class="${CLASS_PREFIX}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) {
+                    // Need to open a new list
+                    listStack.push({ type: listType, level });
+                    result.push(`<${listType}${getAttr(listType)}>`);
+                } else if (listStack.length === level + 1) {
+                    // Check if we need to switch list type
+                    const currentList = listStack[listStack.length - 1];
+                    if (currentList.type !== listType) {
+                        result.push(`</${currentList.type}>`);
+                        listStack.pop();
+                        listStack.push({ type: listType, level });
+                        result.push(`<${listType}${getAttr(listType)}>`);
+                    }
+                }
+                
+                const liAttr = taskListClass || getAttr('li');
+                result.push(`<li${liAttr}${dataQd(marker)}>${listItemContent}</li>`);
+            } else {
+                // Not a list item, close all lists
+                while (listStack.length > 0) {
+                    const list = listStack.pop();
+                    result.push(`</${list.type}>`);
+                }
+                result.push(line);
+            }
+        }
+        
+        // Close any remaining lists
+        while (listStack.length > 0) {
+            const list = listStack.pop();
+            result.push(`</${list.type}>`);
+        }
+        
+        return result.join('\n');
+    }
+
+    /**
+     * Emit CSS styles for quikdown elements
+     * @param {string} prefix - Optional class prefix (default: 'quikdown-')
+     * @param {string} theme - Optional theme: 'light' (default) or 'dark'
+     * @returns {string} CSS string with quikdown styles
      */
-    quikdown_bd.toMarkdown = function(htmlOrElement) {
+    quikdown.emitStyles = function(prefix = 'quikdown-', theme = 'light') {
+        const styles = QUIKDOWN_STYLES;
+        
+        // Define theme color overrides
+        const themeOverrides = {
+            dark: {
+                '#f4f4f4': '#2a2a2a', // pre background
+                '#f0f0f0': '#2a2a2a', // code background
+                '#f2f2f2': '#2a2a2a', // th background
+                '#ddd': '#3a3a3a',    // borders
+                '#06c': '#6db3f2',    // links
+                _textColor: '#e0e0e0'
+            },
+            light: {
+                _textColor: '#333'    // Explicit text color for light theme
+            }
+        };
+        
+        let css = '';
+        for (const [tag, style] of Object.entries(styles)) {
+            let themedStyle = style;
+                
+                // Apply theme overrides if dark theme
+                if (theme === 'dark' && themeOverrides.dark) {
+                    // Replace colors
+                    for (const [oldColor, newColor] of Object.entries(themeOverrides.dark)) {
+                        if (!oldColor.startsWith('_')) {
+                            themedStyle = themedStyle.replace(new RegExp(oldColor, 'g'), newColor);
+                        }
+                    }
+                    
+                    // Add text color for certain elements in dark theme
+                    const needsTextColor = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'td', 'li', 'blockquote'];
+                    if (needsTextColor.includes(tag)) {
+                        themedStyle += `;color:${themeOverrides.dark._textColor}`;
+                    }
+                } else if (theme === 'light' && themeOverrides.light) {
+                    // Add explicit text color for light theme elements too
+                    const needsTextColor = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'td', 'li', 'blockquote'];
+                    if (needsTextColor.includes(tag)) {
+                        themedStyle += `;color:${themeOverrides.light._textColor}`;
+                    }
+                }
+            
+            css += `.${prefix}${tag} { ${themedStyle} }\n`;
+        }
+        
+        return css;
+    };
+
+    /**
+     * Configure quikdown with options and return a function
+     * @param {Object} options - Configuration options
+     * @returns {Function} Configured quikdown function
+     */
+    quikdown.configure = function(options) {
+        return function(markdown) {
+            return quikdown(markdown, options);
+        };
+    };
+
+    /**
+     * Version information
+     */
+    quikdown.version = quikdownVersion;
+
+    // Export for both CommonJS and ES6
+    /* istanbul ignore next */
+    if (typeof module !== 'undefined' && module.exports) {
+        module.exports = quikdown;
+    }
+
+    // For browser global
+    /* istanbul ignore next */
+    if (typeof window !== 'undefined') {
+        window.quikdown = quikdown;
+    }
+
+    /**
+     * quikdown_bd - Bidirectional markdown/HTML converter
+     * Extends core quikdown with HTML→Markdown conversion
+     * 
+     * Uses data-qd attributes to preserve original markdown syntax
+     * Enables HTML→Markdown conversion for quikdown-generated HTML
+     */
+
+
+    /**
+     * Create bidirectional version by extending quikdown
+     * This wraps quikdown and adds the toMarkdown method
+     */
+    function quikdown_bd(markdown, options = {}) {
+        // Use core quikdown with bidirectional flag to add data-qd attributes
+        return quikdown(markdown, { ...options, bidirectional: true });
+    }
+
+    // Copy all properties and methods from quikdown (including version)
+    Object.keys(quikdown).forEach(key => {
+        quikdown_bd[key] = quikdown[key];
+    });
+
+    // Add the toMarkdown method for HTML→Markdown conversion
+    quikdown_bd.toMarkdown = function(htmlOrElement, options = {}) {
         // 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) {
+            /* istanbul ignore next - browser-only code path, not testable in jsdom */
             container = htmlOrElement;
         } else {
             return '';
@@ -404,7 +716,6 @@
             
             const tag = node.tagName.toLowerCase();
             const dataQd = node.getAttribute('data-qd');
-            const styles = window.getComputedStyle ? window.getComputedStyle(node) : {};
             
             // Process children with context
             let childContent = '';
@@ -426,40 +737,55 @@
                     
                 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;
+                    if (!childContent) return ''; // Don't add markers for empty content
+                    const boldMarker = dataQd || '**';
+                    return `${boldMarker}${childContent}${boldMarker}`;
                     
                 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;
+                    if (!childContent) return ''; // Don't add markers for empty content
+                    const emMarker = dataQd || '*';
+                    return `${emMarker}${childContent}${emMarker}`;
                     
                 case 'del':
                 case 's':
                 case 'strike':
+                    if (!childContent) return ''; // Don't add markers for empty content
                     const delMarker = dataQd || '~~';
                     return `${delMarker}${childContent}${delMarker}`;
                     
                 case 'code':
-                    // Skip if inside pre (handled by pre)
-                    if (parentContext.parentTag === 'pre') {
-                        return childContent;
-                    }
+                    // Note: code inside pre is handled directly by the pre case using querySelector
+                    if (!childContent) return ''; // Don't add markers for empty content
                     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
+                    
+                    // Check if this was created by a fence plugin with reverse handler
+                    if (options.fence_plugin && options.fence_plugin.reverse && lang) {
+                        try {
+                            const result = options.fence_plugin.reverse(node);
+                            if (result && result.content) {
+                                const fenceMarker = result.fence || fence;
+                                const langStr = result.lang || lang;
+                                return `${fenceMarker}${langStr}\n${result.content}\n${fenceMarker}\n\n`;
+                            }
+                        } catch (err) {
+                            console.warn('Fence reverse handler error:', err);
+                            // Fall through to default handling
+                        }
+                    }
+                    
+                    // Fallback: use data-qd-source if available
+                    const source = node.getAttribute('data-qd-source');
+                    if (source) {
+                        return `${fence}${lang}\n${source}\n${fence}\n\n`;
+                    }
+                    
+                    // Final fallback: extract text content
                     const codeEl = node.querySelector('code');
                     const codeContent = codeEl ? codeEl.textContent : childContent;
                     return `${fence}${lang}\n${codeContent.trimEnd()}\n${fence}\n\n`;
@@ -506,16 +832,87 @@
                 case 'p':
                     // Check if it's actually a paragraph or just a wrapper
                     if (childContent.trim()) {
-                        return childContent.trim() + '\n\n';
+                        // Check if paragraph ends with a line that's just whitespace
+                        // This indicates an intentional blank line before the next element
+                        const lines = childContent.split('\n');
+                        let content = childContent.trim();
+                        
+                        // If the last line(s) are just whitespace, preserve one blank line
+                        if (lines.length > 1) {
+                            let trailingBlankLines = 0;
+                            for (let i = lines.length - 1; i >= 0; i--) {
+                                if (lines[i].trim() === '') {
+                                    trailingBlankLines++;
+                                } else {
+                                    break;
+                                }
+                            }
+                            if (trailingBlankLines > 0) {
+                                // Add a line with just a space, followed by single newline
+                                // The \n\n will be added below for paragraph separation
+                                content = content + '\n ';
+                                // Only add one newline since we're preserving the space line
+                                return content + '\n';
+                            }
+                        }
+                        
+                        return content + '\n\n';
                     }
                     return '';
                     
                 case 'div':
+                    // Check if this was created by a fence plugin with reverse handler
+                    const divLang = node.getAttribute('data-qd-lang');
+                    const divFence = node.getAttribute('data-qd-fence');
+                    
+                    if (divLang && options.fence_plugin && options.fence_plugin.reverse) {
+                        try {
+                            const result = options.fence_plugin.reverse(node);
+                            if (result && result.content) {
+                                const fenceMarker = result.fence || divFence || '```';
+                                const langStr = result.lang || divLang;
+                                return `${fenceMarker}${langStr}\n${result.content}\n${fenceMarker}\n\n`;
+                            }
+                        } catch (err) {
+                            console.warn('Fence reverse handler error:', err);
+                            // Fall through to default handling
+                        }
+                    }
+                    
+                    // Fallback: use data-qd-source if available
+                    const divSource = node.getAttribute('data-qd-source');
+                    if (divSource && divFence) {
+                        return `${divFence}${divLang || ''}\n${divSource}\n${divFence}\n\n`;
+                    }
+                    
                     // 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
+                        
+                        // First check for data-qd-source attribute on the container
+                        const source = node.getAttribute('data-qd-source');
+                        if (source) {
+                            // Decode HTML entities from the attribute (mainly &quot;)
+                            const temp = document.createElement('textarea');
+                            temp.innerHTML = source;
+                            const code = temp.value;
+                            return `${fence}${lang}\n${code}\n${fence}\n\n`;
+                        }
+                        
+                        // Check for source on the pre.mermaid element
+                        const mermaidPre = node.querySelector('pre.mermaid');
+                        if (mermaidPre) {
+                            const preSource = mermaidPre.getAttribute('data-qd-source');
+                            if (preSource) {
+                                const temp = document.createElement('textarea');
+                                temp.innerHTML = preSource;
+                                const code = temp.value;
+                                return `${fence}${lang}\n${code}\n${fence}\n\n`;
+                            }
+                        }
+                        
+                        // Fallback: Look for the legacy .mermaid-source element
                         const sourceElement = node.querySelector('.mermaid-source');
                         if (sourceElement) {
                             // Decode HTML entities
@@ -524,7 +921,8 @@
                             const code = temp.textContent;
                             return `${fence}${lang}\n${code}\n${fence}\n\n`;
                         }
-                        // Fallback: try to extract from the mermaid element
+                        
+                        // Final fallback: try to extract from the mermaid element (unreliable after rendering)
                         const mermaidElement = node.querySelector('.mermaid');
                         if (mermaidElement && mermaidElement.textContent.includes('graph')) {
                             return `${fence}${lang}\n${mermaidElement.textContent.trim()}\n${fence}\n\n`;
@@ -615,7 +1013,7 @@
                     
                     // Add separator with alignment
                     const separators = headers.map((_, i) => {
-                        const align = alignments[i] || th.getAttribute('data-qd-align') || 'left';
+                        const align = alignments[i] || 'left';
                         if (align === 'center') return ':---:';
                         if (align === 'right') return '---:';
                         return '---';
@@ -651,29 +1049,23 @@
         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
+    // Override the configure method to return a bidirectional version
     quikdown_bd.configure = function(options) {
         return function(markdown) {
             return quikdown_bd(markdown, options);
         };
     };
 
-    // Version property
-    quikdown_bd.version = VERSION;
+    // Set version
+    // Version is already copied from quikdown via Object.keys loop
 
     // Export for both module and browser
+    /* istanbul ignore next */
     if (typeof module !== 'undefined' && module.exports) {
         module.exports = quikdown_bd;
     }
 
+    /* istanbul ignore next */
     if (typeof window !== 'undefined') {
         window.quikdown_bd = quikdown_bd;
     }