quikdown 1.0.1 → 1.0.3

package/dist/quikdown.cjs

@@ -1,16 +1,11 @@
 /**
  * quikdown - Lightweight Markdown Parser
- * @version 1.0.1
+ * @version 1.0.3
  * @license BSD-2-Clause
  * @copyright DeftIO 2025
  */
 'use strict';
 
-// Auto-generated version file - DO NOT EDIT MANUALLY
-// This file is automatically updated by tools/updateVersion.js
-
-const quikdownVersion = "1.0.1";
-
 /**
  * quikdown - A minimal markdown parser optimized for chat/LLM output
  * Supports tables, code blocks, lists, and common formatting
@@ -22,68 +17,71 @@ const quikdownVersion = "1.0.1";
  * @returns {string} - The rendered HTML
  */
 
+// Version will be injected at build time  
+const quikdownVersion = '1.0.3';
 
-function quikdown(markdown, options = {}) {
-    if (!markdown || typeof markdown !== 'string') {
-        return '';
-    }
-    
-    const { fence_plugin, inline_styles = false } = options;
+// Constants for reuse
+const CLASS_PREFIX = 'quikdown-';
+const PLACEHOLDER_CB = '§CB';
+const PLACEHOLDER_IC = '§IC';
 
-    // Style definitions - deduplicated to save space
-    const headingStyle = 'margin-top: 0.5em; margin-bottom: 0.3em';
-    const listStyle = 'margin: 0.5em 0; padding-left: 2em';
-    const cellBorder = 'border: 1px solid #ddd; padding: 8px';
-    
-    const styles = {
-        h1: headingStyle,
-        h2: headingStyle,
-        h3: headingStyle,
-        h4: headingStyle,
-        h5: headingStyle,
-        h6: headingStyle,
-        pre: 'background: #f4f4f4; padding: 10px; border-radius: 4px; overflow-x: auto',
-        code: 'background: #f0f0f0; padding: 2px 4px; border-radius: 3px',
-        blockquote: 'border-left: 4px solid #ddd; margin-left: 0; padding-left: 1em; color: #666',
-        table: 'border-collapse: collapse; width: 100%; margin: 1em 0',
-        thead: '',
-        tbody: '',
-        tr: '',
-        th: cellBorder + '; background-color: #f2f2f2; font-weight: bold',
-        td: cellBorder + '; text-align: left',
-        hr: 'border: none; border-top: 1px solid #ddd; margin: 1em 0',
-        img: 'max-width: 100%; height: auto',
-        a: 'color: #0066cc; text-decoration: underline',
-        strong: 'font-weight: bold',
-        em: 'font-style: italic',
-        del: 'text-decoration: line-through',
-        ul: listStyle,
-        ol: listStyle,
-        li: 'margin: 0.25em 0',
-        br: ''
-    };
+// Escape map at module level
+const ESC_MAP = {'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'};
 
-    // Helper to get class or style attribute
-    function getAttr(tag, additionalStyle = '') {
+// 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] || '';
-            const fullStyle = additionalStyle ? `${style}; ${additionalStyle}` : style;
-            return fullStyle ? ` style="${fullStyle}"` : '';
+            const style = styles[tag];
+            if (!style && !additionalStyle) return '';
+            const fullStyle = additionalStyle ? (style ? `${style};${additionalStyle}` : additionalStyle) : style;
+            return ` style="${fullStyle}"`;
         } else {
-            return ` class="quikdown-${tag}"`;
+            return ` class="${CLASS_PREFIX}${tag}"`;
         }
+    };
+}
+
+function quikdown(markdown, options = {}) {
+    if (!markdown || typeof markdown !== 'string') {
+        return '';
     }
+    
+    const { fence_plugin, inline_styles = 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) {
-        const map = {
-            '&': '&amp;',
-            '<': '&lt;',
-            '>': '&gt;',
-            '"': '&quot;',
-            "'": '&#39;'
-        };
-        return text.replace(/[&<>"']/g, m => map[m]);
+        return text.replace(/[&<>"']/g, m => ESC_MAP[m]);
     }
     
     // Sanitize URLs to prevent XSS attacks
@@ -93,7 +91,6 @@ function quikdown(markdown, options = {}) {
         // If unsafe URLs are explicitly allowed, return as-is
         if (allowUnsafe) return url;
         
-        // Trim and lowercase for checking
         const trimmedUrl = url.trim();
         const lowerUrl = trimmedUrl.toLowerCase();
         
@@ -122,19 +119,24 @@ function quikdown(markdown, options = {}) {
     const inlineCodes = [];
     
     // Extract fenced code blocks first (supports both ``` and ~~~)
-    html = html.replace(/(?:```|~~~)([^\n]*)\n([\s\S]*?)(?:```|~~~)/g, (match, lang, code) => {
-        const placeholder = `%%%CODEBLOCK${codeBlocks.length}%%%`;
+    // 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}§`;
+        
+        // Trim the language specification
+        const langTrimmed = lang ? lang.trim() : '';
         
         // If custom fence plugin is provided, use it
         if (fence_plugin && typeof fence_plugin === 'function') {
             codeBlocks.push({
-                lang: lang || '',
+                lang: langTrimmed,
                 code: code.trimEnd(),
                 custom: true
             });
         } else {
             codeBlocks.push({
-                lang: lang || '',
+                lang: langTrimmed,
                 code: escapeHtml(code.trimEnd()),
                 custom: false
             });
@@ -144,7 +146,7 @@ function quikdown(markdown, options = {}) {
     
     // Extract inline code
     html = html.replace(/`([^`]+)`/g, (match, code) => {
-        const placeholder = `%%%INLINECODE${inlineCodes.length}%%%`;
+        const placeholder = `${PLACEHOLDER_IC}${inlineCodes.length}§`;
         inlineCodes.push(escapeHtml(code));
         return placeholder;
     });
@@ -155,7 +157,7 @@ function quikdown(markdown, options = {}) {
     // Phase 2: Process block elements
     
     // Process tables
-    html = processTable(html, inline_styles, styles);
+    html = processTable(html, getAttr);
     
     // Process headings (supports optional trailing #'s)
     html = html.replace(/^(#{1,6})\s+(.+?)\s*#*$/gm, (match, hashes, content) => {
@@ -172,7 +174,7 @@ function quikdown(markdown, options = {}) {
     html = html.replace(/^---+$/gm, `<hr${getAttr('hr')}>`);
     
     // Process lists
-    html = processLists(html, inline_styles, styles);
+    html = processLists(html, getAttr, inline_styles);
     
     // Phase 3: Process inline elements
     
@@ -197,16 +199,18 @@ function quikdown(markdown, options = {}) {
         return `${prefix}<a${getAttr('a')} href="${sanitizedUrl}" rel="noopener noreferrer">${url}</a>`;
     });
     
-    // Bold (must use non-greedy matching)
-    html = html.replace(/\*\*(.+?)\*\*/g, `<strong${getAttr('strong')}>$1</strong>`);
-    html = html.replace(/__(.+?)__/g, `<strong${getAttr('strong')}>$1</strong>`);
-    
-    // Italic (must not match bold markers)
-    html = html.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, `<em${getAttr('em')}>$1</em>`);
-    html = html.replace(/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, `<em${getAttr('em')}>$1</em>`);
-    
-    // Strikethrough
-    html = html.replace(/~~(.+?)~~/g, `<del${getAttr('del')}>$1</del>`);
+    // Process inline formatting (bold, italic, strikethrough)
+    const inlinePatterns = [
+        [/\*\*(.+?)\*\*/g, 'strong'],
+        [/__(.+?)__/g, 'strong'],
+        [/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, 'em'],
+        [/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, 'em'],
+        [/~~(.+?)~~/g, 'del']
+    ];
+    
+    inlinePatterns.forEach(([pattern, tag]) => {
+        html = html.replace(pattern, `<${tag}${getAttr(tag)}>$1</${tag}>`);
+    });
     
     // Line breaks (two spaces at end of line)
     html = html.replace(/  $/gm, `<br${getAttr('br')}>`);
@@ -215,21 +219,26 @@ function quikdown(markdown, options = {}) {
     html = html.replace(/\n\n+/g, '</p><p>');
     html = '<p>' + html + '</p>';
     
-    // Clean up empty paragraphs and unwrap block elements (account for attributes)
-    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');
-    html = html.replace(/<p>(<pre[^>]*>)/g, '$1');
-    html = html.replace(/(<\/pre>)<\/p>/g, '$1');
-    // Also unwrap code block placeholders
-    html = html.replace(/<p>(%%%CODEBLOCK\d+%%%)<\/p>/g, '$1');
+    // 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+§)<\/p>`, 'g'), '$1']
+    ];
+    
+    cleanupPatterns.forEach(([pattern, replacement]) => {
+        html = html.replace(pattern, replacement);
+    });
     
     // Phase 4: Restore code blocks and inline code
     
@@ -253,13 +262,13 @@ function quikdown(markdown, options = {}) {
             replacement = `<pre${getAttr('pre')}><code${codeAttr}>${block.code}</code></pre>`;
         }
         
-        const placeholder = `%%%CODEBLOCK${i}%%%`;
+        const placeholder = `${PLACEHOLDER_CB}${i}§`;
         html = html.replace(placeholder, replacement);
     });
     
     // Restore inline code
     inlineCodes.forEach((code, i) => {
-        const placeholder = `%%%INLINECODE${i}%%%`;
+        const placeholder = `${PLACEHOLDER_IC}${i}§`;
         html = html.replace(placeholder, `<code${getAttr('code')}>${code}</code>`);
     });
     
@@ -269,31 +278,21 @@ function quikdown(markdown, options = {}) {
 /**
  * Process inline markdown formatting
  */
-function processInlineMarkdown(text, inline_styles, styles) {
-    // Helper to get attributes
-    function getAttr(tag, additionalStyle = '') {
-        if (inline_styles) {
-            const style = styles[tag] || '';
-            const fullStyle = additionalStyle ? `${style}; ${additionalStyle}` : style;
-            return fullStyle ? ` style="${fullStyle}"` : '';
-        } else {
-            return ` class="quikdown-${tag}"`;
-        }
-    }
-    
-    // Process bold
-    text = text.replace(/\*\*(.+?)\*\*/g, `<strong${getAttr('strong')}>$1</strong>`);
-    text = text.replace(/__(.+?)__/g, `<strong${getAttr('strong')}>$1</strong>`);
-    
-    // Process italic (must not match bold markers)
-    text = text.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, `<em${getAttr('em')}>$1</em>`);
-    text = text.replace(/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, `<em${getAttr('em')}>$1</em>`);
-    
-    // Process strikethrough
-    text = text.replace(/~~(.+?)~~/g, `<del${getAttr('del')}>$1</del>`);
-    
-    // Process inline code
-    text = text.replace(/`([^`]+)`/g, `<code${getAttr('code')}>$1</code>`);
+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;
 }
@@ -301,7 +300,7 @@ function processInlineMarkdown(text, inline_styles, styles) {
 /**
  * Process markdown tables
  */
-function processTable(text, inline_styles, styles) {
+function processTable(text, getAttr) {
     const lines = text.split('\n');
     const result = [];
     let inTable = false;
@@ -321,7 +320,7 @@ function processTable(text, inline_styles, styles) {
             // Not a table line
             if (inTable) {
                 // Process the accumulated table
-                const tableHtml = buildTable(tableLines, inline_styles, styles);
+                const tableHtml = buildTable(tableLines, getAttr);
                 if (tableHtml) {
                     result.push(tableHtml);
                 } else {
@@ -337,7 +336,7 @@ function processTable(text, inline_styles, styles) {
     
     // Handle table at end of text
     if (inTable && tableLines.length > 0) {
-        const tableHtml = buildTable(tableLines, inline_styles, styles);
+        const tableHtml = buildTable(tableLines, getAttr);
         if (tableHtml) {
             result.push(tableHtml);
         } else {
@@ -351,17 +350,7 @@ function processTable(text, inline_styles, styles) {
 /**
  * Build an HTML table from markdown table lines
  */
-function buildTable(lines, inline_styles, styles) {
-    // Helper to get attributes
-    function getAttr(tag, additionalStyle = '') {
-        if (inline_styles) {
-            const style = styles[tag] || '';
-            const fullStyle = additionalStyle ? `${style}; ${additionalStyle}` : style;
-            return fullStyle ? ` style="${fullStyle}"` : '';
-        } else {
-            return ` class="quikdown-${tag}"`;
-        }
-    }
+function buildTable(lines, getAttr) {
     
     if (lines.length < 2) return null;
     
@@ -401,8 +390,8 @@ function buildTable(lines, inline_styles, styles) {
             // 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(), inline_styles, styles);
+                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';
@@ -418,8 +407,8 @@ function buildTable(lines, inline_styles, styles) {
             // 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(), inline_styles, styles);
+                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';
@@ -434,17 +423,7 @@ function buildTable(lines, inline_styles, styles) {
 /**
  * Process markdown lists (ordered and unordered)
  */
-function processLists(text, inline_styles, styles) {
-    // Helper to get attributes
-    function getAttr(tag, additionalStyle = '') {
-        if (inline_styles) {
-            const style = styles[tag] || '';
-            const fullStyle = additionalStyle ? `${style}; ${additionalStyle}` : style;
-            return fullStyle ? ` style="${fullStyle}"` : '';
-        } else {
-            return ` class="quikdown-${tag}"`;
-        }
-    }
+function processLists(text, getAttr, inline_styles) {
     
     const lines = text.split('\n');
     const result = [];
@@ -468,10 +447,10 @@ function processLists(text, inline_styles, styles) {
                 const [, checked, taskContent] = taskMatch;
                 const isChecked = checked.toLowerCase() === 'x';
                 const checkboxAttr = inline_styles 
-                    ? ' style="margin-right: 0.5em"' 
-                    : ' class="quikdown-task-checkbox"';
+                    ? ' 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="quikdown-task-item"';
+                taskListClass = inline_styles ? ' style="list-style:none"' : ` class="${CLASS_PREFIX}task-item"`;
             }
             
             // Close deeper levels
@@ -519,39 +498,56 @@ function processLists(text, inline_styles, styles) {
 
 /**
  * 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() {
-    const styles = {
-        h1: 'margin-top: 0.5em; margin-bottom: 0.3em',
-        h2: 'margin-top: 0.5em; margin-bottom: 0.3em',
-        h3: 'margin-top: 0.5em; margin-bottom: 0.3em',
-        h4: 'margin-top: 0.5em; margin-bottom: 0.3em',
-        h5: 'margin-top: 0.5em; margin-bottom: 0.3em',
-        h6: 'margin-top: 0.5em; margin-bottom: 0.3em',
-        pre: 'background: #f4f4f4; padding: 10px; border-radius: 4px; overflow-x: auto',
-        code: 'background: #f0f0f0; padding: 2px 4px; border-radius: 3px',
-        blockquote: 'border-left: 4px solid #ddd; margin-left: 0; padding-left: 1em; color: #666',
-        table: 'border-collapse: collapse; width: 100%; margin: 1em 0',
-        th: 'border: 1px solid #ddd; padding: 8px; background-color: #f2f2f2; font-weight: bold',
-        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: #0066cc; text-decoration: underline',
-        strong: 'font-weight: bold',
-        em: 'font-style: italic',
-        del: 'text-decoration: line-through',
-        ul: 'margin: 0.5em 0; padding-left: 2em',
-        ol: 'margin: 0.5em 0; padding-left: 2em',
-        li: 'margin: 0.25em 0',
-        'task-item': 'list-style: none',
-        'task-checkbox': 'margin-right: 0.5em'
+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)) {
         if (style) {
-            css += `.quikdown-${tag} { ${style} }\n`;
+            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`;
         }
     }
     

package/dist/quikdown.d.ts

@@ -0,0 +1,70 @@
+/**
+ * quikdown - Lightweight Markdown Parser
+ * TypeScript definitions
+ */
+
+declare module 'quikdown' {
+  /**
+   * Options for configuring the quikdown parser
+   */
+  export interface QuikdownOptions {
+    /**
+     * Custom renderer for fenced code blocks.
+     * Return undefined to use default rendering.
+     * @param content - The code block content (unescaped)
+     * @param language - The language identifier (or empty string)
+     * @returns HTML string or undefined for default rendering
+     */
+    fence_plugin?: (content: string, language: string) => string | undefined;
+    
+    /**
+     * If true, uses inline styles instead of CSS classes.
+     * Useful for emails or environments without CSS support.
+     * @default false
+     */
+    inline_styles?: boolean;
+    
+    /**
+     * If true, allows potentially unsafe URLs (javascript:, data:, etc).
+     * Only use with trusted content.
+     * @default false
+     */
+    allow_unsafe_urls?: boolean;
+  }
+
+  /**
+   * Parse markdown to HTML
+   * @param markdown - The markdown source text
+   * @param options - Optional configuration
+   * @returns The rendered HTML string
+   */
+  function quikdown(markdown: string, options?: QuikdownOptions): string;
+
+  namespace quikdown {
+    /**
+     * Generate CSS styles for quikdown classes with theme support
+     * @param prefix - CSS class prefix (default: 'quikdown-')
+     * @param theme - Theme name: 'light' (default) or 'dark'
+     * @returns CSS string with themed .quikdown-* styles
+     */
+    export function emitStyles(prefix?: string, theme?: 'light' | 'dark'): string;
+    
+    /**
+     * Create a configured parser function with preset options
+     * @param options - Configuration to apply to all parsing
+     * @returns A parser function with the options pre-applied
+     */
+    export function configure(options: QuikdownOptions): (markdown: string) => string;
+    
+    /**
+     * The version of quikdown
+     */
+    export const version: string;
+  }
+
+  export = quikdown;
+}
+
+// For ES6 module imports
+export default quikdown;
+export { QuikdownOptions };