@arsedizioni/ars-utils 22.6.86 → 22.6.88

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

@@ -1,591 +1,446 @@
-import * as i0 from '@angular/core';
-import { inject, Pipe } from '@angular/core';
-import { DomSanitizer } from '@angular/platform-browser';
-
-/**
- * Zero-dependency Markdown to HTML converter.
- *
- * Design goals:
- * - Single line-based pass over blocks (no repeated full-string regex passes).
- * - Inline formatting never touches code spans / code blocks (stash & restore).
- * - No HTML entity escaping by default in normal text: the source passes as-is.
- *   Exception: the content of code spans / code blocks is ALWAYS escaped, so
- *   things like List<string> render correctly (the browser displays the
- *   original characters; entities never reach the user or the clipboard).
- *   Opt-in full escaping via { escapeHtml: true } for untrusted input.
- * - URL sanitization on links/images (javascript:, vbscript:, data: are dropped).
- * - Bounded result cache for repeated renders (Angular change detection friendly).
- *
- * 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, 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.
- * - Setext headings (=== / ---) are not supported, use # syntax.
- * - Reference-style links [text][ref] are not supported.
- */
-class MarkdownUtils {
-    // #region Cache
-    static { this.cache = new Map(); }
-    static { this.CACHE_MAX = 200; }
-    /** Clears the internal result cache. */
-    static clearCache() {
-        this.cache.clear();
-    }
-    // #endregion
-    // #region Public API
-    /**
-     * Convert markdown to HTML.
-     * @param markdown : the markdown source
-     * @param options  : conversion options
-     * @returns        : the HTML string ('' when input is falsy)
-     */
-    static toHtml(markdown, options) {
-        if (!markdown)
-            return '';
-        const opts = { escapeHtml: false, breaks: true, ...options };
-        const key = `${opts.escapeHtml ? 1 : 0}${opts.breaks ? 1 : 0}|${markdown}`;
-        const hit = this.cache.get(key);
-        if (hit !== undefined)
-            return hit;
-        // Normalize line endings and fix glued sentence punctuation ("dettaglio!Ecco").
-        // Only when the next char is uppercase (a new sentence), so URLs with query
-        // strings ("/page?id=1") and code identifiers are left untouched.
-        const source = markdown
-            .replace(/\r\n?/g, '\n')
-            .replace(/([a-zà-ÿ][!?])([A-ZÀ-Þ])/g, '$1 $2');
-        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
-        }
-        this.cache.set(key, html);
-        return html;
-    }
-    // #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;
-    }
-    /**
-     * 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 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 = [];
-        let paragraph = [];
-        const flush = () => {
-            if (paragraph.length > 0) {
-                const sep = opts.breaks ? '<br>' : ' ';
-                out.push(`<p>${paragraph.map(l => this.inline(l, opts)).join(sep)}</p>`);
-                paragraph = [];
-            }
-        };
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const trimmed = line.trim();
-            // --- Fenced code block -------------------------------------------------
-            const fence = trimmed.match(/^```([\w+-]+)?\s*$/);
-            if (fence) {
-                flush();
-                const lang = fence[1] ? ` class="language-${fence[1]}"` : '';
-                const code = [];
-                i++;
-                while (i < lines.length && !/^```\s*$/.test(lines[i].trim())) {
-                    code.push(lines[i]);
-                    i++;
-                }
-                out.push(`<pre><code${lang}>${this.escape(code.join('\n'))}</code></pre>`);
-                continue;
-            }
-            // --- Blank line --------------------------------------------------------
-            if (!trimmed) {
-                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) {
-                flush();
-                const level = heading[1].length;
-                out.push(`<h${level}>${this.inline(heading[2], opts)}</h${level}>`);
-                continue;
-            }
-            // --- Horizontal rule ---------------------------------------------------
-            if (/^(?:-{3,}|\*{3,}|_{3,})$/.test(trimmed)) {
-                flush();
-                out.push('<hr>');
-                continue;
-            }
-            // --- Blockquote (consecutive lines, one level stripped, recursive) ------
-            if (/^>\s?/.test(trimmed)) {
-                flush();
-                const quoted = [];
-                while (i < lines.length && /^>\s?/.test(lines[i].trim())) {
-                    quoted.push(lines[i].trim().replace(/^>\s?/, ''));
-                    i++;
-                }
-                i--;
-                out.push(`<blockquote>${this.parseBlocks(quoted, opts)}</blockquote>`);
-                continue;
-            }
-            // --- Table (header row + separator row) ---------------------------------
-            if (trimmed.includes('|') &&
-                i + 1 < lines.length &&
-                lines[i + 1].includes('-') &&
-                /^\|?[\s:\-|]+\|?$/.test(lines[i + 1].trim())) {
-                flush();
-                const aligns = this.tableAligns(lines[i + 1].trim());
-                const head = this.tableRow(trimmed, 'th', aligns, opts);
-                const body = [];
-                i += 2;
-                while (i < lines.length && lines[i].trim().includes('|')) {
-                    body.push(this.tableRow(lines[i].trim(), 'td', aligns, opts));
-                    i++;
-                }
-                i--;
-                out.push(`<table>\n<thead>\n${head}\n</thead>` +
-                    (body.length > 0 ? `\n<tbody>\n${body.join('\n')}\n</tbody>` : '') +
-                    `\n</table>`);
-                continue;
-            }
-            // --- List ---------------------------------------------------------------
-            if (MarkdownUtils.listItemRe.test(line)) {
-                flush();
-                const [html, last] = this.parseList(lines, i, opts);
-                out.push(html);
-                i = last;
-                continue;
-            }
-            // --- Plain text: accumulate into current paragraph ----------------------
-            paragraph.push(trimmed);
-        }
-        flush();
-        return out.join('\n');
-    }
-    // #endregion
-    // #region Lists
-    /** Matches "- item", "* item", "+ item", "1. item", "1) item" with leading indent. */
-    static { this.listItemRe = /^(\s*)([-*+]|\d+[.)])\s+(.*)$/; }
-    /**
-     * Gathers the contiguous list block starting at `start`, builds it (with
-     * nesting) and returns [html, indexOfLastConsumedLine].
-     */
-    static parseList(lines, start, opts) {
-        const block = [];
-        let i = start;
-        while (i < lines.length) {
-            const l = lines[i];
-            if (!l.trim())
-                break; // blank line ends the list
-            if (this.listItemRe.test(l) || /^\s{2,}\S/.test(l)) {
-                block.push(l);
-                i++;
-            }
-            else
-                break;
-        }
-        return [this.buildList(block, opts), i - 1];
-    }
-    static buildList(block, opts) {
-        const first = block[0].match(this.listItemRe);
-        const baseIndent = first[1].length;
-        const ordered = /^\d/.test(first[2]);
-        const startNum = ordered ? parseInt(first[2], 10) : 1;
-        const items = [];
-        for (const l of block) {
-            const m = l.match(this.listItemRe);
-            if (m && m[1].length <= baseIndent) {
-                items.push({ text: m[3], childLines: [] });
-            }
-            else if (items.length > 0) {
-                // Continuation or nested content: strip one nesting level of indent
-                items[items.length - 1].childLines.push(l.length > baseIndent + 2 ? l.slice(baseIndent + 2) : l.trim());
-            }
-        }
-        const lis = items.map(item => {
-            let inner;
-            // GFM task list: - [ ] / - [x]
-            const task = item.text.match(/^\[([ xX])\]\s+(.*)$/);
-            if (task) {
-                const checked = task[1] !== ' ' ? ' checked' : '';
-                inner = `<input type="checkbox" disabled${checked}> ${this.inline(task[2], opts)}`;
-            }
-            else {
-                inner = this.inline(item.text, opts);
-            }
-            if (item.childLines.length > 0) {
-                inner += '\n' + this.parseBlocks(item.childLines, opts);
-            }
-            return `<li>${inner}</li>`;
-        });
-        const tag = ordered ? 'ol' : 'ul';
-        const startAttr = ordered && startNum > 1 ? ` start="${startNum}"` : '';
-        return `<${tag}${startAttr}>\n${lis.join('\n')}\n</${tag}>`;
-    }
-    // #endregion
-    // #region Tables
-    static tableAligns(separator) {
-        return separator
-            .replace(/^\||\|$/g, '')
-            .split('|')
-            .map(cell => {
-            const t = cell.trim();
-            if (t.startsWith(':') && t.endsWith(':'))
-                return 'center';
-            if (t.endsWith(':'))
-                return 'right';
-            if (t.startsWith(':'))
-                return 'left';
-            return undefined;
-        });
-    }
-    static tableRow(row, tag, aligns, opts) {
-        const cells = row.replace(/^\||\|$/g, '').split('|').map(c => c.trim());
-        const cellsHtml = cells
-            .map((cell, j) => {
-            const align = aligns[j] ? ` align="${aligns[j]}"` : '';
-            return `<${tag}${align}>${this.inline(cell, opts)}</${tag}>`;
-        })
-            .join('');
-        return `<tr>${cellsHtml}</tr>`;
-    }
-    // #endregion
-    // #region Inline formatting
-    /**
-     * Applies inline markdown to a single text segment.
-     * Generated HTML (code, links, images, autolinks) is stashed behind \u0000
-     * placeholders so later regex passes can never corrupt it.
-     */
-    static inline(text, opts) {
-        const store = [];
-        const stash = (html) => `\u0000${store.push(html) - 1}\u0000`;
-        // 1. Inline code: stash first so later passes can't touch it.
-        //    Content is ALWAYS escaped so <, >, & inside code survive in the DOM
-        //    (the browser renders entities back to the original characters).
-        let s = text.replace(/`([^`]+)`/g, (_m, code) => stash(`<code>${this.escape(code)}</code>`));
-        // 2. Escape raw HTML as entities (opt-in only)
-        if (opts.escapeHtml)
-            s = this.escape(s);
-        // 3. Images: ![alt](url "title")
-        s = s.replace(/!\[([^\]]*)\]\(\s*([^)\s]+)(?:\s+(?:"|&quot;)(.+?)(?:"|&quot;))?\s*\)/g, (_m, alt, src, title) => {
-            const url = this.safeUrl(src);
-            if (!url)
-                return alt;
-            const t = title ? ` title="${this.escapeAttr(title)}"` : '';
-            return stash(`<img src="${url}" alt="${this.escapeAttr(alt)}"${t} loading="lazy">`);
-        });
-        // 4. Links: [text](url "title")
-        s = s.replace(/\[([^\]]+)\]\(\s*([^)\s]+)(?:\s+(?:"|&quot;)(.+?)(?:"|&quot;))?\s*\)/g, (_m, txt, href, title) => {
-            const url = this.safeUrl(href);
-            if (!url)
-                return txt;
-            const t = title ? ` title="${this.escapeAttr(title)}"` : '';
-            return stash(`<a href="${url}"${t} target="_blank" rel="noopener noreferrer">${txt}</a>`);
-        });
-        // 5. Autolink remaining bare URLs (markdown links are already stashed)
-        s = s.replace(/https?:\/\/[^\s<>"']+/g, url => stash(`<a href="${url}" target="_blank" rel="noopener noreferrer">${url}</a>`));
-        // 6. Bold / italic / strikethrough.
-        //    Delimiters must hug the text; underscore emphasis only at word
-        //    boundaries so identifiers like snake_case are left untouched.
-        s = s.replace(/\*\*\*(?=\S)([\s\S]*?\S)\*\*\*/g, '<strong><em>$1</em></strong>');
-        s = s.replace(/(?<![\w*])___(?=\S)([\s\S]*?\S)___(?![\w*])/g, '<strong><em>$1</em></strong>');
-        s = s.replace(/\*\*(?=\S)([\s\S]*?\S)\*\*/g, '<strong>$1</strong>');
-        s = s.replace(/(?<![\w*])__(?=\S)([\s\S]*?\S)__(?![\w*])/g, '<strong>$1</strong>');
-        s = s.replace(/\*(?=\S)([^*\n]*?\S)\*/g, '<em>$1</em>');
-        s = s.replace(/(?<![\w_])_(?=\S)([^_\n]*?\S)_(?![\w_])/g, '<em>$1</em>');
-        s = s.replace(/~~(?=\S)([\s\S]*?\S)~~/g, '<del>$1</del>');
-        // 7. Restore stashed HTML
-        return s.replace(/\u0000(\d+)\u0000/g, (_m, idx) => store[Number(idx)] ?? '');
-    }
-    // #endregion
-    // #region Security helpers
-    /** Escapes quotes for safe interpolation inside a double-quoted HTML attribute. */
-    static escapeAttr(s) {
-        return s.replace(/&(?!(?:amp|lt|gt|quot|#\d+);)/g, '&amp;').replace(/"/g, '&quot;');
-    }
-    /** Escapes &, <, > and " for safe HTML interpolation. */
-    static escape(s) {
-        return s
-            .replace(/&/g, '&amp;')
-            .replace(/</g, '&lt;')
-            .replace(/>/g, '&gt;')
-            .replace(/"/g, '&quot;');
-    }
-    /**
-     * Returns a sanitized URL or undefined when the scheme is dangerous.
-     * Blocks javascript:, vbscript: and data: (also when obfuscated with
-     * whitespace/control characters, e.g. "java\tscript:").
-     */
-    static safeUrl(url) {
-        const compact = url.replace(/[\s\u0000-\u001f]/g, '');
-        if (/^(javascript|vbscript|data):/i.test(compact))
-            return undefined;
-        return url.replace(/"/g, '%22');
-    }
-    // #endregion
-    // #region Clipboard
-    /**
-     * Copies markdown content to the clipboard in two flavors:
-     * - text/html  : the rendered HTML (rich paste into Word, Outlook, Gmail...)
-     * - text/plain : the original markdown source (paste into editors, IDEs...)
-     * @param markdown : the markdown source
-     * @param options  : conversion options for the HTML flavor
-     * @returns        : true on success
-     */
-    static async copyToClipboard(markdown, options) {
-        if (!markdown || typeof navigator === 'undefined' || !navigator.clipboard)
-            return false;
-        try {
-            if (typeof ClipboardItem !== 'undefined') {
-                const html = this.toHtml(markdown, options);
-                await navigator.clipboard.write([
-                    new ClipboardItem({
-                        'text/html': new Blob([html], { type: 'text/html' }),
-                        'text/plain': new Blob([markdown], { type: 'text/plain' }),
-                    }),
-                ]);
-            }
-            else {
-                // Older engines: plain text only
-                await navigator.clipboard.writeText(markdown);
-            }
-            return true;
-        }
-        catch {
-            // Clipboard API requires a secure context and user activation
-            return false;
-        }
-    }
-    /**
-     * Copies plain text (e.g. the content of a single code block) to the clipboard.
-     * @param text : the text to copy
-     * @returns    : true on success
-     */
-    static async copyText(text) {
-        if (!text || typeof navigator === 'undefined' || !navigator.clipboard)
-            return false;
-        try {
-            await navigator.clipboard.writeText(text);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Extracts the visible plain text from a rendered element
-     * (what the user sees, entities already decoded by the browser).
-     * @param element : the element hosting the rendered markdown
-     * @returns       : the plain text
-     */
-    static elementToText(element) {
-        return element.innerText ?? element.textContent ?? '';
-    }
-}
-
-/**
- * Pipe that converts a Markdown string to sanitized HTML using `MarkdownUtils.toHtml`.
- *
- * Usage: `{{ text | formatMarkdown }}`
- */
-class FormatMarkdownPipe {
-    constructor() {
-        this.sanitizer = inject(DomSanitizer);
-    }
-    /**
-     * Transforms a Markdown string into sanitized HTML.
-     * @param value - The Markdown input to convert. Treated as an empty string when `undefined`.
-     * @returns A `SafeHtml` value that can be rendered with `[innerHTML]`.
-     */
-    transform(value) {
-        return this.sanitizer.bypassSecurityTrustHtml(MarkdownUtils.toHtml(value ?? '', { escapeHtml: false }));
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: FormatMarkdownPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
-    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.1.7", ngImport: i0, type: FormatMarkdownPipe, isStandalone: true, name: "formatMarkdown" }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: FormatMarkdownPipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'formatMarkdown',
-                    standalone: true
-                }]
-        }] });
-
-/*
- * Public API Surface of @arsedizioni/ars-utils/core.markdown
- */
-
-/**
- * Generated bundle index. Do not edit.
- */
-
+import * as i0 from "@angular/core";
+import { Pipe, SecurityContext, inject } from "@angular/core";
+import { DomSanitizer } from "@angular/platform-browser";
+var MarkdownUtils = class MarkdownUtils {
+	static {
+		this.cache = /* @__PURE__ */ new Map();
+	}
+	static {
+		this.CACHE_MAX = 200;
+	}
+	static clearCache() {
+		this.cache.clear();
+	}
+	static toHtml(markdown, options) {
+		if (!markdown) return "";
+		const opts = {
+			escapeHtml: false,
+			breaks: true,
+			...options
+		};
+		const key = `${opts.escapeHtml ? 1 : 0}${opts.breaks ? 1 : 0}|${markdown}`;
+		const hit = this.cache.get(key);
+		if (hit !== void 0) return hit;
+		const source = markdown.replace(/\r\n?/g, "\n").replace(/([a-zà-ÿ][!?])([A-ZÀ-Þ])/g, "$1 $2");
+		const html = this.parseBlocks(source.split("\n"), opts).trim();
+		if (this.cache.size >= this.CACHE_MAX) this.cache.delete(this.cache.keys().next().value);
+		this.cache.set(key, html);
+		return html;
+	}
+	static {
+		this.htmlBlockTags = /* @__PURE__ */ 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"
+		]);
+	}
+	static {
+		this.htmlVoidTags = /* @__PURE__ */ new Set([
+			"hr",
+			"col",
+			"img",
+			"input"
+		]);
+	}
+	static {
+		this.htmlBlockScanRe = new RegExp(`<(\\/?)(${[...MarkdownUtils.htmlBlockTags].join("|")})(?=[\\s/>])`, "gi");
+	}
+	static findHtmlBlockStart(line) {
+		let comment = line.indexOf("<!--");
+		while (comment !== -1 && this.insideCodeSpan(line, comment)) comment = line.indexOf("<!--", comment + 4);
+		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
+		} : void 0;
+	}
+	static insideCodeSpan(line, index) {
+		let count = 0;
+		for (let i = 0; i < index; i++) if (line.charCodeAt(i) === 96) count++;
+		return (count & 1) === 1;
+	}
+	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);
+			if (gt !== -1 && lower.charCodeAt(gt - 1) === 47) {
+				if (depth === 0) return [0, gt + 1];
+			} else depth++;
+			i = gt === -1 ? lower.length : gt + 1;
+		} else i++;
+		return [depth, -1];
+	}
+	static isTagBoundary(s, idx) {
+		if (idx >= s.length) return true;
+		const c = s.charCodeAt(idx);
+		return c === 62 || c === 47 || c === 32 || c === 9;
+	}
+	static pushBack(lines, i, remainder) {
+		if (remainder.trim()) {
+			lines[i] = remainder;
+			return i - 1;
+		}
+		return i;
+	}
+	static emitHtmlBlock(lines, i, hit, out) {
+		const line = lines[i];
+		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;
+		}
+		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));
+		}
+		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 = [];
+		let paragraph = [];
+		const flush = () => {
+			if (paragraph.length > 0) {
+				const sep = opts.breaks ? "<br>" : " ";
+				out.push(`<p>${paragraph.map((l) => this.inline(l, opts)).join(sep)}</p>`);
+				paragraph = [];
+			}
+		};
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i];
+			const trimmed = line.trim();
+			const fence = trimmed.match(/^```([\w+-]+)?\s*$/);
+			if (fence) {
+				flush();
+				const lang = fence[1] ? ` class="language-${fence[1]}"` : "";
+				const code = [];
+				i++;
+				while (i < lines.length && !/^```\s*$/.test(lines[i].trim())) {
+					code.push(lines[i]);
+					i++;
+				}
+				out.push(`<pre><code${lang}>${this.escape(code.join("\n"))}</code></pre>`);
+				continue;
+			}
+			if (!trimmed) {
+				flush();
+				continue;
+			}
+			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;
+				}
+			}
+			const heading = trimmed.match(/^(#{1,6})\s+(.+?)\s*#*\s*$/);
+			if (heading) {
+				flush();
+				const level = heading[1].length;
+				out.push(`<h${level}>${this.inline(heading[2], opts)}</h${level}>`);
+				continue;
+			}
+			if (/^(?:-{3,}|\*{3,}|_{3,})$/.test(trimmed)) {
+				flush();
+				out.push("<hr>");
+				continue;
+			}
+			if (/^>\s?/.test(trimmed)) {
+				flush();
+				const quoted = [];
+				while (i < lines.length && /^>\s?/.test(lines[i].trim())) {
+					quoted.push(lines[i].trim().replace(/^>\s?/, ""));
+					i++;
+				}
+				i--;
+				out.push(`<blockquote>${this.parseBlocks(quoted, opts)}</blockquote>`);
+				continue;
+			}
+			if (trimmed.includes("|") && i + 1 < lines.length && lines[i + 1].includes("-") && /^\|?[\s:\-|]+\|?$/.test(lines[i + 1].trim())) {
+				flush();
+				const aligns = this.tableAligns(lines[i + 1].trim());
+				const head = this.tableRow(trimmed, "th", aligns, opts);
+				const body = [];
+				i += 2;
+				while (i < lines.length && lines[i].trim().includes("|")) {
+					body.push(this.tableRow(lines[i].trim(), "td", aligns, opts));
+					i++;
+				}
+				i--;
+				out.push(`<table>\n<thead>\n${head}\n</thead>` + (body.length > 0 ? `\n<tbody>\n${body.join("\n")}\n</tbody>` : "") + `\n</table>`);
+				continue;
+			}
+			if (MarkdownUtils.listItemRe.test(line)) {
+				flush();
+				const [html, last] = this.parseList(lines, i, opts);
+				out.push(html);
+				i = last;
+				continue;
+			}
+			paragraph.push(trimmed);
+		}
+		flush();
+		return out.join("\n");
+	}
+	static {
+		this.listItemRe = /^(\s*)([-*+]|\d+[.)])\s+(.*)$/;
+	}
+	static parseList(lines, start, opts) {
+		const block = [];
+		let i = start;
+		while (i < lines.length) {
+			const l = lines[i];
+			if (!l.trim()) break;
+			if (this.listItemRe.test(l) || /^\s{2,}\S/.test(l)) {
+				block.push(l);
+				i++;
+			} else break;
+		}
+		return [this.buildList(block, opts), i - 1];
+	}
+	static buildList(block, opts) {
+		const first = block[0].match(this.listItemRe);
+		const baseIndent = first[1].length;
+		const ordered = /^\d/.test(first[2]);
+		const startNum = ordered ? parseInt(first[2], 10) : 1;
+		const items = [];
+		for (const l of block) {
+			const m = l.match(this.listItemRe);
+			if (m && m[1].length <= baseIndent) items.push({
+				text: m[3],
+				childLines: []
+			});
+			else if (items.length > 0) items[items.length - 1].childLines.push(l.length > baseIndent + 2 ? l.slice(baseIndent + 2) : l.trim());
+		}
+		const lis = items.map((item) => {
+			let inner;
+			const task = item.text.match(/^\[([ xX])\]\s+(.*)$/);
+			if (task) inner = `<input type="checkbox" disabled${task[1] !== " " ? " checked" : ""}> ${this.inline(task[2], opts)}`;
+			else inner = this.inline(item.text, opts);
+			if (item.childLines.length > 0) inner += "\n" + this.parseBlocks(item.childLines, opts);
+			return `<li>${inner}</li>`;
+		});
+		const tag = ordered ? "ol" : "ul";
+		return `<${tag}${ordered && startNum > 1 ? ` start="${startNum}"` : ""}>\n${lis.join("\n")}\n</${tag}>`;
+	}
+	static tableAligns(separator) {
+		return separator.replace(/^\||\|$/g, "").split("|").map((cell) => {
+			const t = cell.trim();
+			if (t.startsWith(":") && t.endsWith(":")) return "center";
+			if (t.endsWith(":")) return "right";
+			if (t.startsWith(":")) return "left";
+		});
+	}
+	static tableRow(row, tag, aligns, opts) {
+		return `<tr>${row.replace(/^\||\|$/g, "").split("|").map((c) => c.trim()).map((cell, j) => {
+			return `<${tag}${aligns[j] ? ` align="${aligns[j]}"` : ""}>${this.inline(cell, opts)}</${tag}>`;
+		}).join("")}</tr>`;
+	}
+	static inline(text, opts) {
+		const store = [];
+		const stash = (html) => `\u0000${store.push(html) - 1}\u0000`;
+		let s = text.replace(/`([^`]+)`/g, (_m, code) => stash(`<code>${this.escape(code)}</code>`));
+		if (opts.escapeHtml) s = this.escape(s);
+		s = s.replace(/!\[([^\]]*)\]\(\s*([^)\s]+)(?:\s+(?:"|&quot;)(.+?)(?:"|&quot;))?\s*\)/g, (_m, alt, src, title) => {
+			const url = this.safeUrl(src);
+			if (!url) return alt;
+			const t = title ? ` title="${this.escapeAttr(title)}"` : "";
+			return stash(`<img src="${url}" alt="${this.escapeAttr(alt)}"${t} loading="lazy">`);
+		});
+		s = s.replace(/\[([^\]]+)\]\(\s*([^)\s]+)(?:\s+(?:"|&quot;)(.+?)(?:"|&quot;))?\s*\)/g, (_m, txt, href, title) => {
+			const url = this.safeUrl(href);
+			if (!url) return txt;
+			const t = title ? ` title="${this.escapeAttr(title)}"` : "";
+			return stash(`<a href="${url}"${t} target="_blank" rel="noopener noreferrer">${txt}</a>`);
+		});
+		s = s.replace(/https?:\/\/[^\s<>"']+/g, (url) => stash(`<a href="${url}" target="_blank" rel="noopener noreferrer">${url}</a>`));
+		s = s.replace(/\*\*\*(?=\S)([\s\S]*?\S)\*\*\*/g, "<strong><em>$1</em></strong>");
+		s = s.replace(/(?<![\w*])___(?=\S)([\s\S]*?\S)___(?![\w*])/g, "<strong><em>$1</em></strong>");
+		s = s.replace(/\*\*(?=\S)([\s\S]*?\S)\*\*/g, "<strong>$1</strong>");
+		s = s.replace(/(?<![\w*])__(?=\S)([\s\S]*?\S)__(?![\w*])/g, "<strong>$1</strong>");
+		s = s.replace(/\*(?=\S)([^*\n]*?\S)\*/g, "<em>$1</em>");
+		s = s.replace(/(?<![\w_])_(?=\S)([^_\n]*?\S)_(?![\w_])/g, "<em>$1</em>");
+		s = s.replace(/~~(?=\S)([\s\S]*?\S)~~/g, "<del>$1</del>");
+		return s.replace(/\u0000(\d+)\u0000/g, (_m, idx) => store[Number(idx)] ?? "");
+	}
+	static escapeAttr(s) {
+		return s.replace(/&(?!(?:amp|lt|gt|quot|#\d+);)/g, "&amp;").replace(/"/g, "&quot;");
+	}
+	static escape(s) {
+		return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+	}
+	static safeUrl(url) {
+		const compact = url.replace(/[\s\u0000-\u001f]/g, "");
+		if (/^(javascript|vbscript|data):/i.test(compact)) return void 0;
+		return url.replace(/"/g, "%22");
+	}
+	static async copyToClipboard(markdown, options) {
+		if (!markdown || typeof navigator === "undefined" || !navigator.clipboard) return false;
+		try {
+			if (typeof ClipboardItem !== "undefined") {
+				const html = this.toHtml(markdown, options);
+				await navigator.clipboard.write([new ClipboardItem({
+					"text/html": new Blob([html], { type: "text/html" }),
+					"text/plain": new Blob([markdown], { type: "text/plain" })
+				})]);
+			} else await navigator.clipboard.writeText(markdown);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	static async copyText(text) {
+		if (!text || typeof navigator === "undefined" || !navigator.clipboard) return false;
+		try {
+			await navigator.clipboard.writeText(text);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	static elementToText(element) {
+		return element.innerText ?? element.textContent ?? "";
+	}
+};
+var FormatMarkdownPipe = class FormatMarkdownPipe {
+	constructor() {
+		this.sanitizer = inject(DomSanitizer);
+	}
+	transform(value) {
+		const html = MarkdownUtils.toHtml(value ?? "", { escapeHtml: false });
+		const clean = this.sanitizer.sanitize(SecurityContext.HTML, html) ?? "";
+		return this.sanitizer.bypassSecurityTrustHtml(clean);
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: FormatMarkdownPipe,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Pipe
+		});
+	}
+	static {
+		this.ɵpipe = i0.ɵɵngDeclarePipe({
+			minVersion: "14.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: FormatMarkdownPipe,
+			isStandalone: true,
+			name: "formatMarkdown"
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: FormatMarkdownPipe,
+	decorators: [{
+		type: Pipe,
+		args: [{
+			name: "formatMarkdown",
+			standalone: true
+		}]
+	}]
+});
 export { FormatMarkdownPipe, MarkdownUtils };
-//# sourceMappingURL=arsedizioni-ars-utils-core.markdown.mjs.map
+
+//# sourceMappingURL=arsedizioni-ars-utils-core.markdown.mjs.map