@arsedizioni/ars-utils 22.1.5 → 22.5.2

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

@@ -0,0 +1,591 @@
+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.3", ngImport: i0, type: FormatMarkdownPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "22.1.3", ngImport: i0, type: FormatMarkdownPipe, isStandalone: true, name: "formatMarkdown" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", 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.
+ */
+
+export { FormatMarkdownPipe, MarkdownUtils };
+//# sourceMappingURL=arsedizioni-ars-utils-core.markdown.mjs.map