quikdown 1.1.1 → 1.2.3

package/dist/quikdown_edit.umd.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
  */
@@ -24,7 +24,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-';
@@ -72,6 +72,11 @@
                 // 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 += ';';
                 }
                 
@@ -103,9 +108,12 @@
             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 */
@@ -274,7 +282,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 +311,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,10 +517,15 @@
         
         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++) {
@@ -684,8 +697,11 @@
         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];
     });
 
@@ -719,7 +735,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 +969,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 +982,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 +993,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 +1022,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 +1041,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) {
@@ -1049,10 +1065,13 @@
         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);
         };
     };
 
@@ -1931,7 +1950,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 +1969,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 +2203,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 +2566,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)
@@ -2557,8 +2577,73 @@
             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'
+        }
     };
 
     /**
@@ -2583,6 +2668,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();
@@ -2639,6 +2729,7 @@
             
             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);
             
@@ -2646,6 +2737,7 @@
             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);
@@ -2675,6 +2767,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 +2814,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 +2876,11 @@
                 color: white;
                 border-color: #0056b3;
             }
+
+            .qde-btn.disabled {
+                opacity: 0.4;
+                pointer-events: none;
+            }
             
             .qde-spacer {
                 flex: 1;
@@ -2769,24 +2893,45 @@
             }
             
             .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 {
@@ -2795,14 +2940,69 @@
                 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;
@@ -2874,6 +3074,45 @@
                 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,
@@ -2936,6 +3175,7 @@
             .qde-dark {
                 background: #1e1e1e;
                 color: #e0e0e0;
+                border-color: #444;
             }
             
             .qde-dark .qde-toolbar {
@@ -2967,6 +3207,20 @@
                 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 {
@@ -2986,11 +3240,14 @@
                 .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;
+                }
             }
         `;
             
@@ -3041,6 +3298,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 +3342,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 +3373,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);
                                 });
                         }
                     }
@@ -3123,24 +3394,34 @@
         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();
         }
         
         /**
@@ -3341,7 +3622,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 +3712,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 +3835,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 +3883,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 +3982,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>';
                         }
@@ -3737,18 +4018,12 @@
          */
         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;
                     
@@ -3806,9 +4081,34 @@
                 }
             };
             
-            // 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>`;
         }
@@ -3900,30 +4200,64 @@
         }
         
         /**
-         * 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);
         }
         
@@ -3975,36 +4309,73 @@
         /**
          * 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;
         }
         
         /**
@@ -4048,10 +4419,18 @@
          */
         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 => {
@@ -4059,11 +4438,6 @@
                 });
             }
             
-            // 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);
@@ -4075,6 +4449,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 +4565,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 +4661,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 +4678,247 @@
                 }, 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
@@ -4250,6 +4962,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;