quikdown 1.1.1 → 1.2.2

package/dist/quikdown_edit.umd.js

@@ -1,6 +1,6 @@
 /**
  * Quikdown Editor - Drop-in Markdown Parser
- * @version 1.1.1
+ * @version 1.2.2
  * @license BSD-2-Clause
  * @copyright DeftIO 2025
  */
@@ -24,7 +24,7 @@
      */
 
     // Version will be injected at build time  
-    const quikdownVersion = '1.1.1';
+    const quikdownVersion = '1.2.2';
 
     // Constants for reuse
     const CLASS_PREFIX = 'quikdown-';
@@ -274,7 +274,7 @@
             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)
@@ -303,7 +303,7 @@
             [/(<\/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]) => {
@@ -509,7 +509,7 @@
         
         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]);
@@ -719,7 +719,7 @@
             
             // Process children with context
             let childContent = '';
-            for (let child of node.childNodes) {
+            for (const child of node.childNodes) {
                 childContent += walkNode(child, { parentTag: tag, ...parentContext });
             }
             
@@ -953,7 +953,7 @@
             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');
@@ -966,7 +966,7 @@
                     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') {
@@ -977,7 +977,7 @@
                 } 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 {
@@ -1006,7 +1006,7 @@
                 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';
@@ -1025,9 +1025,9 @@
             // 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) {
@@ -1931,7 +1931,7 @@
                                     // 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;
@@ -1950,8 +1950,8 @@
                                 // 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) {
@@ -2184,7 +2184,7 @@
                     let mapDataUrl = '';
                     try {
                         mapDataUrl = canvas.toDataURL('image/png', 1.0);
-                    } catch (e) {
+                    } catch (_e) {
                         console.warn('Map canvas tainted; falling back to placeholder');
                     }
 
@@ -2547,7 +2547,8 @@
     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)
@@ -2558,7 +2559,9 @@
             mermaid: false
         },
         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
     };
 
     /**
@@ -2583,6 +2586,11 @@
             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();
@@ -2675,6 +2683,23 @@
                 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';
@@ -2705,6 +2730,16 @@
                 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;
         }
@@ -2757,6 +2792,11 @@
                 color: white;
                 border-color: #0056b3;
             }
+
+            .qde-btn.disabled {
+                opacity: 0.4;
+                pointer-events: none;
+            }
             
             .qde-spacer {
                 flex: 1;
@@ -3041,6 +3081,21 @@
                             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;
                     }
                 }
             });
@@ -3070,6 +3125,12 @@
          * 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
@@ -3095,16 +3156,9 @@
                     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);
                                 });
                         }
                     }
@@ -3341,7 +3395,7 @@
                 // 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:')) {
@@ -3431,7 +3485,7 @@
         /**
          * 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
@@ -3554,11 +3608,11 @@
                 
                 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
          */
@@ -3602,13 +3656,13 @@
                     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
                 }
             }
@@ -3701,7 +3755,7 @@
                     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>';
                         }
@@ -3988,24 +4042,46 @@
         }
         
         /**
-         * Apply theme
+         * 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);
-                });
+                };
+                mq.addEventListener('change', this._autoThemeListener);
             } else {
                 this.container.classList.toggle('qde-dark', theme === 'dark');
             }
         }
+
+        /**
+         * 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;
+        }
         
         /**
          * Set lazy linefeeds option
@@ -4075,6 +4151,105 @@
             }
         }
         
+        // --- 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
          */
@@ -4092,6 +4267,15 @@
                 case 'remove-hr':
                     this.removeHR();
                     break;
+                case 'lazy-linefeeds':
+                    this.convertLazyLinefeeds();
+                    break;
+                case 'undo':
+                    this.undo();
+                    break;
+                case 'redo':
+                    this.redo();
+                    break;
             }
         }
         
@@ -4179,24 +4363,13 @@
         }
         
         /**
-         * 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) {
@@ -4207,6 +4380,202 @@
                 }, 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) {
+            const lines = (markdown || '').split('\n');
+            const result = [];
+            let inFence = false;
+            let fenceChar = null;
+            let fenceLen = 0;
+            let inHTMLBlock = false;
+
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                const trimmed = line.trim();
+
+                // Track fence open/close
+                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)) {
+                        inFence = false;
+                        fenceChar = null;
+                        fenceLen = 0;
+                        result.push(line);
+                        continue;
+                    }
+                }
+
+                // Inside fence — pass through
+                if (inFence) {
+                    result.push(line);
+                    continue;
+                }
+
+                // Track HTML blocks (lines starting with < and ending with >)
+                if (/^<[a-zA-Z]/.test(trimmed)) inHTMLBlock = true;
+                if (inHTMLBlock) {
+                    result.push(line);
+                    if (/>$/.test(trimmed) || trimmed === '') inHTMLBlock = false;
+                    continue;
+                }
+
+                // Always pass through blank lines, but never add extras
+                if (trimmed === '') {
+                    // Avoid doubling: don't add blank line if the last result line is already blank
+                    if (result.length === 0 || result[result.length - 1].trim() !== '') {
+                        result.push(line);
+                    }
+                    continue;
+                }
+
+                // Skip conversion for block-level constructs
+                const isBlockElement = (
+                    /^#{1,6}\s/.test(trimmed) ||           // headings
+                    /^[-_*](\s*[-_*]){2,}\s*$/.test(trimmed) || // horizontal rules
+                    /^(\d+\.|-|\*|\+)\s/.test(trimmed) ||  // list items
+                    /^>/.test(trimmed) ||                   // blockquotes
+                    /^\|/.test(trimmed)                     // table rows
+                );
+
+                if (isBlockElement) {
+                    result.push(line);
+                    continue;
+                }
+
+                // For plain paragraph text: if previous result line is non-blank
+                // plain text, insert a blank line between them (making the single
+                // newline into a paragraph break). This is the lazy→strict conversion.
+                if (result.length > 0) {
+                    const prevLine = result[result.length - 1];
+                    const prevTrimmed = prevLine.trim();
+                    // Only insert blank line if prev is non-blank, non-block text
+                    if (prevTrimmed !== '' &&
+                        !/^#{1,6}\s/.test(prevTrimmed) &&
+                        !/^[-_*](\s*[-_*]){2,}\s*$/.test(prevTrimmed) &&
+                        !/^(\d+\.|-|\*|\+)\s/.test(prevTrimmed) &&
+                        !/^>/.test(prevTrimmed) &&
+                        !/^\|/.test(prevTrimmed) &&
+                        !/^(`{3,}|~{3,})/.test(prevTrimmed)) {
+                        result.push('');
+                    }
+                }
+
+                result.push(line);
+            }
+
+            return result.join('\n');
+        }
         
         /**
          * Copy rendered content as rich text
@@ -4250,6 +4619,13 @@
         }
     }
 
+    // --- 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;