@arsedizioni/ars-utils 22.0.17 → 22.0.20

package/fesm2022/arsedizioni-ars-utils-core.mjs

@@ -28,7 +28,9 @@ import { SelectionModel } from '@angular/cdk/collections';
  * Supported syntax: headings, paragraphs, hard/soft breaks, hr, blockquotes
  * (nested), fenced code blocks, inline code, bold/italic/strikethrough, links
  * (with title), images, autolinked bare URLs, ordered/unordered lists (nested,
- * task lists, ordered start offset), GFM tables with alignment.
+ * task lists, ordered start offset), GFM tables with alignment, raw HTML
+ * blocks (e.g. <table>...</table>) passed through verbatim when escapeHtml
+ * is false: their newlines stay plain newlines, never converted to <br>.
  *
  * Known simplifications (documented, by design):
  * - A blank line terminates a list.
@@ -63,7 +65,7 @@ class MarkdownUtils {
         const source = markdown
             .replace(/\r\n?/g, '\n')
             .replace(/([A-Za-zÀ-ÿ][!?])([A-Za-zÀ-ÿ])/g, '$1 $2');
-        const html = this.normalizeBreaks(this.parseBlocks(source.split('\n'), opts).trim());
+        const html = this.parseBlocks(source.split('\n'), opts).trim();
         if (this.cache.size >= this.CACHE_MAX) {
             this.cache.delete(this.cache.keys().next().value); // FIFO eviction
         }
@@ -72,18 +74,160 @@ class MarkdownUtils {
     }
     // #endregion
     // #region Block parser (single pass)
+    /** Block-level HTML tags that start a raw HTML block (passthrough, no <p>/<br>). */
+    static { this.htmlBlockTags = new Set([
+        'address', 'article', 'aside', 'blockquote', 'caption', 'colgroup', 'col',
+        'dd', 'details', 'dialog', 'div', 'dl', 'dt', 'fieldset', 'figcaption',
+        'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header',
+        'hr', 'iframe', 'li', 'main', 'nav', 'ol', 'p', 'pre', 'section', 'summary',
+        'table', 'tbody', 'td', 'tfoot', 'thead', 'th', 'tr', 'ul',
+    ]); }
+    /** Void/self-contained tags: a single tag, no closing tag expected. */
+    static { this.htmlVoidTags = new Set(['hr', 'col', 'img', 'input']); }
+    /**
+     * Precompiled: first block-level tag occurrence anywhere in a line.
+     * Anchored on the '<' literal, so scanning is cheap; the lookahead
+     * prevents partial matches ('<td' must not match inside '<tdx').
+     */
+    static { this.htmlBlockScanRe = new RegExp(`<(\\/?)(${[...MarkdownUtils.htmlBlockTags].join('|')})(?=[\\s/>])`, 'gi'); }
+    /** Result of scanning a line for the start of a raw HTML block. */
+    static findHtmlBlockStart(line) {
+        // HTML comment candidate (skipping occurrences inside inline code spans)
+        let comment = line.indexOf('<!--');
+        while (comment !== -1 && this.insideCodeSpan(line, comment)) {
+            comment = line.indexOf('<!--', comment + 4);
+        }
+        // Block tag candidate (same code-span guard)
+        const re = this.htmlBlockScanRe;
+        re.lastIndex = 0;
+        let m;
+        let tagHit;
+        while ((m = re.exec(line)) !== null) {
+            if (!this.insideCodeSpan(line, m.index)) {
+                tagHit = { index: m.index, tag: m[2].toLowerCase(), isClose: m[1] === '/' };
+                break;
+            }
+        }
+        if (comment !== -1 && (!tagHit || comment < tagHit.index)) {
+            return { index: comment, tag: '', isClose: false, isComment: true };
+        }
+        return tagHit ? { ...tagHit, isComment: false } : undefined;
+    }
+    /** True when `index` falls inside an inline code span (odd backtick count before it). */
+    static insideCodeSpan(line, index) {
+        let count = 0;
+        for (let i = 0; i < index; i++) {
+            if (line.charCodeAt(i) === 96 /* ` */)
+                count++;
+        }
+        return (count & 1) === 1;
+    }
+    /**
+     * indexOf-based depth scanner (no regex, no allocations): walks `text`
+     * adjusting `depth` for <tag ...> / </tag> occurrences of the SAME tag.
+     * Self-closing <tag ... /> forms do not alter depth.
+     * @returns [newDepth, endIndex] where endIndex is the position right after
+     *          the '>' that balanced the element, or -1 when still open.
+     */
+    static scanHtmlDepth(text, tag, depth) {
+        const lower = text.toLowerCase();
+        const open = '<' + tag;
+        const close = '</' + tag;
+        let i = 0;
+        while ((i = lower.indexOf('<', i)) !== -1) {
+            if (lower.startsWith(close, i) && this.isTagBoundary(lower, i + close.length)) {
+                depth--;
+                const gt = lower.indexOf('>', i);
+                const end = gt === -1 ? lower.length : gt + 1;
+                if (depth <= 0)
+                    return [0, end];
+                i = end;
+            }
+            else if (lower.startsWith(open, i) && this.isTagBoundary(lower, i + open.length)) {
+                const gt = lower.indexOf('>', i);
+                const selfClosing = gt !== -1 && lower.charCodeAt(gt - 1) === 47 /* / */;
+                if (selfClosing) {
+                    if (depth === 0)
+                        return [0, gt + 1]; // standalone self-closed element
+                }
+                else {
+                    depth++;
+                }
+                i = gt === -1 ? lower.length : gt + 1;
+            }
+            else {
+                i++;
+            }
+        }
+        return [depth, -1];
+    }
+    /** A tag token must be followed by whitespace, '/', '>' or end of line. */
+    static isTagBoundary(s, idx) {
+        if (idx >= s.length)
+            return true; // tag opening continues on the next line
+        const c = s.charCodeAt(idx);
+        return c === 62 /* > */ || c === 47 /* / */ || c === 32 /* space */ || c === 9 /* tab */;
+    }
+    /**
+     * Re-injects the remainder of a partially consumed line so the main loop
+     * processes it as markdown. Returns the index the loop should resume from.
+     */
+    static pushBack(lines, i, remainder) {
+        if (remainder.trim()) {
+            lines[i] = remainder;
+            return i - 1; // the loop's i++ re-processes the remainder
+        }
+        return i;
+    }
     /**
-     * Normalizes <br> runs in the final HTML:
-     * - 3+ consecutive <br> (including <br/> / <br /> from the source) collapse to 2;
-     * - leading/trailing <br> inside a paragraph are removed.
-     * Code content is immune: <br> inside <code> is escaped as &lt;br&gt;.
+     * Emits a raw HTML block starting at `hit.index` of lines[i], consuming
+     * following lines until the element is balanced. Text after the block on
+     * the closing line is pushed back for markdown processing.
+     * @returns the index of the last consumed line
      */
-    static normalizeBreaks(html) {
-        return html
-            .replace(/(?:<br\s*\/?>\s*){3,}/gi, '<br><br>')
-            .replace(/<p>(?:<br\s*\/?>\s*)+/gi, '<p>')
-            .replace(/(?:\s*<br\s*\/?>)+<\/p>/gi, '</p>')
-            .replace(/<p>\s*<\/p>/gi, '');
+    static emitHtmlBlock(lines, i, hit, out) {
+        const line = lines[i];
+        // HTML comment: raw until '-->'
+        if (hit.isComment) {
+            let end = line.indexOf('-->', hit.index);
+            if (end !== -1) {
+                out.push(line.slice(hit.index, end + 3));
+                return this.pushBack(lines, i, line.slice(end + 3));
+            }
+            out.push(line.slice(hit.index));
+            while (++i < lines.length) {
+                end = lines[i].indexOf('-->');
+                if (end !== -1) {
+                    out.push(lines[i].slice(0, end + 3));
+                    return this.pushBack(lines, i, lines[i].slice(end + 3));
+                }
+                out.push(lines[i]);
+            }
+            return lines.length - 1; // unterminated: consumed to EOF
+        }
+        // Stray closing tag or void tag: emit just the tag, resume after '>'
+        if (hit.isClose || this.htmlVoidTags.has(hit.tag)) {
+            const gt = line.indexOf('>', hit.index);
+            const end = gt === -1 ? line.length : gt + 1;
+            out.push(line.slice(hit.index, end));
+            return this.pushBack(lines, i, line.slice(end));
+        }
+        // Opening block tag: raw until the element is balanced (depth === 0)
+        let [depth, split] = this.scanHtmlDepth(line.slice(hit.index), hit.tag, 0);
+        if (split !== -1) {
+            out.push(line.slice(hit.index, hit.index + split));
+            return this.pushBack(lines, i, line.slice(hit.index + split));
+        }
+        out.push(line.slice(hit.index));
+        while (depth > 0 && ++i < lines.length) {
+            [depth, split] = this.scanHtmlDepth(lines[i], hit.tag, depth);
+            if (split !== -1) {
+                out.push(lines[i].slice(0, split));
+                return this.pushBack(lines, i, lines[i].slice(split));
+            }
+            out.push(lines[i]);
+        }
+        return Math.min(i, lines.length - 1);
     }
     static parseBlocks(lines, opts) {
         const out = [];
@@ -117,6 +261,22 @@ class MarkdownUtils {
                 flush();
                 continue;
             }
+            // --- Raw HTML block passthrough (only with escaping disabled) ------------
+            // A block-level HTML element found ANYWHERE in the line starts a raw
+            // block: text before it joins the current paragraph, the element is
+            // emitted as-is (plain newlines, no <p>, no <br>) until balanced, and
+            // any text after the closing tag resumes markdown processing.
+            if (!opts.escapeHtml && line.includes('<')) {
+                const hit = this.findHtmlBlockStart(line);
+                if (hit) {
+                    const before = line.slice(0, hit.index).trim();
+                    if (before)
+                        paragraph.push(before);
+                    flush();
+                    i = this.emitHtmlBlock(lines, i, hit, out);
+                    continue;
+                }
+            }
             // --- ATX heading -------------------------------------------------------
             const heading = trimmed.match(/^(#{1,6})\s+(.+?)\s*#*\s*$/);
             if (heading) {