quikdown 1.1.1 → 1.2.3

package/dist/quikdown_edit.esm.js

@@ -1,6 +1,6 @@
 /**
  * Quikdown Editor - Drop-in Markdown Parser
- * @version 1.1.1
+ * @version 1.2.3
  * @license BSD-2-Clause
  * @copyright DeftIO 2025
  */
@@ -18,7 +18,7 @@
  */
 
 // Version will be injected at build time  
-const quikdownVersion = '1.1.1';
+const quikdownVersion = '1.2.3';
 
 // Constants for reuse
 const CLASS_PREFIX = 'quikdown-';
@@ -66,6 +66,11 @@ function createGetAttr(inline_styles, styles) {
             // 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();
+                // Ensure trailing semicolon before concatenating additionalStyle.
+                // Both short-circuit paths of this guard (empty `style` or
+                // already-has-`;`) are defensive and unreachable with the
+                // current QUIKDOWN_STYLES values — istanbul ignore next.
+                /* istanbul ignore next */
                 if (style && !style.endsWith(';')) style += ';';
             }
             
@@ -97,9 +102,12 @@ function quikdown(markdown, options = {}) {
         return text.replace(/[&<>"']/g, m => ESC_MAP[m]);
     }
     
-    // Helper to add data-qd attributes for bidirectional support
+    // Helper to add data-qd attributes for bidirectional support.
+    // The non-bidirectional branch is a trivial no-op arrow; it's exercised in
+    // the core bundle but never in quikdown_bd (which always sets bidirectional=true).
+    /* istanbul ignore next - trivial no-op fallback */
     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 */
@@ -268,7 +276,7 @@ function quikdown(markdown, options = {}) {
         html = '<p>' + html + '</p>';
     } else {
         // Standard: two spaces at end of line for line breaks
-        html = html.replace(/  $/gm, `<br${getAttr('br')}>`);
+        html = html.replace(/ {2}$/gm, `<br${getAttr('br')}>`);
         
         // Paragraphs (double newlines)
         // Don't add </p> after block elements (they're not in paragraphs)
@@ -297,7 +305,7 @@ function quikdown(markdown, options = {}) {
         [/(<\/table>)<\/p>/g, '$1'],
         [/<p>(<pre[^>]*>)/g, '$1'],
         [/(<\/pre>)<\/p>/g, '$1'],
-        [new RegExp(`<p>(${PLACEHOLDER_CB}\\d+§)<\/p>`, 'g'), '$1']
+        [new RegExp(`<p>(${PLACEHOLDER_CB}\\d+§)</p>`, 'g'), '$1']
     ];
     
     cleanupPatterns.forEach(([pattern, replacement]) => {
@@ -503,10 +511,15 @@ function processLists(text, getAttr, inline_styles, bidirectional) {
     
     const lines = text.split('\n');
     const result = [];
-    let listStack = []; // Track nested lists
+    const 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]);
+    // Helper to escape HTML for data-qd attributes. List markers (`-`, `*`,
+    // `+`, `1.`, etc.) never contain HTML-special chars, so the replace
+    // callback is defensive-only and never actually fires in practice.
+    const escapeHtml = (text) => text.replace(/[&<>"']/g,
+        /* istanbul ignore next - defensive: list markers never contain HTML specials */
+        m => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'})[m]);
+    /* istanbul ignore next - trivial no-op fallback; not exercised via bd bundle */
     const dataQd = bidirectional ? (marker) => ` data-qd="${escapeHtml(marker)}"` : () => '';
     
     for (let i = 0; i < lines.length; i++) {
@@ -678,8 +691,11 @@ function quikdown_bd(markdown, options = {}) {
     return quikdown(markdown, { ...options, bidirectional: true });
 }
 
-// Copy all properties and methods from quikdown (including version)
+// Copy all properties and methods from quikdown (including version).
+// Skip `configure` — quikdown_bd provides its own override below, so the
+// inner quikdown.configure is dead code in this bundle.
 Object.keys(quikdown).forEach(key => {
+    if (key === 'configure') return;
     quikdown_bd[key] = quikdown[key];
 });
 
@@ -713,7 +729,7 @@ quikdown_bd.toMarkdown = function(htmlOrElement, options = {}) {
         
         // Process children with context
         let childContent = '';
-        for (let child of node.childNodes) {
+        for (const child of node.childNodes) {
             childContent += walkNode(child, { parentTag: tag, ...parentContext });
         }
         
@@ -947,7 +963,7 @@ quikdown_bd.toMarkdown = function(htmlOrElement, options = {}) {
         let index = 1;
         const indent = '  '.repeat(depth);
         
-        for (let child of listNode.children) {
+        for (const child of listNode.children) {
             if (child.tagName !== 'LI') continue;
             
             const dataQd = child.getAttribute('data-qd');
@@ -960,7 +976,7 @@ quikdown_bd.toMarkdown = function(htmlOrElement, options = {}) {
                 marker = '-';
                 // Get text without the checkbox
                 let text = '';
-                for (let node of child.childNodes) {
+                for (const node of child.childNodes) {
                     if (node.nodeType === Node.TEXT_NODE) {
                         text += node.textContent;
                     } else if (node.tagName && node.tagName !== 'INPUT') {
@@ -971,7 +987,7 @@ quikdown_bd.toMarkdown = function(htmlOrElement, options = {}) {
             } else {
                 let itemContent = '';
                 
-                for (let node of child.childNodes) {
+                for (const node of child.childNodes) {
                     if (node.tagName === 'UL' || node.tagName === 'OL') {
                         itemContent += walkList(node, node.tagName === 'OL', depth + 1);
                     } else {
@@ -1000,7 +1016,7 @@ quikdown_bd.toMarkdown = function(htmlOrElement, options = {}) {
             const headerRow = thead.querySelector('tr');
             if (headerRow) {
                 const headers = [];
-                for (let th of headerRow.querySelectorAll('th')) {
+                for (const th of headerRow.querySelectorAll('th')) {
                     headers.push(th.textContent.trim());
                 }
                 result += '| ' + headers.join(' | ') + ' |\n';
@@ -1019,9 +1035,9 @@ quikdown_bd.toMarkdown = function(htmlOrElement, options = {}) {
         // Process body
         const tbody = table.querySelector('tbody');
         if (tbody) {
-            for (let row of tbody.querySelectorAll('tr')) {
+            for (const row of tbody.querySelectorAll('tr')) {
                 const cells = [];
-                for (let td of row.querySelectorAll('td')) {
+                for (const td of row.querySelectorAll('td')) {
                     cells.push(td.textContent.trim());
                 }
                 if (cells.length > 0) {
@@ -1043,10 +1059,13 @@ quikdown_bd.toMarkdown = function(htmlOrElement, options = {}) {
     return markdown;
 };
 
-// Override the configure method to return a bidirectional version
+// Override the configure method to return a bidirectional version.
+// We delegate to the inner quikdown.configure so the shared closure
+// machinery is exercised in both bundles (no dead code).
 quikdown_bd.configure = function(options) {
+    const innerParser = quikdown.configure({ ...options, bidirectional: true });
     return function(markdown) {
-        return quikdown_bd(markdown, options);
+        return innerParser(markdown);
     };
 };
 
@@ -1925,7 +1944,7 @@ async function getRenderedContent(previewPanel) {
                                 // First try baseVal.value (works for absolute units)
                                 width = svg.width.baseVal.value;
                                 height = svg.height.baseVal.value;
-                            } catch (e) {
+                            } catch (_e) {
                                 // Fallback for relative units - use viewBox or rendered size
                                 if (svg.viewBox && svg.viewBox.baseVal) {
                                     width = svg.viewBox.baseVal.width;
@@ -1944,8 +1963,8 @@ async function getRenderedContent(previewPanel) {
                             // Apply aggressive downsizing for MathJax SVGs
                             let scaleFactor = 0.04; // Further reduced for smaller output
                             
-                            let scaledWidth = width * scaleFactor;
-                            let scaledHeight = height * scaleFactor;
+                            const scaledWidth = width * scaleFactor;
+                            const scaledHeight = height * scaleFactor;
                             
                             // If still too large after base scaling, scale down further
                             if (scaledWidth > targetMaxWidth || scaledHeight > targetMaxHeight) {
@@ -2178,7 +2197,7 @@ async function getRenderedContent(previewPanel) {
                 let mapDataUrl = '';
                 try {
                     mapDataUrl = canvas.toDataURL('image/png', 1.0);
-                } catch (e) {
+                } catch (_e) {
                     console.warn('Map canvas tainted; falling back to placeholder');
                 }
 
@@ -2541,7 +2560,8 @@ async function getRenderedContent(previewPanel) {
 const DEFAULT_OPTIONS = {
     mode: 'split',          // 'source' | 'preview' | 'split'
     showToolbar: true,
-    showRemoveHR: false,    // Show button to remove horizontal rules (---) 
+    showRemoveHR: false,    // Show button to remove horizontal rules (---)
+    showLazyLinefeeds: false, // Show button to convert lazy linefeeds
     theme: 'auto',          // 'light' | 'dark' | 'auto'
     lazy_linefeeds: false,
     inline_styles: false,   // Use CSS classes (false) or inline styles (true)
@@ -2551,8 +2571,73 @@ const DEFAULT_OPTIONS = {
         highlightjs: false,
         mermaid: false
     },
+    /**
+     * Preload fence-rendering libraries at construction time so the FIRST
+     * encounter with a fence type renders instantly (no lazy load delay).
+     *
+     * Accepts:
+     *   - 'all'                                — preload every known library
+     *   - ['highlightjs','mermaid','math',
+     *      'geojson','stl']                    — preload specific libraries
+     *   - [{ name: 'mylib', script: 'https://...', css: '...' }]
+     *                                          — preload an arbitrary library
+     *
+     * Without this, fence libraries are loaded on demand the first time their
+     * fence type is encountered. That keeps the editor lightweight, but the
+     * first SVG/Mermaid/Math/GeoJSON/STL fence will show "loading..." for a
+     * moment. Set `preloadFences` if you want zero-delay rendering — at the
+     * cost of a few hundred KB of upfront network.
+     *
+     * Developer's choice. The editor itself is still ~70 KB minified;
+     * `preloadFences` only affects the OPTIONAL fence renderers.
+     */
+    preloadFences: null,
     customFences: {}, // { 'language': (code, lang) => html }
-    enableComplexFences: true // Enable CSV tables, math rendering, SVG, etc.
+    enableComplexFences: true, // Enable CSV tables, math rendering, SVG, etc.
+    showUndoRedo: false,      // Show undo/redo toolbar buttons
+    undoStackSize: 100        // Maximum number of undo states to keep
+};
+
+// Library catalog used by preloadFences. Each entry knows how to:
+//   - check if the library is already on the page (so we don't double-load)
+//   - load it via script (and optional CSS)
+const FENCE_LIBRARIES = {
+    highlightjs: {
+        check: () => typeof window.hljs !== 'undefined',
+        script: 'https://unpkg.com/@highlightjs/cdn-assets/highlight.min.js',
+        css: 'https://unpkg.com/@highlightjs/cdn-assets/styles/github.min.css',
+        cssDark: 'https://unpkg.com/@highlightjs/cdn-assets/styles/github-dark.min.css'
+    },
+    mermaid: {
+        check: () => typeof window.mermaid !== 'undefined',
+        script: 'https://unpkg.com/mermaid/dist/mermaid.min.js',
+        afterLoad: () => {
+            if (window.mermaid) window.mermaid.initialize({ startOnLoad: false });
+        }
+    },
+    math: {
+        check: () => typeof window.MathJax !== 'undefined',
+        script: 'https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-svg.js',
+        beforeLoad: () => {
+            // Configure MathJax before loading (must be set on window before script runs)
+            if (!window.MathJax) {
+                window.MathJax = {
+                    tex: { inlineMath: [['$', '$'], ['\\(', '\\)']], displayMath: [['$$', '$$'], ['\\[', '\\]']] },
+                    svg: { fontCache: 'global' },
+                    startup: { typeset: false }
+                };
+            }
+        }
+    },
+    geojson: {
+        check: () => typeof window.L !== 'undefined',
+        script: 'https://unpkg.com/leaflet@1.9.4/dist/leaflet.js',
+        css: 'https://unpkg.com/leaflet@1.9.4/dist/leaflet.css'
+    },
+    stl: {
+        check: () => typeof window.THREE !== 'undefined',
+        script: 'https://unpkg.com/three@0.147.0/build/three.min.js'
+    }
 };
 
 /**
@@ -2577,6 +2662,11 @@ class QuikdownEditor {
         this._html = '';
         this.currentMode = this.options.mode;
         this.updateTimer = null;
+
+        // Undo/redo state
+        this._undoStack = [];
+        this._redoStack = [];
+        this._isUndoRedo = false;
         
         // Initialize
         this.initPromise = this.init();
@@ -2633,6 +2723,7 @@ class QuikdownEditor {
         
         this.sourceTextarea = document.createElement('textarea');
         this.sourceTextarea.className = 'qde-textarea';
+        this.sourceTextarea.spellcheck = false;
         this.sourceTextarea.placeholder = this.options.placeholder;
         this.sourcePanel.appendChild(this.sourceTextarea);
         
@@ -2640,6 +2731,7 @@ class QuikdownEditor {
         this.previewPanel = document.createElement('div');
         this.previewPanel.className = 'qde-preview';
         this.previewPanel.contentEditable = true;
+        this.previewPanel.spellcheck = false;
         
         // Add panels to editor
         this.editorArea.appendChild(this.sourcePanel);
@@ -2669,6 +2761,23 @@ class QuikdownEditor {
             toolbar.appendChild(btn);
         });
         
+        // Undo/Redo buttons (if enabled)
+        if (this.options.showUndoRedo) {
+            const undoBtn = document.createElement('button');
+            undoBtn.className = 'qde-btn disabled';
+            undoBtn.dataset.action = 'undo';
+            undoBtn.textContent = 'Undo';
+            undoBtn.title = 'Undo (Ctrl+Z)';
+            toolbar.appendChild(undoBtn);
+
+            const redoBtn = document.createElement('button');
+            redoBtn.className = 'qde-btn disabled';
+            redoBtn.dataset.action = 'redo';
+            redoBtn.textContent = 'Redo';
+            redoBtn.title = 'Redo (Ctrl+Shift+Z / Ctrl+Y)';
+            toolbar.appendChild(redoBtn);
+        }
+
         // Spacer
         const spacer = document.createElement('span');
         spacer.className = 'qde-spacer';
@@ -2699,6 +2808,16 @@ class QuikdownEditor {
             removeHRBtn.title = 'Remove all horizontal rules (---) from markdown';
             toolbar.appendChild(removeHRBtn);
         }
+
+        // Lazy linefeeds button (if enabled)
+        if (this.options.showLazyLinefeeds) {
+            const lazyLFBtn = document.createElement('button');
+            lazyLFBtn.className = 'qde-btn';
+            lazyLFBtn.dataset.action = 'lazy-linefeeds';
+            lazyLFBtn.textContent = 'Fix Linefeeds';
+            lazyLFBtn.title = 'Convert single newlines to paragraph breaks (one-time transform)';
+            toolbar.appendChild(lazyLFBtn);
+        }
         
         return toolbar;
     }
@@ -2751,6 +2870,11 @@ class QuikdownEditor {
                 color: white;
                 border-color: #0056b3;
             }
+
+            .qde-btn.disabled {
+                opacity: 0.4;
+                pointer-events: none;
+            }
             
             .qde-spacer {
                 flex: 1;
@@ -2763,24 +2887,45 @@ class QuikdownEditor {
             }
             
             .qde-source, .qde-preview {
-                flex: 1;
+                flex: 1 1 0;
+                min-width: 0;       /* allow flex shrinking below content size */
+                min-height: 0;
                 overflow: auto;
                 padding: 16px;
+                box-sizing: border-box;
             }
-            
+
             .qde-source {
                 border-right: 1px solid #ddd;
+                /* Source pane is just a container for the textarea — make it
+                   a positioning context so the textarea can fill it absolutely */
+                position: relative;
+                padding: 0;          /* textarea brings its own padding */
             }
-            
+
             .qde-textarea {
+                display: block;
+                position: absolute;
+                inset: 0;
                 width: 100%;
                 height: 100%;
                 border: none;
                 outline: none;
                 resize: none;
+                padding: 16px;
+                box-sizing: border-box;
                 font-family: 'Monaco', 'Courier New', monospace;
                 font-size: 14px;
                 line-height: 1.5;
+                background: transparent;
+                color: inherit;
+                /* Wrap long lines so the textarea only scrolls VERTICALLY.
+                   pre-wrap preserves intentional line breaks/whitespace
+                   while soft-wrapping at the right edge. */
+                white-space: pre-wrap;
+                word-wrap: break-word;
+                overflow-x: hidden;
+                overflow-y: auto;
             }
             
             .qde-preview {
@@ -2789,14 +2934,69 @@ class QuikdownEditor {
                 line-height: 1.6;
                 outline: none;
                 cursor: text;  /* Standard text cursor */
+                overflow-x: hidden;  /* never scroll horizontally; clip wide content */
             }
-            
+
+            /* Code blocks and inline code — self-contained so the editor
+               does not depend on any external stylesheet for these. */
+            .qde-preview pre {
+                background: #f4f4f4;
+                color: #1f2937;
+                padding: 10px;
+                border-radius: 4px;
+                overflow-x: auto;
+                margin: 0.6em 0;
+                font-size: 0.9em;
+                line-height: 1.5;
+                font-family: ui-monospace, "SF Mono", Monaco, "Cascadia Code",
+                             "Roboto Mono", Consolas, "Courier New", monospace;
+            }
+            .qde-preview code {
+                padding: 2px 4px;
+                font-size: 0.9em;
+                border-radius: 3px;
+                background: #f0f0f0;
+                color: #1f2937;
+                font-family: ui-monospace, "SF Mono", Monaco, "Cascadia Code",
+                             "Roboto Mono", Consolas, "Courier New", monospace;
+            }
+            .qde-preview pre code {
+                padding: 0;
+                font-size: inherit;
+                border-radius: 0;
+                background: transparent;
+                color: inherit;
+            }
+
+            /* Wide fence content (Leaflet maps, large SVGs, STL canvases,
+               iframes, raw <img>) must never overflow the preview pane */
+            .qde-preview .geojson-container,
+            .qde-preview .qde-stl-container,
+            .qde-preview .qde-svg-container,
+            .qde-preview .leaflet-container,
+            .qde-preview iframe,
+            .qde-preview img,
+            .qde-preview > svg {
+                max-width: 100%;
+            }
+            .qde-preview .leaflet-container { box-sizing: border-box; }
+
+            /* Standard markdown tables (the .quikdown-table class) need to
+               scroll horizontally inside their own wrapper rather than
+               making the whole preview pane scroll */
+            .qde-preview table.quikdown-table,
+            .qde-preview table.qde-csv-table {
+                display: block;
+                max-width: 100%;
+                overflow-x: auto;
+            }
+
             /* Fence-specific styles */
             .qde-svg-container {
                 max-width: 100%;
                 overflow: auto;
             }
-            
+
             .qde-svg-container svg {
                 max-width: 100%;
                 height: auto;
@@ -2868,6 +3068,45 @@ class QuikdownEditor {
                 position: relative;
             }
             
+            /* Reset headings inside the preview to plain browser defaults so
+               parent-page styles (site navs, marketing pages, design systems)
+               cannot bleed in. Business-casual: black text, decreasing sizes,
+               no decorative borders. See docs/quikdown-editor.md for how
+               embedders can override these with their own stylesheet. */
+            .qde-preview h1 { font-size: 2em; }
+            .qde-preview h2 { font-size: 1.5em; }
+            .qde-preview h3 { font-size: 1.25em; }
+            .qde-preview h4 { font-size: 1em; }
+            .qde-preview h5 { font-size: 0.875em; }
+            .qde-preview h6 { font-size: 0.85em; }
+            .qde-preview h1,
+            .qde-preview h2,
+            .qde-preview h3,
+            .qde-preview h4,
+            .qde-preview h5,
+            .qde-preview h6 {
+                font-weight: bold;
+                color: inherit;
+                border: none;
+                margin: 0.6em 0 0.3em 0;
+                line-height: 1.25;
+            }
+            .qde-preview p {
+                margin: 0.35em 0;
+            }
+            .qde-preview ul,
+            .qde-preview ol {
+                padding-left: 1.8em;
+                margin: 0.4em 0;
+            }
+            .qde-preview li {
+                margin: 0.15em 0;
+            }
+            .qde-preview blockquote {
+                margin: 0.5em 0;
+                padding-left: 1em;
+            }
+
             /* Ensure proper cursor for editable text elements */
             .qde-preview p,
             .qde-preview h1,
@@ -2930,6 +3169,7 @@ class QuikdownEditor {
             .qde-dark {
                 background: #1e1e1e;
                 color: #e0e0e0;
+                border-color: #444;
             }
             
             .qde-dark .qde-toolbar {
@@ -2961,6 +3201,20 @@ class QuikdownEditor {
                 color: #e0e0e0;
             }
             
+            /* Dark mode code blocks */
+            .qde-dark .qde-preview pre {
+                background: #2d2d3a;
+                color: #e6e6f0;
+            }
+            .qde-dark .qde-preview code {
+                background: #2a2a3a;
+                color: #e6e6f0;
+            }
+            .qde-dark .qde-preview pre code {
+                background: transparent;
+                color: inherit;
+            }
+
             /* Dark mode table styles */
             .qde-dark .qde-preview table th,
             .qde-dark .qde-preview table td {
@@ -2980,11 +3234,14 @@ class QuikdownEditor {
                 .qde-mode-split .qde-editor {
                     flex-direction: column;
                 }
-                
+
                 .qde-mode-split .qde-source {
                     border-right: none;
                     border-bottom: 1px solid #ddd;
                 }
+                .qde-dark.qde-mode-split .qde-source {
+                    border-bottom-color: #444;
+                }
             }
         `;
         
@@ -3035,6 +3292,21 @@ class QuikdownEditor {
                         e.preventDefault();
                         this.setMode('preview');
                         break;
+                    case 'z':
+                    case 'Z':
+                        if (e.shiftKey) {
+                            e.preventDefault();
+                            this.redo();
+                        } else {
+                            e.preventDefault();
+                            this.undo();
+                        }
+                        break;
+                    case 'y':
+                    case 'Y':
+                        e.preventDefault();
+                        this.redo();
+                        break;
                 }
             }
         });
@@ -3064,6 +3336,12 @@ class QuikdownEditor {
      * Update from markdown source
      */
     updateFromMarkdown(markdown) {
+        // Push current state to undo stack before changing (unless this is an undo/redo operation)
+        if (!this._isUndoRedo) {
+            this._pushUndoState(markdown || '');
+        }
+        this._isUndoRedo = false;
+
         this._markdown = markdown || '';
         
         // Show placeholder if empty
@@ -3089,16 +3367,9 @@ class QuikdownEditor {
                 if (window.MathJax && window.MathJax.typesetPromise) {
                     const mathElements = this.previewPanel.querySelectorAll('.math-display');
                     if (mathElements.length > 0) {
-                        mathElements.forEach(el => {
-                        });
                         window.MathJax.typesetPromise(Array.from(mathElements))
-                            .then(() => {
-                                mathElements.forEach(el => {
-                                    el.querySelector('mjx-container');
-                                });
-                            })
-                            .catch(err => {
-                                console.warn('MathJax batch processing failed:', err);
+                            .catch(_err => {
+                                console.warn('MathJax batch processing failed:', _err);
                             });
                     }
                 }
@@ -3117,24 +3388,34 @@ class QuikdownEditor {
     updateFromHTML() {
         // Clone the preview panel to avoid modifying the actual DOM
         const clonedPanel = this.previewPanel.cloneNode(true);
-        
+
         // Pre-process special elements on the clone
         this.preprocessSpecialElements(clonedPanel);
-        
+
         this._html = this.previewPanel.innerHTML;
-        this._markdown = quikdown_bd.toMarkdown(clonedPanel, {
+        const newMarkdown = quikdown_bd.toMarkdown(clonedPanel, {
             fence_plugin: this.createFencePlugin()
         });
-        
+
+        // Push previous state to undo stack (now that we know the new markdown)
+        if (!this._isUndoRedo) {
+            this._pushUndoState(newMarkdown);
+        }
+        this._isUndoRedo = false;
+
+        this._markdown = newMarkdown;
+
         // Update source if visible
         if (this.currentMode !== 'preview') {
             this.sourceTextarea.value = this._markdown;
         }
-        
+
         // Trigger change event
         if (this.options.onChange) {
             this.options.onChange(this._markdown, this._html);
         }
+
+        this._updateUndoButtons();
     }
     
     /**
@@ -3335,7 +3616,7 @@ class QuikdownEditor {
             // Remove event handlers
             const walker = document.createTreeWalker(svg, NodeFilter.SHOW_ELEMENT);
             let node;
-            while (node = walker.nextNode()) {
+            while ((node = walker.nextNode())) {
                 for (let i = node.attributes.length - 1; i >= 0; i--) {
                     const attr = node.attributes[i];
                     if (attr.name.startsWith('on') || attr.value.includes('javascript:')) {
@@ -3425,7 +3706,7 @@ class QuikdownEditor {
     /**
      * Render math with MathJax (SVG output for better copy support)
      */
-    renderMath(code, lang) {
+    renderMath(code, _lang) {
         const id = `math-${Math.random().toString(36).substring(2, 15)}`;
         
         // Create container exactly like squibview
@@ -3548,11 +3829,11 @@ class QuikdownEditor {
             
             html += '</table>';
             return html;
-        } catch (err) {
+        } catch (_err) {
             return `<pre data-qd-fence="\`\`\`" data-qd-lang="${lang}" data-qd-source="${escapedCode}">${escapedCode}</pre>`;
         }
     }
-    
+
     /**
      * Parse CSV line handling quoted values
      */
@@ -3596,13 +3877,13 @@ class QuikdownEditor {
                 try {
                     const data = JSON.parse(code);
                     toHighlight = JSON.stringify(data, null, 2);
-                } catch (e) {
+                } catch (_e) {
                     // Use original if not valid JSON
                 }
                 
                 const highlighted = hljs.highlight(toHighlight, { language: 'json' }).value;
                 return `<pre class="qde-json" data-qd-fence="\`\`\`" data-qd-lang="${lang}"><code class="hljs language-json">${highlighted}</code></pre>`;
-            } catch (e) {
+            } catch (_e) {
                 // Fall through if highlighting fails
             }
         }
@@ -3695,7 +3976,7 @@ class QuikdownEditor {
                 if (loaded) {
                     renderMap();
                 } else {
-                    const element = document.getElementById(id);
+                    const element = document.getElementById(mapId + '-container');
                     if (element) {
                         element.innerHTML = '<div style="padding: 20px; text-align: center; color: #666;">Failed to load map library</div>';
                     }
@@ -3731,18 +4012,12 @@ class QuikdownEditor {
      */
     renderSTL(code) {
         const id = `qde-stl-viewer-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-        
-        // Function to render the 3D model
+
+        // Function to render the 3D model (assumes window.THREE is loaded)
         const render3D = () => {
             const element = document.getElementById(id);
             if (!element) return;
-            
-            // Check if Three.js is available
-            if (typeof window.THREE === 'undefined') {
-                element.innerHTML = '<div style="padding: 20px; text-align: center; color: #666;">Three.js library not loaded. Add &lt;script src="https://unpkg.com/three@0.147.0/build/three.min.js"&gt;&lt;/script&gt; to your HTML.</div>';
-                return;
-            }
-            
+
             try {
                 const THREE = window.THREE;
                 
@@ -3800,9 +4075,34 @@ class QuikdownEditor {
             }
         };
         
-        // Render after DOM update
-        setTimeout(render3D, 0);
-        
+        // If Three.js is already loaded, render immediately. Otherwise lazy-load
+        // it from a CDN (matches the GeoJSON/Leaflet pattern).
+        if (window.THREE) {
+            setTimeout(render3D, 0);
+        } else {
+            if (!window._qde_three_loading) {
+                window._qde_three_loading = this.lazyLoadLibrary(
+                    'Three.js',
+                    () => window.THREE,
+                    'https://unpkg.com/three@0.147.0/build/three.min.js'
+                ).catch(_err => {
+                    console.warn('Failed to load Three.js for STL rendering');
+                    window._qde_three_loading = null;
+                    return false;
+                });
+            }
+            window._qde_three_loading.then(loaded => {
+                if (loaded) {
+                    render3D();
+                } else {
+                    const element = document.getElementById(id);
+                    if (element) {
+                        element.innerHTML = '<div style="padding: 20px; text-align: center; color: #666;">Failed to load Three.js for STL rendering</div>';
+                    }
+                }
+            });
+        }
+
         // Return placeholder with data-stl-id for copy functionality
         return `<div id="${id}" class="qde-stl-container" data-stl-id="${id}" data-qd-fence="\`\`\`" data-qd-lang="stl" data-qd-source="${this.escapeHtml(code)}" contenteditable="false" style="height: 400px; background: #f0f0f0; display: flex; align-items: center; justify-content: center;">Loading 3D model...</div>`;
     }
@@ -3894,30 +4194,64 @@ class QuikdownEditor {
     }
     
     /**
-     * Load plugins dynamically
+     * Load plugins dynamically — honors both `plugins: { highlightjs, mermaid }`
+     * (legacy) and the newer `preloadFences` option which can preload any
+     * combination of fence libraries (or 'all') at construction time.
      */
     async loadPlugins() {
-        const promises = [];
-        
-        // Load highlight.js (check if already loaded)
-        if (this.options.plugins.highlightjs && !window.hljs) {
-            promises.push(
-                this.loadScript('https://unpkg.com/@highlightjs/cdn-assets/highlight.min.js'),
-                this.loadCSS('https://unpkg.com/@highlightjs/cdn-assets/styles/github.min.css')
-            );
+        const namesToLoad = new Set();
+
+        // Legacy plugins option
+        if (this.options.plugins) {
+            if (this.options.plugins.highlightjs) namesToLoad.add('highlightjs');
+            if (this.options.plugins.mermaid)     namesToLoad.add('mermaid');
         }
-        
-        // Load mermaid (check if already loaded)
-        if (this.options.plugins.mermaid && !window.mermaid) {
-            promises.push(
-                this.loadScript('https://unpkg.com/mermaid/dist/mermaid.min.js').then(() => {
-                    if (window.mermaid) {
-                        mermaid.initialize({ startOnLoad: false });
-                    }
-                })
-            );
+
+        // New preloadFences option
+        const pf = this.options.preloadFences;
+        if (pf === 'all') {
+            Object.keys(FENCE_LIBRARIES).forEach(n => namesToLoad.add(n));
+        } else if (Array.isArray(pf)) {
+            for (const entry of pf) {
+                if (typeof entry === 'string') {
+                    if (FENCE_LIBRARIES[entry]) namesToLoad.add(entry);
+                    else console.warn(`QuikdownEditor: unknown preloadFences entry "${entry}"`);
+                } else if (entry && typeof entry === 'object' && entry.script) {
+                    // Custom library: { name, script, css? }
+                    namesToLoad.add('__custom__:' + (entry.name || entry.script));
+                    FENCE_LIBRARIES['__custom__:' + (entry.name || entry.script)] = {
+                        check: () => false,
+                        script: entry.script,
+                        css: entry.css
+                    };
+                }
+            }
+        } else if (pf) {
+            console.warn('QuikdownEditor: preloadFences should be "all", an array, or null');
         }
-        
+
+        // Load each in parallel; respect already-loaded state
+        const promises = [];
+        for (const name of namesToLoad) {
+            const lib = FENCE_LIBRARIES[name];
+            if (!lib || lib.check()) continue;
+            if (lib.beforeLoad) lib.beforeLoad();
+            const p = (async () => {
+                try {
+                    const tasks = [];
+                    if (lib.script) tasks.push(this.loadScript(lib.script));
+                    if (lib.css)    tasks.push(this.loadCSS(lib.css, 'qde-hljs-light'));
+                    if (lib.cssDark) tasks.push(this.loadCSS(lib.cssDark, 'qde-hljs-dark'));
+                    await Promise.all(tasks);
+                    if (lib.css && lib.cssDark) this._syncHljsTheme();
+                    if (lib.afterLoad) lib.afterLoad();
+                } catch (err) {
+                    console.warn(`QuikdownEditor: failed to preload ${name}:`, err);
+                }
+            })();
+            promises.push(p);
+        }
+
         await Promise.all(promises);
     }
     
@@ -3969,36 +4303,73 @@ class QuikdownEditor {
     /**
      * Load external CSS
      */
-    loadCSS(href) {
+    loadCSS(href, id) {
         return new Promise((resolve) => {
             const link = document.createElement('link');
             link.rel = 'stylesheet';
             link.href = href;
+            if (id) link.id = id;
             link.onload = resolve;
             document.head.appendChild(link);
             // Resolve anyway after timeout (CSS doesn't always fire onload)
             setTimeout(resolve, 1000);
         });
     }
-    
+
     /**
-     * Apply theme
+     * Enable the hljs stylesheet matching the current theme and disable
+     * the other one. Called from applyTheme and after hljs CSS loads.
+     */
+    _syncHljsTheme() {
+        const isDark = this.container.classList.contains('qde-dark');
+        const light = document.getElementById('qde-hljs-light');
+        const dark  = document.getElementById('qde-hljs-dark');
+        if (light) light.disabled = isDark;
+        if (dark)  dark.disabled  = !isDark;
+    }
+
+    /**
+     * Apply the current theme (based on this.options.theme)
      */
     applyTheme() {
         const theme = this.options.theme;
-        
+
+        // Tear down any previous auto-mode listener so we don't stack them
+        if (this._autoThemeListener) {
+            window.matchMedia('(prefers-color-scheme: dark)').removeEventListener('change', this._autoThemeListener);
+            this._autoThemeListener = null;
+        }
+
         if (theme === 'auto') {
-            // Check system preference
-            const isDark = window.matchMedia('(prefers-color-scheme: dark)').matches;
-            this.container.classList.toggle('qde-dark', isDark);
-            
-            // Listen for changes
-            window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', (e) => {
+            const mq = window.matchMedia('(prefers-color-scheme: dark)');
+            this.container.classList.toggle('qde-dark', mq.matches);
+            this._autoThemeListener = (e) => {
                 this.container.classList.toggle('qde-dark', e.matches);
-            });
+                this._syncHljsTheme();
+            };
+            mq.addEventListener('change', this._autoThemeListener);
         } else {
             this.container.classList.toggle('qde-dark', theme === 'dark');
         }
+        this._syncHljsTheme();
+    }
+
+    /**
+     * Set theme at runtime. Accepts 'light', 'dark', or 'auto'.
+     * @param {'light'|'dark'|'auto'} theme
+     */
+    setTheme(theme) {
+        if (!['light', 'dark', 'auto'].includes(theme)) return;
+        this.options.theme = theme;
+        this.applyTheme();
+    }
+
+    /**
+     * Get the current theme option (as configured, not resolved).
+     * @returns {'light'|'dark'|'auto'}
+     */
+    getTheme() {
+        return this.options.theme;
     }
     
     /**
@@ -4042,10 +4413,18 @@ class QuikdownEditor {
      */
     setMode(mode) {
         if (!['source', 'preview', 'split'].includes(mode)) return;
-        
+
+        // Preserve theme class across mode swap (the assignment to className
+        // below would otherwise wipe it out — this used to be a no-op bug
+        // where dark mode was lost on every setMode call).
+        const wasDark = this.container.classList.contains('qde-dark');
+
         this.currentMode = mode;
         this.container.className = `qde-container qde-mode-${mode}`;
-        
+        if (wasDark) {
+            this.container.classList.add('qde-dark');
+        }
+
         // Update toolbar buttons
         if (this.toolbar) {
             this.toolbar.querySelectorAll('.qde-btn[data-mode]').forEach(btn => {
@@ -4053,11 +4432,6 @@ class QuikdownEditor {
             });
         }
         
-        // Apply theme class
-        if (this.container.classList.contains('qde-dark')) {
-            this.container.classList.add('qde-dark');
-        }
-        
         // Make fence blocks non-editable when showing preview
         if (mode !== 'source') {
             setTimeout(() => this.makeFencesNonEditable(), 0);
@@ -4069,6 +4443,105 @@ class QuikdownEditor {
         }
     }
     
+    // --- Undo / Redo ---
+
+    /**
+     * Push current markdown state onto the undo stack (called before a change).
+     * Only pushes if the new state differs from the current state.
+     * @param {string} newMarkdown - the incoming markdown (used to detect no-op)
+     * @private
+     */
+    _pushUndoState(newMarkdown) {
+        // Don't push if the content hasn't actually changed
+        if (newMarkdown === this._markdown) return;
+
+        this._undoStack.push(this._markdown);
+
+        // Enforce max stack size
+        const max = this.options.undoStackSize || 100;
+        if (this._undoStack.length > max) {
+            this._undoStack.splice(0, this._undoStack.length - max);
+        }
+
+        // Any new edit clears the redo stack
+        this._redoStack = [];
+        this._updateUndoButtons();
+    }
+
+    /**
+     * Undo the last change. Restores the previous markdown state.
+     */
+    undo() {
+        if (!this.canUndo()) return;
+        // Save current state to redo stack
+        this._redoStack.push(this._markdown);
+        const previous = this._undoStack.pop();
+        this._isUndoRedo = true;
+        // Update state directly (setMarkdown is async; keep it synchronous here)
+        this._markdown = previous;
+        if (this.sourceTextarea) {
+            this.sourceTextarea.value = previous;
+        }
+        this.updateFromMarkdown(previous);
+        this._updateUndoButtons();
+    }
+
+    /**
+     * Redo the last undone change.
+     */
+    redo() {
+        if (!this.canRedo()) return;
+        // Save current state to undo stack
+        this._undoStack.push(this._markdown);
+        const next = this._redoStack.pop();
+        this._isUndoRedo = true;
+        this._markdown = next;
+        if (this.sourceTextarea) {
+            this.sourceTextarea.value = next;
+        }
+        this.updateFromMarkdown(next);
+        this._updateUndoButtons();
+    }
+
+    /**
+     * @returns {boolean} true if undo is possible
+     */
+    canUndo() {
+        return this._undoStack.length > 0;
+    }
+
+    /**
+     * @returns {boolean} true if redo is possible
+     */
+    canRedo() {
+        return this._redoStack.length > 0;
+    }
+
+    /**
+     * Clear the undo and redo history.
+     */
+    clearHistory() {
+        this._undoStack = [];
+        this._redoStack = [];
+        this._updateUndoButtons();
+    }
+
+    /**
+     * Update the disabled state of the undo/redo toolbar buttons.
+     * @private
+     */
+    _updateUndoButtons() {
+        if (!this.toolbar) return;
+        const undoBtn = this.toolbar.querySelector('[data-action="undo"]');
+        const redoBtn = this.toolbar.querySelector('[data-action="redo"]');
+        if (undoBtn) {
+            undoBtn.classList.toggle('disabled', !this.canUndo());
+        }
+        if (redoBtn) {
+            redoBtn.classList.toggle('disabled', !this.canRedo());
+        }
+    }
+
     /**
      * Handle toolbar actions
      */
@@ -4086,6 +4559,15 @@ class QuikdownEditor {
             case 'remove-hr':
                 this.removeHR();
                 break;
+            case 'lazy-linefeeds':
+                this.convertLazyLinefeeds();
+                break;
+            case 'undo':
+                this.undo();
+                break;
+            case 'redo':
+                this.redo();
+                break;
         }
     }
     
@@ -4173,24 +4655,13 @@ class QuikdownEditor {
     }
     
     /**
-     * Remove all horizontal rules (---) from markdown
+     * Remove all horizontal rules (---) from markdown source.
+     * Preserves content inside fences (``` or ~~~) and table separator rows.
      */
     async removeHR() {
-        // Remove standalone HR lines (3 or more dashes/underscores/asterisks)
-        // Matches: ---, ___, ***, ----, etc. with optional spaces
-        const cleaned = this._markdown
-            .split('\n')
-            .filter(line => {
-                // Keep lines that aren't just HR patterns
-                const trimmed = line.trim();
-                // Match HR patterns: 3+ of -, _, or * with optional spaces between
-                return !(/^[-_*](\s*[-_*]){2,}\s*$/.test(trimmed));
-            })
-            .join('\n');
-        
-        // Update the markdown
+        const cleaned = QuikdownEditor.removeHRFromMarkdown(this._markdown);
         await this.setMarkdown(cleaned);
-        
+
         // Visual feedback if toolbar button exists
         const btn = this.toolbar?.querySelector('[data-action="remove-hr"]');
         if (btn) {
@@ -4201,6 +4672,247 @@ class QuikdownEditor {
             }, 1500);
         }
     }
+
+    /**
+     * Static: remove horizontal rules from markdown string.
+     * Safe for fences, tables, and all markdown constructs.
+     * Can be used headless without an editor instance.
+     * @param {string} markdown - source markdown
+     * @returns {string} markdown with standalone HRs removed
+     */
+    static removeHRFromMarkdown(markdown) {
+        const lines = (markdown || '').split('\n');
+        const result = [];
+        let inFence = false;
+        let fenceChar = null;  // '`' or '~'
+        let fenceLen = 0;      // length of opening fence marker
+
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const trimmed = line.trim();
+
+            // Track fence open/close (``` or ~~~, 3+ chars)
+            const fenceMatch = trimmed.match(/^(`{3,}|~{3,})/);
+            if (fenceMatch) {
+                const matchChar = fenceMatch[1][0];
+                const matchLen = fenceMatch[1].length;
+                if (!inFence) {
+                    inFence = true;
+                    fenceChar = matchChar;
+                    fenceLen = matchLen;
+                    result.push(line);
+                    continue;
+                } else if (matchChar === fenceChar && matchLen >= fenceLen && /^(`{3,}|~{3,})\s*$/.test(trimmed)) {
+                    // Closing fence: same char, at least as many chars, no trailing content
+                    inFence = false;
+                    fenceChar = null;
+                    fenceLen = 0;
+                    result.push(line);
+                    continue;
+                }
+            }
+
+            // Inside a fence — keep everything
+            if (inFence) {
+                result.push(line);
+                continue;
+            }
+
+            // Detect table row/separator with pipes — always keep
+            if (/^\|.*\|$/.test(trimmed) || (/^[-| :]+$/.test(trimmed) && trimmed.includes('|'))) {
+                result.push(line);
+                continue;
+            }
+
+            // Check if this line is a standalone HR
+            const isHR = /^[-_*](\s*[-_*]){2,}\s*$/.test(trimmed);
+            if (isHR) {
+                // Table separator heuristic: immediately adjacent lines (no blank
+                // lines between) that look like table rows protect this HR-like line
+                const prevLine = i > 0 ? lines[i - 1].trim() : '';
+                const nextLine = i < lines.length - 1 ? lines[i + 1].trim() : '';
+                if (_looksLikeTableRow(prevLine) || _looksLikeTableRow(nextLine)) {
+                    result.push(line);
+                    continue;
+                }
+                // It's a real HR — skip it
+                continue;
+            }
+
+            result.push(line);
+        }
+
+        return result.join('\n');
+    }
+
+    /**
+     * Convert lazy linefeeds in markdown source.
+     * Replaces single newlines with double newlines (adds real line breaks)
+     * except inside fences, tables, and other block-level constructs.
+     * Idempotent: calling multiple times produces the same result.
+     * Can be used as a toolbar action or headless via the static method.
+     */
+    async convertLazyLinefeeds() {
+        const converted = QuikdownEditor.convertLazyLinefeeds(this._markdown);
+        await this.setMarkdown(converted);
+
+        // Visual feedback if toolbar button exists
+        const btn = this.toolbar?.querySelector('[data-action="lazy-linefeeds"]');
+        if (btn) {
+            const originalText = btn.textContent;
+            btn.textContent = 'Converted!';
+            setTimeout(() => {
+                btn.textContent = originalText;
+            }, 1500);
+        }
+    }
+
+    /**
+     * Static: convert lazy linefeeds in markdown source.
+     * Turns single \n between non-blank lines into \n\n so each line becomes
+     * its own paragraph / hard break. Idempotent — already-doubled newlines
+     * are not doubled again. Fences, tables, lists, blockquotes, headings,
+     * and HTML blocks are left untouched.
+     * @param {string} markdown - source markdown
+     * @returns {string} markdown with lazy linefeeds resolved
+     */
+    static convertLazyLinefeeds(markdown) {
+        // Two-phase approach (much cleaner than the old single pass):
+        //
+        //   Phase A: walk lines, classify each as { content, blank, fence }.
+        //            Inside fences, lines are passed through verbatim.
+        //   Phase B: emit lines with the rule:
+        //            "between two adjacent CONTENT lines, ensure exactly one
+        //             blank line — never zero, never more than one."
+        //
+        // The rule applies regardless of whether the content lines are
+        // headings, lists, blockquotes, table rows, paragraphs, or HR — any
+        // adjacent pair of non-fence non-blank lines gets exactly one blank
+        // between them. This produces the cleanest possible output for any
+        // input and is fully idempotent.
+        //
+        // Lines that are whitespace-only (e.g. "   ") are normalized to
+        // empty strings, eliminating "phantom" blank lines.
+        //
+        // Lists are a special case: adjacent list items (same marker type)
+        // should NOT get a blank line between them, otherwise we'd break
+        // tight lists.
+        //
+        // Same applies to blockquote lines and table rows — adjacent rows
+        // belong to the same block.
+
+        const inputLines = (markdown || '').split('\n');
+
+        // -------- Phase A: classify lines, normalize whitespace-only --------
+        // Each entry: { line, kind } where kind is one of:
+        //   'fence-open', 'fence-close', 'fence-body', 'blank', 'content'
+        // Plus a 'category' for content lines: 'list-ul', 'list-ol',
+        //   'blockquote', 'table', 'heading', 'hr', 'paragraph'
+        const items = [];
+        let inFence = false;
+        let fenceChar = null;
+        let fenceLen = 0;
+
+        for (const rawLine of inputLines) {
+            const line = rawLine;
+            const trimmed = line.trim();
+
+            // Fence tracking
+            const fenceMatch = trimmed.match(/^(`{3,}|~{3,})/);
+            if (fenceMatch && !inFence) {
+                inFence = true;
+                fenceChar = fenceMatch[1][0];
+                fenceLen  = fenceMatch[1].length;
+                items.push({ line, kind: 'fence-open' });
+                continue;
+            }
+            if (inFence) {
+                if (fenceMatch &&
+                    fenceMatch[1][0] === fenceChar &&
+                    fenceMatch[1].length >= fenceLen &&
+                    /^(`{3,}|~{3,})\s*$/.test(trimmed)) {
+                    inFence = false;
+                    fenceChar = null;
+                    fenceLen = 0;
+                    items.push({ line, kind: 'fence-close' });
+                } else {
+                    items.push({ line, kind: 'fence-body' });
+                }
+                continue;
+            }
+
+            // Outside fence: whitespace-only lines become canonical blanks
+            if (trimmed === '') {
+                items.push({ line: '', kind: 'blank' });
+                continue;
+            }
+
+            // Categorize content lines so we can recognize adjacent same-kind blocks
+            let category = 'paragraph';
+            if (/^#{1,6}\s/.test(trimmed))                    category = 'heading';
+            else if (/^[-_*](\s*[-_*]){2,}\s*$/.test(trimmed)) category = 'hr';
+            else if (/^(\d+\.)\s/.test(trimmed))              category = 'list-ol';
+            else if (/^[-*+]\s/.test(trimmed))                category = 'list-ul';
+            else if (/^>/.test(trimmed))                      category = 'blockquote';
+            else if (/^\|/.test(trimmed))                     category = 'table';
+            // Indented continuation of a list (2+ leading spaces or tab)
+            else if (/^(?: {4}|\t| {2,}[-*+]| {2,}\d+\.)/.test(line)) category = 'list-cont';
+
+            items.push({ line, kind: 'content', category });
+        }
+
+        // -------- Phase B: emit with exactly-one-blank-line normalization --------
+        // Same-block adjacent lines (lists, blockquotes, tables) stay
+        // touching; any other adjacent content pair gets exactly one blank.
+        const result = [];
+        let prev = null;   // last emitted non-blank content item
+
+        function inSameBlock(a, b) {
+            if (!a || !b) return false;
+            // Lists: same marker family OR list-content continuation
+            if ((a.category === 'list-ul' || a.category === 'list-ol' || a.category === 'list-cont') &&
+                (b.category === 'list-ul' || b.category === 'list-ol' || b.category === 'list-cont')) {
+                return true;
+            }
+            // Blockquotes
+            if (a.category === 'blockquote' && b.category === 'blockquote') return true;
+            // Table rows
+            if (a.category === 'table' && b.category === 'table') return true;
+            return false;
+        }
+
+        for (const item of items) {
+            if (item.kind === 'fence-open' || item.kind === 'fence-body' || item.kind === 'fence-close') {
+                // Fences: ensure exactly one blank line before the fence-open
+                if (item.kind === 'fence-open' && prev && result.length > 0 && result[result.length - 1] !== '') {
+                    result.push('');
+                }
+                result.push(item.line);
+                if (item.kind === 'fence-close') prev = { kind: 'content', category: 'fence' };
+                continue;
+            }
+
+            if (item.kind === 'blank') {
+                // Skip — Phase B inserts its own blank lines as needed
+                continue;
+            }
+
+            // item.kind === 'content'
+            if (prev) {
+                if (inSameBlock(prev, item)) ; else {
+                    // Different blocks (or paragraphs): exactly one blank
+                    if (result[result.length - 1] !== '') result.push('');
+                }
+            }
+            result.push(item.line);
+            prev = item;
+        }
+
+        // Trim trailing blank lines so output has exactly one terminal newline
+        while (result.length > 0 && result[result.length - 1] === '') result.pop();
+
+        return result.join('\n');
+    }
     
     /**
      * Copy rendered content as rich text
@@ -4244,6 +4956,13 @@ class QuikdownEditor {
     }
 }
 
+// --- Internal helpers for removeHR fence/table awareness ---
+
+/** Heuristic: does this line look like a markdown table row? */
+function _looksLikeTableRow(line) {
+    return line.includes('|');
+}
+
 // Export for CommonJS (needed for bundled ESM to work with Jest)
 if (typeof module !== 'undefined' && module.exports) {
     module.exports = QuikdownEditor;