bitwrench 1.2.16 → 2.0.7

package/src/vendor/quikdown.js

@@ -0,0 +1,654 @@
+/**
+ * Vendored: quikdown v1.2.0
+ * Lightweight Markdown Parser - https://github.com/deftio/quikdown
+ * @license BSD-2-Clause
+ * @copyright DeftIO 2025
+ *
+ * DO NOT EDIT - This file is vendored from the quikdown project.
+ * Update by copying from quikdown/dist/quikdown.esm.js
+ */
+/**
+ * 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 will be injected at build time
+const quikdownVersion = '1.2.0';
+
+// Constants for reuse
+const CLASS_PREFIX = 'quikdown-';
+const PLACEHOLDER_CB = '\u00a7CB';
+const PLACEHOLDER_IC = '\u00a7IC';
+
+// Escape map at module level
+const ESC_MAP = {'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'};
+
+// 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) {
+            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 {
+            const classAttr = ` class="${CLASS_PREFIX}${tag}"`;
+            // Apply inline styles for alignment even when using CSS classes
+            if (additionalStyle) {
+                return `${classAttr} style="${additionalStyle}"`;
+            }
+            return classAttr;
+        }
+    };
+}
+
+function quikdown(markdown, options = {}) {
+    if (!markdown || typeof markdown !== 'string') {
+        return '';
+    }
+
+    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]);
+    }
+
+    // Helper to add data-qd attributes for bidirectional support
+    const dataQd = bidirectional ? (marker) => ` data-qd="${escapeHtml(marker)}"` : () => '';
+
+    // 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 and inline code
+    const codeBlocks = [];
+    const inlineCodes = [];
+
+    // 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 = `${PLACEHOLDER_CB}${codeBlocks.length}\u00a7`;
+
+        // 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 = `${PLACEHOLDER_IC}${inlineCodes.length}\u00a7`;
+        inlineCodes.push(escapeHtml(code));
+        return placeholder;
+    });
+
+    // Now escape HTML in the rest of the content
+    html = escapeHtml(html);
+
+    // 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;
+        return `<h${level}${getAttr('h' + level)}${dataQd(hashes)}>${content}</h${level}>`;
+    });
+
+    // 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 horizontal rules (allow trailing spaces)
+    html = html.replace(/^---+\s*$/gm, `<hr${getAttr('hr')}>`);
+
+    // Process lists
+    html = processLists(html, getAttr, inline_styles, bidirectional);
+
+    // Phase 3: Process inline elements
+
+    // Images (must come before links, with URL sanitization)
+    html = html.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (match, alt, 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) => {
+        // 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>`;
+    });
+
+    // 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>`;
+    });
+
+    // Process inline formatting (bold, italic, strikethrough)
+    const inlinePatterns = [
+        [/\*\*(.+?)\*\*/g, 'strong', '**'],
+        [/__(.+?)__/g, 'strong', '__'],
+        [/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, 'em', '*'],
+        [/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, 'em', '_'],
+        [/~~(.+?)~~/g, 'del', '~~']
+    ];
+
+    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 `\u00a7B${bi++}\u00a7`;
+        });
+
+        // Handle paragraphs and block elements
+        html = html.replace(/\n\n+/g, '\u00a7P\u00a7')
+            // After block elements
+            .replace(/(<\/(?:h[1-6]|blockquote|pre)>)\n/g, '$1\u00a7N\u00a7')
+            .replace(/(<(?:h[1-6]|blockquote|pre|hr)[^>]*>)\n/g, '$1\u00a7N\u00a7')
+            // Before block elements
+            .replace(/\n(<(?:h[1-6]|blockquote|pre|hr)[^>]*>)/g, '\u00a7N\u00a7$1')
+            .replace(/\n(\u00a7B\d+\u00a7)/g, '\u00a7N\u00a7$1')
+            .replace(/(\u00a7B\d+\u00a7)\n/g, '$1\u00a7N\u00a7')
+            // Convert remaining newlines
+            .replace(/\n/g, `<br${getAttr('br')}>`)
+            // Restore
+            .replace(/\u00a7N\u00a7/g, '\n')
+            .replace(/\u00a7P\u00a7/g, '</p><p>');
+
+        // Restore protected blocks
+        blocks.forEach((b, i) => html = html.replace(`\u00a7B${i}\u00a7`, 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
+    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+\u00a7)<\/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) => {
+        let replacement;
+
+        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) {
+                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 {
+            // 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}\u00a7`;
+        html = html.replace(placeholder, replacement);
+    });
+
+    // Restore inline code
+    inlineCodes.forEach((code, i) => {
+        const placeholder = `${PLACEHOLDER_IC}${i}\u00a7`;
+        html = html.replace(placeholder, `<code${getAttr('code')}${dataQd('`')}>${code}</code>`);
+    });
+
+    return html.trim();
+}
+
+/**
+ * Process inline markdown formatting
+ */
+function processInlineMarkdown(text, getAttr) {
+
+    // Process inline formatting patterns
+    const patterns = [
+        [/\*\*(.+?)\*\*/g, 'strong'],
+        [/__(.+?)__/g, 'strong'],
+        [/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, 'em'],
+        [/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, 'em'],
+        [/~~(.+?)~~/g, 'del'],
+        [/`([^`]+)`/g, 'code']
+    ];
+
+    patterns.forEach(([pattern, tag]) => {
+        text = text.replace(pattern, `<${tag}${getAttr(tag)}>$1</${tag}>`);
+    });
+
+    return text;
+}
+
+/**
+ * Process markdown tables
+ */
+function processTable(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();
+
+        // 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) {
+                // 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;
+                tableLines = [];
+            }
+            result.push(lines[i]);
+        }
+    }
+
+    // Handle table at end of text
+    if (inTable && tableLines.length > 0) {
+        const tableHtml = buildTable(tableLines, getAttr);
+        if (tableHtml) {
+            result.push(tableHtml);
+        } else {
+            result.push(...tableLines);
+        }
+    }
+
+    return result.join('\n');
+}
+
+/**
+ * Build an HTML table from markdown table lines
+ */
+function buildTable(lines, getAttr) {
+
+    if (lines.length < 2) return null;
+
+    // Check for separator line (second line should be the separator)
+    let separatorIndex = -1;
+    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;
+            break;
+        }
+    }
+
+    if (separatorIndex === -1) return null;
+
+    const headerLines = lines.slice(0, separatorIndex);
+    const bodyLines = lines.slice(separatorIndex + 1);
+
+    // 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';
+    });
+
+    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`;
+        bodyLines.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 += `<td${getAttr('td', alignStyle)}>${processedCell}</td>\n`;
+            });
+            html += '</tr>\n';
+        });
+        html += '</tbody>\n';
+    }
+
+    html += '</table>';
+    return html;
+}
+
+/**
+ * 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.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 { quikdown as default };

package/src/version.js

@@ -0,0 +1,16 @@
+/**
+ * Auto-generated version file from package.json
+ * DO NOT EDIT DIRECTLY - Use npm run generate-version
+ */
+
+export const VERSION = '2.0.7';
+export const VERSION_INFO = {
+  version: '2.0.7',
+  name: 'bitwrench',
+  description: 'A library for javascript UI functions.',
+  license: 'BSD-2-Clause',
+  homepage: 'http://deftio.com/bitwrench',
+  repository: 'git+https://github.com/deftio/bitwrench.git',
+  author: 'manu a. chatterjee <deftio@deftio.com> (https://deftio.com/)',
+  buildDate: '2026-03-06T09:27:27.033Z'
+};