@arsedizioni/ars-utils 22.0.15 → 22.0.16

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

@@ -2,7 +2,6 @@ import * as i0 from '@angular/core';
 import { Pipe, inject, makeEnvironmentProviders, Injectable, ElementRef, afterNextRender, Directive, input, DestroyRef, HostListener, output, forwardRef, EventEmitter, signal, computed, Service, RendererFactory2 } from '@angular/core';
 import { parseISO, parse, format, getYear, getMonth, getDate, getDay, getDaysInMonth, addYears, addMonths, addDays, formatISO, isDate, isValid, endOfDay } from 'date-fns';
 import { it } from 'date-fns/locale';
-import { HttpParams } from '@angular/common/http';
 import { TZDate } from '@date-fns/tz';
 import { DomSanitizer } from '@angular/platform-browser';
 import { DateAdapter, MAT_DATE_LOCALE, MAT_DATE_FORMATS } from '@angular/material/core';
@@ -12,6 +11,376 @@ import { debounceTime } from 'rxjs/operators';
 import { NG_VALIDATORS } from '@angular/forms';
 import { SelectionModel } from '@angular/cdk/collections';
 
+/**
+ * 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.
+ *
+ * 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")
+        const source = markdown
+            .replace(/\r\n?/g, '\n')
+            .replace(/([A-Za-zÀ-ÿ][!?])([A-Za-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)
+    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;
+            }
+            // --- 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="${title}"` : '';
+            return stash(`<img src="${url}" alt="${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="${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 &, <, > 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 ?? '';
+    }
+}
+
 var DateFormat;
 (function (DateFormat) {
     DateFormat[DateFormat["Short"] = 1] = "Short";
@@ -28,6 +397,8 @@ var DateFormat;
     DateFormat[DateFormat["ShortISO8601"] = 12] = "ShortISO8601"; // yyyy-mm-dd
 })(DateFormat || (DateFormat = {}));
 class SystemUtils {
+    /** Shared collator for locale-aware, case-insensitive string comparison. */
+    static { this.collator = new Intl.Collator('it', { sensitivity: 'base', numeric: true }); }
     /**
      * Array find by key
      * @param array     : the array to scan
@@ -108,21 +479,23 @@ class SystemUtils {
      * Comparator factory for sorting arrays of objects by a given property key.
      * @param key   - Name of the property to sort by.
      * @param order - Sort direction: `'asc'` (default) or `'desc'`.
-     * @returns A comparator function that returns `0`, `1`, or `-1`.
+     * @returns A comparator function that returns a negative, zero, or positive number.
      */
     static arraySortCompare(key, order = 'asc') {
-        return function innerSort(a, b) {
-            if (!Object.prototype.hasOwnProperty.call(a, key) || !Object.prototype.hasOwnProperty.call(b, key)) {
+        const dir = order === 'desc' ? -1 : 1;
+        return (a, b) => {
+            const varA = a[key];
+            const varB = b[key];
+            if (varA === varB)
                 return 0;
+            if (varA === undefined || varA === null)
+                return -1 * dir;
+            if (varB === undefined || varB === null)
+                return 1 * dir;
+            if (typeof varA === 'string' && typeof varB === 'string') {
+                return SystemUtils.collator.compare(varA, varB) * dir;
             }
-            const varA = typeof a[key] === 'string' ? a[key].toUpperCase() : a[key];
-            const varB = typeof b[key] === 'string' ? b[key].toUpperCase() : b[key];
-            let comparison = 0;
-            if (varA > varB)
-                comparison = 1;
-            else if (varA < varB)
-                comparison = -1;
-            return order === 'desc' ? comparison * -1 : comparison;
+            return (varA > varB ? 1 : varA < varB ? -1 : 0) * dir;
         };
     }
     /**
@@ -153,17 +526,13 @@ class SystemUtils {
         return `${bytes} byte`;
     }
     /**
-     * Compare two string
+     * Compare two strings (case-insensitive, locale-aware, accent-insensitive).
      * @param a   : string a
      * @param b   : string b
      * @returns   : 0 if equals, 1 if bigger, -1 if lower
      */
     static compareString(a, b) {
-        if ((a ?? "").toLowerCase() > (b ?? "").toLowerCase())
-            return 1;
-        if ((a ?? "").toLowerCase() < (b ?? "").toLowerCase())
-            return -1;
-        return 0;
+        return this.collator.compare(a ?? '', b ?? '');
     }
     /**
      * Capitalize a string
@@ -191,7 +560,7 @@ class SystemUtils {
         return b;
     }
     /**
-     * Truncate a string
+     * Truncate a string at the last word boundary before `max`.
      * @param s     : the string to truncate
      * @param max   : the max number of chars
      * @returns     : the truncated string
@@ -201,13 +570,8 @@ class SystemUtils {
             return undefined;
         if (s.length < max)
             return s;
-        let i = max - 1;
-        while (i > 0) {
-            if (s[i] === ' ')
-                return s.slice(0, i);
-            i--;
-        }
-        return s;
+        const i = s.lastIndexOf(' ', max - 1);
+        return i > 0 ? s.slice(0, i) : s;
     }
     /**
      * Join a list of strings
@@ -280,247 +644,16 @@ class SystemUtils {
     static replaceAsHtml(s) {
         if (!s)
             return '';
-        const regex = /https?:\/\/.*[^\s]/ig;
-        const m = regex.exec(s);
-        if (!m || m.length === 0)
-            return s;
-        let result = s;
-        for (const v of m) {
-            result = result.replace(v, `<a href="${v}" target="_blank">${v}</a>`);
-        }
-        return result;
+        return s.replace(/https?:\/\/[^\s<]+/gi, v => `<a href="${v}" target="_blank" rel="noopener">${v}</a>`);
     }
     /**
      * Convert markdown to html
      * @param markdown : the markdown data
-     * @param escapeEntities : true to escape entities. Default is false
+     * @param escapeHtml : true to escape HTML. Default is false
      * @returns the html
      */
-    static markdownToHtml(markdown, escapeEntities = false) {
-        if (!markdown)
-            return '';
-        let html = markdown;
-        // 1. Escape HTML entities
-        if (escapeEntities) {
-            html = html.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-        }
-        // 2. Protect code from inline formatting by replacing it with placeholders.
-        //    Placeholders are HTML-comment shaped so block detection treats them correctly.
-        const codeStore = [];
-        const stash = (content) => `<!--C${codeStore.push(content) - 1}-->`;
-        // 2a. Fenced code blocks
-        html = html.replace(/```(\w+)?\n([\s\S]*?)```/g, (_match, lang, code) => {
-            const langClass = lang ? ` class="language-${lang}"` : '';
-            return stash(`<pre><code${langClass}>${code.trim()}</code></pre>`);
-        });
-        // 2b. Inline code
-        html = html.replace(/`([^`]+)`/g, (_match, code) => stash(`<code>${code}</code>`));
-        // 2c. Ensure a space between two letters separated by sentence punctuation
-        //     (! or ?), e.g. "dettaglio!Ecco" becomes "dettaglio! Ecco".
-        //     Period, comma, colon and semicolon are ignored.
-        html = html.replace(/([A-Za-zÀ-ÿ][!?])([A-Za-zÀ-ÿ])/g, '$1 $2');
-        // 3. Headers
-        html = html.replace(/^##### (.*$)/gim, '<h5>$1</h5>');
-        html = html.replace(/^#### (.*$)/gim, '<h4>$1</h4>');
-        html = html.replace(/^### (.*$)/gim, '<h3>$1</h3>');
-        html = html.replace(/^## (.*$)/gim, '<h2>$1</h2>');
-        html = html.replace(/^# (.*$)/gim, '<h1>$1</h1>');
-        // 4. Horizontal rules
-        html = html.replace(/^---+$/gim, '<hr>');
-        html = html.replace(/^\*\*\*+$/gim, '<hr>');
-        // 5. Links
-        html = html.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
-        // 6. Images
-        html = html.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '<img src="$2" alt="$1">');
-        // 7. Bold and Italic.
-        //    Delimiters must hug the text (no inner spaces) so spacing between
-        //    separate styled spans is preserved. Underscore emphasis only applies at
-        //    word boundaries, so identifiers like snake_case are left untouched.
-        html = html.replace(/\*\*\*(?=\S)([\s\S]*?\S)\*\*\*/g, '<strong><em>$1</em></strong>');
-        html = html.replace(/(?<![\w*])___(?=\S)([\s\S]*?\S)___(?![\w*])/g, '<strong><em>$1</em></strong>');
-        html = html.replace(/\*\*(?=\S)([\s\S]*?\S)\*\*/g, '<strong>$1</strong>');
-        html = html.replace(/(?<![\w*])__(?=\S)([\s\S]*?\S)__(?![\w*])/g, '<strong>$1</strong>');
-        html = html.replace(/\*(?=\S)([^*\n]*?\S)\*/g, '<em>$1</em>');
-        html = html.replace(/(?<![\w_])_(?=\S)([^_\n]*?\S)_(?![\w_])/g, '<em>$1</em>');
-        // 8. Strikethrough
-        html = html.replace(/~~(?=\S)([\s\S]*?\S)~~/g, '<del>$1</del>');
-        // 9. Blockquotes
-        html = html.replace(/^> (.*$)/gim, '<blockquote>$1</blockquote>');
-        // 10. Tables
-        html = this.markdownConvertTables(html);
-        // 11. Lists
-        html = this.markdownConvertLists(html);
-        // 12. Line breaks (two trailing spaces)
-        html = html.replace(/ {2}$/gm, '<br>');
-        // 13. Paragraphs (last block step, to avoid interfering with other elements)
-        html = this.markdownConvertParagraphs(html);
-        // 14. Collapse extra blank lines
-        html = html.replace(/\n{3,}/g, '\n\n');
-        // 15. Restore protected code placeholders
-        html = html.replace(/<!--C(\d+)-->/g, (_match, index) => codeStore[Number(index)] ?? '');
-        return html.trim();
-    }
-    /**
-     * Convert markdown table to html
-     * @param markdown: the markdown string
-     * @returns : the html
-     */
-    static markdownConvertTables(markdown) {
-        const lines = markdown.split('\n');
-        const result = [];
-        let inTable = false;
-        let tableRows = [];
-        let headerProcessed = false;
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i].trim();
-            if (line.includes('|') && line.length > 1) {
-                const nextLine = i + 1 < lines.length ? lines[i + 1].trim() : '';
-                const isHeaderSeparator = /^\|?[\s\-:|]+\|?$/.test(nextLine);
-                if (!inTable) {
-                    inTable = true;
-                    headerProcessed = false;
-                    tableRows = [];
-                }
-                if (isHeaderSeparator && !headerProcessed) {
-                    tableRows.push(this.markdownConvertTableRow(line, true));
-                    headerProcessed = true;
-                    i++;
-                }
-                else if (!isHeaderSeparator) {
-                    tableRows.push(this.markdownConvertTableRow(line, false));
-                }
-            }
-            else {
-                if (inTable && tableRows.length > 0) {
-                    result.push('<table>');
-                    result.push(...tableRows);
-                    result.push('</table>');
-                    tableRows = [];
-                    inTable = false;
-                }
-                result.push(line);
-            }
-        }
-        if (inTable && tableRows.length > 0) {
-            result.push('<table>');
-            result.push(...tableRows);
-            result.push('</table>');
-        }
-        return result.join('\n');
-    }
-    /**
-     * Convert a markdown table row to html
-     * @param row : the markdown row
-     * @param isHeader : true if is header
-     * @returns the html
-     */
-    static markdownConvertTableRow(row, isHeader) {
-        const cells = row.split('|').map(cell => cell.trim()).filter(cell => cell !== '');
-        const tag = isHeader ? 'th' : 'td';
-        const cellsHtml = cells.map(cell => `    <${tag}>${cell}</${tag}>`).join('\n');
-        return `  <tr>\n${cellsHtml}\n  </tr>`;
-    }
-    /**
-     * Convert a markdown list to html
-     * @param markdown : the markdown list
-     * @returns the html
-     */
-    static markdownConvertLists(markdown) {
-        markdown = markdown.replace(/^\* (.*$)/gim, '<li data-type="ul">$1</li>');
-        markdown = markdown.replace(/^- (.*$)/gim, '<li data-type="ul">$1</li>');
-        markdown = markdown.replace(/^\+ (.*$)/gim, '<li data-type="ul">$1</li>');
-        markdown = markdown.replace(/^\d+\. (.*$)/gim, '<li data-type="ol">$1</li>');
-        const lines = markdown.split('\n');
-        const result = [];
-        let currentList = { type: null, items: [] };
-        for (const line of lines) {
-            const ulMatch = line.match(/^<li data-type="ul">(.*)<\/li>$/);
-            const olMatch = line.match(/^<li data-type="ol">(.*)<\/li>$/);
-            if (ulMatch) {
-                if (currentList.type !== 'ul') {
-                    if (currentList.type && currentList.items.length > 0) {
-                        result.push(this.markdownWrapList(currentList.type, currentList.items));
-                    }
-                    currentList = { type: 'ul', items: [ulMatch[1]] };
-                }
-                else {
-                    currentList.items.push(ulMatch[1]);
-                }
-            }
-            else if (olMatch) {
-                if (currentList.type !== 'ol') {
-                    if (currentList.type && currentList.items.length > 0) {
-                        result.push(this.markdownWrapList(currentList.type, currentList.items));
-                    }
-                    currentList = { type: 'ol', items: [olMatch[1]] };
-                }
-                else {
-                    currentList.items.push(olMatch[1]);
-                }
-            }
-            else {
-                if (currentList.type && currentList.items.length > 0) {
-                    result.push(this.markdownWrapList(currentList.type, currentList.items));
-                    currentList = { type: null, items: [] };
-                }
-                result.push(line);
-            }
-        }
-        if (currentList.type && currentList.items.length > 0) {
-            result.push(this.markdownWrapList(currentList.type, currentList.items));
-        }
-        return result.join('\n');
-    }
-    /**
-     * Wrap a list
-     * @param type: the list type
-     * @param items : the item list
-     * @returns the html
-     */
-    static markdownWrapList(type, items) {
-        const listItems = items.map(item => `  <li>${item}</li>`).join('\n');
-        return `<${type}>\n${listItems}\n</${type}>`;
-    }
-    /**
-     * Convert markdown paragraphs to html
-     * @param markdown : the markdown paragraphs
-     * @returns the html
-     */
-    static markdownConvertParagraphs(markdown) {
-        // Block-level tags that must not be wrapped in a paragraph.
-        const blockTag = /^<\/?(h[1-6]|ul|ol|li|table|thead|tbody|tfoot|tr|td|th|pre|blockquote|hr|p|div)\b/i;
-        // A line consisting solely of a protected code placeholder is block-level.
-        const codePlaceholder = /^<!--C\d+-->$/;
-        const lines = markdown.split('\n');
-        const result = [];
-        // Buffer of consecutive plain-text lines that belong to the same paragraph.
-        let paragraph = [];
-        // Flush the buffered lines as a single paragraph, joining soft line breaks
-        // (single newlines) with a <br> so each source line keeps its own visual row.
-        const flushParagraph = () => {
-            if (paragraph.length > 0) {
-                result.push(`<p>${paragraph.join('<br>')}</p>`);
-                paragraph = [];
-            }
-        };
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed) {
-                flushParagraph();
-                result.push('');
-                continue;
-            }
-            if (blockTag.test(trimmed) || codePlaceholder.test(trimmed)) {
-                flushParagraph();
-                result.push(line);
-                continue;
-            }
-            // Plain text or inline-level content (strong, em, a, code, ...) becomes a paragraph.
-            // Lines separated by a single newline are merged into the same paragraph.
-            paragraph.push(trimmed);
-        }
-        flushParagraph();
-        return result.join('\n');
+    static markdownToHtml(markdown, escapeHtml = false) {
+        return MarkdownUtils.toHtml(markdown, { escapeHtml: escapeHtml });
     }
     /**
      * Compare two names
@@ -560,51 +693,44 @@ class SystemUtils {
      * @returns       :the ciphered text
      */
     static cipher(text, key, reverse = false) {
+        if (!text || !key)
+            return undefined;
         // Surrogate pair limit
         const bound = 0x10000;
-        // Create string from character codes
-        return String.fromCharCode.apply(null, 
-        // Turn string to character codes
-        text.split('').map((v, i) => {
-            // Get rotation from key
-            let rotation = key.charCodeAt(i % key.length);
-            // Are we decrypting?
+        const keyLen = key.length;
+        let result = '';
+        for (let i = 0; i < text.length; i++) {
+            let rotation = key.charCodeAt(i % keyLen);
             if (reverse)
                 rotation = -rotation;
-            // Return current character code + rotation
-            return (v.charCodeAt(0) + rotation + bound) % bound;
-        }));
+            result += String.fromCharCode((text.charCodeAt(i) + rotation + bound) % bound);
+        }
+        return result;
     }
     /**
-     * Clone an object using JSON
-     * @param obj : the oblect to clone
+     * Clone an object (deep copy).
+     * Uses native structuredClone: handles Date, Map, Set, typed arrays and circular references.
+     * @param obj : the object to clone
      * @returns   : a new object
      */
     static clone(obj) {
         if (!obj)
             return {};
-        return JSON.parse(JSON.stringify(obj));
+        return structuredClone(obj);
     }
     /**
-     * Creates a deep clone of an object by recursively copying all own properties.
+     * Creates a deep clone of an object.
      * @param obj  - The source object to clone.
-     * @param dest - Optional pre-allocated destination object; a new instance is created when omitted.
+     * @param dest - Optional pre-allocated destination object to merge the clone into.
      * @returns A deep copy of `obj`.
      */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static deepClone(obj, dest) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const cloneObj = dest ?? obj.constructor();
-        for (const attribute of Object.keys(obj)) {
-            const property = obj[attribute];
-            if (typeof property === 'object' && property !== null) {
-                cloneObj[attribute] = this.deepClone(property);
-            }
-            else {
-                cloneObj[attribute] = property;
-            }
+        const cloned = structuredClone(obj);
+        if (dest) {
+            Object.assign(dest, cloned);
+            return dest;
         }
-        return cloneObj;
+        return cloned;
     }
     /**
      * Returns `true` when `value` is a syntactically valid UUID string.
@@ -633,6 +759,10 @@ class SystemUtils {
      * @returns : the string UUID
      */
     static generateUUID() {
+        if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+            return crypto.randomUUID();
+        }
+        // Fallback (non-secure contexts)
         return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
             const r = (Math.random() * 16) | 0;
             const v = c === 'x' ? r : (r & 0x3) | 0x8;
@@ -650,27 +780,46 @@ class SystemUtils {
             return s;
         return `${s.slice(0, 8)}-${s.slice(8, 12)}-${s.slice(12, 16)}-${s.slice(16, 20)}-${s.slice(20)}`;
     }
+    /** Precompiled validation patterns. */
+    static { this.emailRegex = /^(?:[a-z0-9+!#$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+\/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$/i; }
+    static { this.urlRegex = /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)\/?$/i; }
     /**
-     * Parse a text and return true if is a valid email or null
+     * Parse a text and return true if it is a valid email (or empty)
      * @param value : email
      * @returns     : true if the email is valid or empty
      */
     static parseEmail(value) {
         if (!value)
             return true;
-        const regex = /(?:[a-z0-9+!#$%&'*+\/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+\/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])/gi;
-        return regex.test(value.trim().toLowerCase());
+        return this.emailRegex.test(value.trim().toLowerCase());
+    }
+    /**
+     * Parse a text containing one or more email addresses separated by `;` or `,`
+     * and return true if all of them are valid (or the text is empty).
+     * Empty items caused by double or trailing separators are ignored.
+     * @param value : the email list to parse (e.g. "a@b.it; c@d.it")
+     * @returns     : true if all emails are valid or the value is empty
+     */
+    static parseEmails(value) {
+        if (!value || value.trim().length === 0)
+            return true;
+        const items = value
+            .split(/[;,]/)
+            .map(e => e.trim().toLowerCase())
+            .filter(e => e.length > 0);
+        if (items.length === 0)
+            return false; // only separators, no addresses
+        return items.every(e => this.emailRegex.test(e));
     }
     /**
-     * Parse a text and return true if is a valid url or null
+     * Parse a text and return true if it is a valid url (or empty)
      * @param value : the url to parse
      * @returns     : true if the url is valid or empty
      */
     static parseUrl(value) {
         if (!value)
             return true;
-        const regex = new RegExp("(https?://)?([\\da-z.-]+)\\.([a-z.]{2,6})[/\\w .-]*/?");
-        return regex.test(value.trim().toLowerCase());
+        return this.urlRegex.test(value.trim().toLowerCase());
     }
     /**
      * Get date parts from a string value
@@ -874,16 +1023,8 @@ class SystemUtils {
     static getQueryStringValueByName(name) {
         if (!this.isBrowser())
             return undefined;
-        const url = window.location.href;
-        if (url.includes('?')) {
-            const httpParams = new HttpParams({ fromString: url.split('?')[1] });
-            const raw = httpParams.get(name);
-            if (!raw)
-                return undefined;
-            const v = decodeURIComponent(raw);
-            return v && v !== 'null' ? v : undefined;
-        }
-        return undefined;
+        const v = new URLSearchParams(window.location.search).get(name);
+        return v && v !== 'null' ? v : undefined;
     }
     /**
      * Generate a password
@@ -1061,6 +1202,8 @@ class SystemUtils {
         else
             return [];
     }
+    /** Cache for resolved color luminance results. */
+    static { this.colorLightCache = new Map(); }
     /**
      * Check if a color is light or dark
      * @param color : the color
@@ -1068,19 +1211,27 @@ class SystemUtils {
      * @returns true if the color is light
      */
     static isColorLight(color, minimumLuminance = 186) {
+        if (!this.isBrowser())
+            return true; // SSR fallback
+        const cacheKey = `${color}|${minimumLuminance}`;
+        const cached = this.colorLightCache.get(cacheKey);
+        if (cached !== undefined)
+            return cached;
         const tempDiv = document.createElement('div');
         tempDiv.style.color = color;
         document.body.appendChild(tempDiv);
         const rgb = getComputedStyle(tempDiv).color;
         document.body.removeChild(tempDiv);
         const result = rgb.match(/\d+/g);
-        if (!result || result.length < 3)
-            return true; // fallback
-        const r = parseInt(result[0], 10);
-        const g = parseInt(result[1], 10);
-        const b = parseInt(result[2], 10);
-        const luminance = 0.299 * r + 0.587 * g + 0.114 * b;
-        return luminance > minimumLuminance;
+        let light = true; // fallback
+        if (result && result.length >= 3) {
+            const r = parseInt(result[0], 10);
+            const g = parseInt(result[1], 10);
+            const b = parseInt(result[2], 10);
+            light = (0.299 * r + 0.587 * g + 0.114 * b) > minimumLuminance;
+        }
+        this.colorLightCache.set(cacheKey, light);
+        return light;
     }
 }