markstream-svelte 0.0.1-beta.1

package/dist/renderMarkdownHtml.js

@@ -0,0 +1,465 @@
+import { getMarkdown, isHtmlTagBlocked, isUnsafeHtmlUrl, NON_STRUCTURING_HTML_TAGS, normalizeCustomHtmlTagName, normalizeCustomHtmlTags, parseMarkdownToStructure, sanitizeHtmlAttrs, } from 'stream-markdown-parser';
+import { hydrateCustomTagContent } from './hydrateCustomTagContent';
+import { sanitizeHtmlContent } from './sanitizeHtmlContent';
+const DEFAULT_CACHE_KEY = 'markstream-svelte-html';
+const DEFAULT_CUSTOM_NODE_TAG = 'div';
+const markdownCache = new Map();
+const KNOWN_NODE_TYPES = new Set([
+    'admonition',
+    'blockquote',
+    'checkbox',
+    'checkbox_input',
+    'code_block',
+    'definition_item',
+    'definition_list',
+    'emoji',
+    'emphasis',
+    'footnote',
+    'footnote_reference',
+    'footnote_anchor',
+    'hardbreak',
+    'heading',
+    'highlight',
+    'html_block',
+    'html_inline',
+    'image',
+    'inline_code',
+    'insert',
+    'link',
+    'list',
+    'list_item',
+    'math_block',
+    'math_inline',
+    'paragraph',
+    'reference',
+    'strikethrough',
+    'strong',
+    'subscript',
+    'superscript',
+    'table',
+    'table_cell',
+    'table_row',
+    'text',
+    'thematic_break',
+]);
+export function renderMarkdownToHtml(input) {
+    var _a;
+    const normalizedTags = normalizeCustomHtmlTags([
+        ...(input.customHtmlTags || []),
+        ...(((_a = input.parseOptions) === null || _a === void 0 ? void 0 : _a.customHtmlTags) || []),
+    ]);
+    const ctx = createRenderContext({
+        allowHtml: input.allowHtml,
+        customHtmlTags: normalizedTags,
+        htmlPolicy: input.htmlPolicy,
+    });
+    const nodes = resolveParsedNodes(input, ctx);
+    return renderNodesToHtml(nodes, ctx);
+}
+export function renderNestedMarkdownToHtml(input, options = {}) {
+    const ctx = createRenderContext(options);
+    return renderNestedInputToHtml(input, ctx);
+}
+export function renderMarkdownNodesToHtml(nodes, options = {}) {
+    const ctx = createRenderContext(options);
+    return renderNodesToHtml(nodes, ctx);
+}
+export function renderMarkdownNodeToHtml(node, options = {}) {
+    const ctx = createRenderContext(options);
+    return renderNodeToHtml(node, ctx);
+}
+function resolveParsedNodes(input, ctx) {
+    var _a, _b;
+    if (Array.isArray(input.nodes))
+        return input.nodes;
+    const content = getString(input.content);
+    if (!content)
+        return [];
+    const normalizedTags = normalizeCustomHtmlTags([
+        ...(input.customHtmlTags || []),
+        ...(((_a = input.parseOptions) === null || _a === void 0 ? void 0 : _a.customHtmlTags) || []),
+    ]);
+    const mergedParseOptions = {
+        ...((_b = input.parseOptions) !== null && _b !== void 0 ? _b : {}),
+    };
+    if (typeof input.final === 'boolean')
+        mergedParseOptions.final = input.final;
+    if (normalizedTags.length > 0)
+        mergedParseOptions.customHtmlTags = normalizedTags;
+    return hydrateCustomTagContent(parseMarkdownToStructure(content, ctx.markdown, mergedParseOptions), content, normalizedTags);
+}
+function createRenderContext(options) {
+    var _a;
+    const normalizedTags = normalizeCustomHtmlTags(options.customHtmlTags);
+    const cacheKey = `${options.cacheKey || DEFAULT_CACHE_KEY}::${normalizedTags.join(',')}`;
+    let markdown = markdownCache.get(cacheKey);
+    if (!markdown) {
+        markdown = getMarkdown(cacheKey, {
+            customHtmlTags: normalizedTags,
+        });
+        markdownCache.set(cacheKey, markdown);
+    }
+    return {
+        markdown,
+        options: {
+            allowHtml: options.allowHtml !== false,
+            htmlPolicy: (_a = options.htmlPolicy) !== null && _a !== void 0 ? _a : 'safe',
+            customNodeTag: normalizeCustomHtmlTagName(options.customNodeTag) || DEFAULT_CUSTOM_NODE_TAG,
+            customNodeClass: options.customNodeClass,
+        },
+    };
+}
+function renderNestedInputToHtml(input, ctx) {
+    if (Array.isArray(input.nodes) && input.nodes.length > 0)
+        return renderNodesToHtml(input.nodes, ctx);
+    const node = input.node;
+    if (node) {
+        const children = getNodeList(node.children);
+        if (children.length > 0)
+            return renderNodesToHtml(children, ctx);
+        const content = getString(node.content);
+        if (content)
+            return renderMarkdownFragment(content, ctx);
+        if (node.raw != null)
+            return escapeHtml(getString(node.raw));
+    }
+    return input.content ? renderMarkdownFragment(getString(input.content), ctx) : '';
+}
+function renderNodesToHtml(nodes, ctx) {
+    return (Array.isArray(nodes) ? nodes : []).map(node => renderNodeToHtml(node, ctx)).join('');
+}
+function renderNodeToHtml(node, ctx) {
+    if (!node || typeof node !== 'object')
+        return '';
+    switch (node.type) {
+        case 'text':
+            return renderTextNode(node);
+        case 'paragraph':
+            return `<p>${renderNodesToHtml(getNodeList(node.children), ctx)}</p>`;
+        case 'strong':
+            return `<strong>${renderNodesToHtml(getNodeList(node.children), ctx)}</strong>`;
+        case 'emphasis':
+            return `<em>${renderNodesToHtml(getNodeList(node.children), ctx)}</em>`;
+        case 'strikethrough':
+            return `<del>${renderNodesToHtml(getNodeList(node.children), ctx)}</del>`;
+        case 'highlight':
+            return `<mark>${renderNodesToHtml(getNodeList(node.children), ctx)}</mark>`;
+        case 'insert':
+            return `<ins>${renderNodesToHtml(getNodeList(node.children), ctx)}</ins>`;
+        case 'subscript':
+            return `<sub>${renderNodesToHtml(getNodeList(node.children), ctx)}</sub>`;
+        case 'superscript':
+            return `<sup>${renderNodesToHtml(getNodeList(node.children), ctx)}</sup>`;
+        case 'inline_code':
+            return `<code>${escapeHtml(getString(node.code))}</code>`;
+        case 'hardbreak':
+            return '<br>';
+        case 'link':
+            return renderLinkNode(node, ctx);
+        case 'image':
+            return renderImageNode(node);
+        case 'list':
+            return renderListNode(node, ctx);
+        case 'list_item':
+            return `<li>${renderNodesToHtml(getNodeList(node.children), ctx)}</li>`;
+        case 'blockquote':
+            return `<blockquote>${renderNodesToHtml(getNodeList(node.children), ctx)}</blockquote>`;
+        case 'heading':
+            return renderHeadingNode(node, ctx);
+        case 'code_block':
+            return renderCodeBlockNode(node);
+        case 'thematic_break':
+            return '<hr>';
+        case 'table':
+            return renderTableNode(node, ctx);
+        case 'table_row':
+            return renderTableRowNode(node, ctx);
+        case 'table_cell':
+            return renderTableCellNode(node, ctx);
+        case 'definition_list':
+            return renderDefinitionListNode(node, ctx);
+        case 'definition_item':
+            return renderDefinitionItemNode(node, ctx);
+        case 'footnote':
+            return renderFootnoteNode(node, ctx);
+        case 'footnote_reference':
+            return renderFootnoteReferenceNode(node);
+        case 'footnote_anchor':
+            return renderFootnoteAnchorNode(node);
+        case 'admonition':
+            return renderAdmonitionNode(node, ctx);
+        case 'checkbox':
+        case 'checkbox_input':
+            return `<input type="checkbox" disabled${node.checked ? ' checked' : ''}>`;
+        case 'emoji':
+            return escapeHtml(getString(node.raw || node.markup || node.content || node.name));
+        case 'math_inline':
+            return renderMathInlineNode(node);
+        case 'math_block':
+            return renderMathBlockNode(node);
+        case 'reference':
+            return `<span class="markstream-nested-reference">${escapeHtml(getString(node.id))}</span>`;
+        case 'html_inline':
+        case 'html_block':
+            return renderHtmlNode(node, ctx);
+        default:
+            return renderCustomOrFallbackNode(node, ctx);
+    }
+}
+function renderTextNode(node) {
+    const content = getString(node.content);
+    const escaped = escapeHtml(content);
+    const centered = !!node.center;
+    if (!centered && !content.includes('\n'))
+        return escaped;
+    const className = centered
+        ? 'markstream-svelte-text-node markstream-svelte-text--centered'
+        : 'markstream-svelte-text-node';
+    return `<span class="${className}">${escaped}</span>`;
+}
+function renderLinkNode(node, ctx) {
+    const href = getString(node.href);
+    const title = getString(node.title);
+    const content = getNodeList(node.children).length > 0
+        ? renderNodesToHtml(getNodeList(node.children), ctx)
+        : escapeHtml(getString(node.text || href));
+    const titleAttr = title ? ` title="${escapeAttr(title)}"` : '';
+    const hrefAttr = href && !isUnsafeHtmlUrl(href) ? ` href="${escapeAttr(href)}"` : '';
+    const externalAttrs = href.startsWith('#') ? '' : ' target="_blank" rel="noreferrer noopener"';
+    return `<a${hrefAttr}${titleAttr}${externalAttrs}>${content}</a>`;
+}
+function renderMathInlineNode(node) {
+    const source = escapeHtml(getString(node.content || node.markup || node.raw));
+    return `<span class="markstream-nested-math" data-display="inline"><span class="markstream-nested-math__source">${source}</span><span class="markstream-nested-math__render" aria-hidden="true"></span></span>`;
+}
+function renderMathBlockNode(node) {
+    const source = escapeHtml(getString(node.content || node.markup || node.raw));
+    return `<div class="markstream-nested-math-block"><pre class="markstream-nested-math-block__source"><code>${source}</code></pre><div class="markstream-nested-math-block__render" aria-hidden="true"></div></div>`;
+}
+function renderImageNode(node) {
+    const src = getString(node.src);
+    const alt = getString(node.alt);
+    const title = getString(node.title);
+    const titleAttr = title ? ` title="${escapeAttr(title)}"` : '';
+    return `<img src="${escapeAttr(src)}" alt="${escapeAttr(alt)}"${titleAttr}>`;
+}
+function renderListNode(node, ctx) {
+    const tag = node.ordered ? 'ol' : 'ul';
+    const start = node.ordered && Number.isFinite(node.start) ? ` start="${Number(node.start)}"` : '';
+    return `<${tag}${start}>${renderNodesToHtml(getNodeList(node.items), ctx)}</${tag}>`;
+}
+function renderHeadingNode(node, ctx) {
+    const level = clampHeadingLevel(node.level);
+    return `<h${level}>${renderNodesToHtml(getNodeList(node.children), ctx)}</h${level}>`;
+}
+function renderCodeBlockNode(node) {
+    const rawLanguage = getString(node.language).trim();
+    const language = sanitizeClassToken(rawLanguage);
+    const languageClass = language ? ` class="language-${language}"` : '';
+    const diff = !!node.diff;
+    const code = getString(node.code);
+    const loading = node.loading === true;
+    if (loading && !code.trim())
+        return '';
+    const blockAttrs = [
+        'data-markstream-code-block="1"',
+        rawLanguage ? `data-markstream-language="${escapeAttr(rawLanguage)}"` : '',
+        loading ? 'data-markstream-loading="1"' : '',
+        diff ? 'data-markstream-diff="1"' : '',
+        diff ? `data-markstream-original="${escapeAttr(encodeDataPayload(getString(node.originalCode)))}"` : '',
+        diff ? `data-markstream-updated="${escapeAttr(encodeDataPayload(getString(node.updatedCode)))}"` : '',
+        loading ? 'aria-busy="true"' : '',
+    ].filter(Boolean).join(' ');
+    return `<pre ${blockAttrs}><code${languageClass}>${escapeHtml(code)}</code></pre>`;
+}
+function renderTableNode(node, ctx) {
+    const header = node.header ? renderTableRowNode(node.header, ctx, true) : '';
+    const rows = renderNodesToHtml(getNodeList(node.rows), ctx);
+    const thead = header ? `<thead>${header}</thead>` : '';
+    const tbody = rows ? `<tbody>${rows}</tbody>` : '';
+    return `<table>${thead}${tbody}</table>`;
+}
+function renderTableRowNode(node, ctx, forceHeader = false) {
+    const cells = getNodeList(node.cells).map(cell => renderTableCellNode(cell, ctx, forceHeader)).join('');
+    return `<tr>${cells}</tr>`;
+}
+function renderTableCellNode(node, ctx, forceHeader = false) {
+    const tag = forceHeader || !!node.header ? 'th' : 'td';
+    const align = getString(node.align);
+    const alignAttr = align ? ` style="text-align:${escapeAttr(align)}"` : '';
+    return `<${tag}${alignAttr}>${renderNodesToHtml(getNodeList(node.children), ctx)}</${tag}>`;
+}
+function renderDefinitionListNode(node, ctx) {
+    return `<dl>${getNodeList(node.items).map(item => renderDefinitionItemNode(item, ctx)).join('')}</dl>`;
+}
+function renderDefinitionItemNode(node, ctx) {
+    const term = renderNodesToHtml(getNodeList(node.term), ctx);
+    const definition = renderNodesToHtml(getNodeList(node.definition), ctx);
+    return `<dt>${term}</dt><dd>${definition}</dd>`;
+}
+function renderFootnoteNode(node, ctx) {
+    const id = escapeAttr(getString(node.id));
+    const idAttr = id ? ` id="fnref--${id}"` : '';
+    return `<div${idAttr} class="footnote-node markstream-nested-footnote"><div class="footnote-node__content">${renderNodesToHtml(getNodeList(node.children), ctx)}</div></div>`;
+}
+function renderFootnoteReferenceNode(node) {
+    const rawId = getString(node.id);
+    const id = escapeHtml(rawId);
+    const attrId = escapeAttr(rawId);
+    const idAttr = attrId ? ` id="fnref-${attrId}"` : '';
+    const hrefAttr = attrId ? ` href="#fnref--${attrId}"` : '';
+    const titleAttr = attrId ? ` title="查看脚注 ${attrId}"` : '';
+    return `<sup${idAttr} class="footnote-reference markstream-nested-footnote-ref"><span${hrefAttr}${titleAttr} class="footnote-link cursor-pointer">[${id}]</span></sup>`;
+}
+function renderFootnoteAnchorNode(node) {
+    const id = escapeAttr(getString(node.id));
+    const hrefAttr = id ? ` href="#fnref-${id}"` : '';
+    const titleAttr = id ? ` title="返回引用 ${id}"` : '';
+    return `<a class="footnote-anchor"${hrefAttr}${titleAttr} aria-label="${id ? `返回引用 ${id}` : '返回引用'}">↩︎</a>`;
+}
+function renderAdmonitionNode(node, ctx) {
+    const kind = sanitizeClassToken(getString(node.kind || 'note')) || 'note';
+    const title = getString(node.title) || capitalize(kind);
+    return `<div class="markstream-nested-admonition markstream-nested-admonition--${kind}"><div class="markstream-nested-admonition__title">${escapeHtml(title)}</div><div class="markstream-nested-admonition__content">${renderNodesToHtml(getNodeList(node.children), ctx)}</div></div>`;
+}
+function renderHtmlNode(node, ctx) {
+    const content = getString(node.content);
+    const rawContent = content || getString(node.raw);
+    const tag = getString(node.tag).trim().toLowerCase();
+    const children = getNodeList(node.children);
+    if (!ctx.options.allowHtml)
+        return escapeHtml(rawContent);
+    if (ctx.options.htmlPolicy === 'escape')
+        return escapeHtml(rawContent);
+    if (node.loading && !node.autoClosed)
+        return escapeHtml(rawContent);
+    if (tag && children.length > 0 && !NON_STRUCTURING_HTML_TAGS.has(tag) && !isHtmlTagBlocked(tag, ctx.options.htmlPolicy)) {
+        const attrs = serializeAttrs(node.attrs, '', ctx.options.htmlPolicy, tag);
+        return `<${tag}${attrs}>${renderNodesToHtml(children, ctx)}</${tag}>`;
+    }
+    return sanitizeHtmlContent(rawContent, ctx.options.htmlPolicy);
+}
+function renderCustomOrFallbackNode(node, ctx) {
+    const tagName = getString(node.tag || node.type);
+    if (!tagName || KNOWN_NODE_TYPES.has(tagName))
+        return escapeHtml(getString(node.content || node.raw));
+    const classes = [
+        'markstream-nested-custom',
+        `markstream-nested-custom--${sanitizeClassToken(tagName) || 'node'}`,
+        resolveCustomNodeClass(node, ctx.options.customNodeClass),
+    ].filter(Boolean).join(' ');
+    const attrs = serializeAttrs(node.attrs, classes, ctx.options.htmlPolicy);
+    const body = resolveCustomNodeBody(node, ctx);
+    const wrapperTag = ctx.options.customNodeTag;
+    return `<${wrapperTag}${attrs} data-markstream-custom-tag="${escapeAttr(tagName)}">${body}</${wrapperTag}>`;
+}
+function resolveCustomNodeBody(node, ctx) {
+    const children = getNodeList(node.children);
+    if (children.length > 0)
+        return renderNodesToHtml(children, ctx);
+    const content = getString(node.content);
+    if (content)
+        return renderMarkdownFragment(content, ctx);
+    return escapeHtml(getString(node.raw));
+}
+function renderMarkdownFragment(content, ctx) {
+    return content ? ctx.markdown.render(content) : '';
+}
+function resolveCustomNodeClass(node, customNodeClass) {
+    if (!customNodeClass)
+        return '';
+    const resolved = typeof customNodeClass === 'function'
+        ? customNodeClass(node)
+        : customNodeClass;
+    return serializeClassValue(resolved);
+}
+function serializeClassValue(value) {
+    if (Array.isArray(value))
+        return value.map(item => serializeClassValue(item)).filter(Boolean).join(' ');
+    return typeof value === 'string'
+        ? value.trim()
+        : '';
+}
+function serializeAttrs(attrs, extraClass = '', policy = 'safe', tagName) {
+    const pairs = normalizeAttrs(attrs);
+    const record = {};
+    const mergedClasses = [extraClass];
+    for (const [name, value] of pairs) {
+        const safeName = String(name).trim();
+        if (!safeName)
+            continue;
+        if (safeName.toLowerCase() === 'class') {
+            mergedClasses.push(String(value));
+            continue;
+        }
+        record[safeName] = value === true ? '' : String(value);
+    }
+    const rendered = Object.entries(sanitizeHtmlAttrs(record, policy, tagName))
+        .map(([name, value]) => value === '' ? ` ${name}` : ` ${name}="${escapeAttr(String(value))}"`);
+    const className = mergedClasses.map(value => value.trim()).filter(Boolean).join(' ');
+    if (className)
+        rendered.unshift(` class="${escapeAttr(className)}"`);
+    return rendered.join('');
+}
+function normalizeAttrs(attrs) {
+    if (!attrs)
+        return [];
+    if (Array.isArray(attrs)) {
+        if (attrs.length === 0)
+            return [];
+        const first = attrs[0];
+        if (Array.isArray(first))
+            return attrs.map(([name, value]) => [String(name), value]);
+        return attrs.map(item => [String(item.name), item.value]);
+    }
+    return Object.entries(attrs).map(([name, value]) => [name, value]);
+}
+function getNodeList(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => !!item && typeof item === 'object')
+        : [];
+}
+function getString(value) {
+    return typeof value === 'string'
+        ? value
+        : value == null
+            ? ''
+            : String(value);
+}
+function sanitizeClassToken(value) {
+    return value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '');
+}
+function clampHeadingLevel(value) {
+    const level = Math.trunc(Number(value) || 1);
+    return Math.min(6, Math.max(1, level));
+}
+function escapeHtml(value) {
+    return getString(value)
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+function escapeAttr(value) {
+    return escapeHtml(value).replace(/`/g, '&#96;');
+}
+function capitalize(value) {
+    return value ? `${value[0].toUpperCase()}${value.slice(1)}` : '';
+}
+function encodeDataPayload(value) {
+    var _a, _b;
+    if (!value)
+        return '';
+    const globalBuffer = (_b = (_a = globalThis === null || globalThis === void 0 ? void 0 : globalThis.require) === null || _a === void 0 ? void 0 : _a.call(globalThis, 'buffer')) === null || _b === void 0 ? void 0 : _b.Buffer;
+    if (globalBuffer === null || globalBuffer === void 0 ? void 0 : globalBuffer.from)
+        return globalBuffer.from(value, 'utf8').toString('base64');
+    if (typeof TextEncoder !== 'undefined' && typeof globalThis.btoa === 'function') {
+        const bytes = new TextEncoder().encode(value);
+        let binary = '';
+        for (const byte of bytes)
+            binary += String.fromCharCode(byte);
+        return globalThis.btoa(binary);
+    }
+    return '';
+}

package/dist/sanitizeHtmlContent.d.ts

@@ -0,0 +1,3 @@
+import type { HtmlPolicy } from 'stream-markdown-parser';
+export declare function sanitizeHtmlContent(content: string, policy?: HtmlPolicy): string;
+//# sourceMappingURL=sanitizeHtmlContent.d.ts.map

package/dist/sanitizeHtmlContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizeHtmlContent.d.ts","sourceRoot":"","sources":["../src/sanitizeHtmlContent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAA;AAsJxD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,GAAE,UAAmB,GAAG,MAAM,CAyExF"}

package/dist/sanitizeHtmlContent.js

@@ -0,0 +1,175 @@
+import { BLOCKED_HTML_TAGS as BLOCKED_TAGS, isHtmlTagBlocked, isHtmlTagHardBlocked, sanitizeHtmlAttrs, VOID_HTML_TAGS as VOID_ELEMENTS, } from 'stream-markdown-parser';
+import { escapeAttr, escapeHtml } from './components/shared/node-helpers';
+function sanitizeAttrs(attrs, policy, tagName) {
+    return sanitizeHtmlAttrs(attrs, policy, tagName);
+}
+function tokenizeHtml(html) {
+    var _a, _b, _c;
+    const tokens = [];
+    let pos = 0;
+    while (pos < html.length) {
+        if (html.startsWith('<!--', pos)) {
+            const commentEnd = html.indexOf('-->', pos);
+            if (commentEnd !== -1) {
+                pos = commentEnd + 3;
+                continue;
+            }
+            break;
+        }
+        const tagStart = html.indexOf('<', pos);
+        if (tagStart === -1) {
+            if (pos < html.length)
+                tokens.push({ type: 'text', content: html.slice(pos) });
+            break;
+        }
+        if (tagStart > pos)
+            tokens.push({ type: 'text', content: html.slice(pos, tagStart) });
+        if (html.startsWith('![CDATA[', tagStart + 1)) {
+            const cdataEnd = html.indexOf(']]>', tagStart);
+            if (cdataEnd !== -1) {
+                tokens.push({ type: 'text', content: html.slice(tagStart, cdataEnd + 3) });
+                pos = cdataEnd + 3;
+                continue;
+            }
+            break;
+        }
+        if (html.startsWith('!', tagStart + 1)) {
+            const specialEnd = html.indexOf('>', tagStart);
+            if (specialEnd !== -1) {
+                pos = specialEnd + 1;
+                continue;
+            }
+            break;
+        }
+        const tagEnd = html.indexOf('>', tagStart);
+        if (tagEnd === -1)
+            break;
+        const tagContent = html.slice(tagStart + 1, tagEnd).trim();
+        if (!tagContent) {
+            pos = tagEnd + 1;
+            continue;
+        }
+        const isClosingTag = tagContent.startsWith('/');
+        const isSelfClosing = tagContent.endsWith('/');
+        if (isClosingTag) {
+            const tagName = tagContent.slice(1).trim();
+            tokens.push({ type: 'tag_close', tagName });
+            pos = tagEnd + 1;
+            continue;
+        }
+        const spaceIndex = tagContent.indexOf(' ');
+        let tagName = '';
+        let attrsStr = '';
+        if (spaceIndex === -1) {
+            tagName = isSelfClosing ? tagContent.slice(0, -1).trim() : tagContent.trim();
+        }
+        else {
+            tagName = tagContent.slice(0, spaceIndex).trim();
+            attrsStr = tagContent.slice(spaceIndex + 1);
+        }
+        const attrs = {};
+        if (attrsStr) {
+            const attrRegex = /([^\s=]+)(?:=(?:"([^"]*)"|'([^']*)'|(\S*)))?/g;
+            let attrMatch;
+            while ((attrMatch = attrRegex.exec(attrsStr)) !== null) {
+                const name = attrMatch[1];
+                const value = (_c = (_b = (_a = attrMatch[2]) !== null && _a !== void 0 ? _a : attrMatch[3]) !== null && _b !== void 0 ? _b : attrMatch[4]) !== null && _c !== void 0 ? _c : '';
+                if (name && !name.endsWith('/'))
+                    attrs[name] = value;
+            }
+        }
+        tokens.push({
+            type: isSelfClosing || VOID_ELEMENTS.has(tagName.toLowerCase()) ? 'self_closing' : 'tag_open',
+            tagName,
+            attrs,
+        });
+        pos = tagEnd + 1;
+    }
+    return tokens;
+}
+function normalizeTagName(tagName) {
+    return String(tagName !== null && tagName !== void 0 ? tagName : '').trim().toLowerCase();
+}
+function serializeAttrs(attrs) {
+    const pairs = Object.entries(attrs);
+    if (pairs.length === 0)
+        return '';
+    return pairs
+        .map(([name, value]) => value === '' ? ` ${name}` : ` ${name}="${escapeAttr(value)}"`)
+        .join('');
+}
+function serializeLiteralHtmlTag(token) {
+    var _a, _b;
+    const tagName = String((_a = token.tagName) !== null && _a !== void 0 ? _a : '').trim();
+    if (!tagName)
+        return '';
+    if (token.type === 'tag_close')
+        return `&lt;/${escapeHtml(tagName)}&gt;`;
+    const attrs = Object.entries((_b = token.attrs) !== null && _b !== void 0 ? _b : {})
+        .map(([name, value]) => value === '' ? ` ${escapeHtml(name)}` : ` ${escapeHtml(name)}="${escapeAttr(value)}"`)
+        .join('');
+    return token.type === 'self_closing'
+        ? `&lt;${escapeHtml(tagName)}${attrs} /&gt;`
+        : `&lt;${escapeHtml(tagName)}${attrs}&gt;`;
+}
+export function sanitizeHtmlContent(content, policy = 'safe') {
+    var _a, _b, _c;
+    if (!content)
+        return '';
+    if (policy === 'escape')
+        return escapeHtml(content);
+    const tokens = tokenizeHtml(content);
+    const stack = [];
+    const output = [];
+    let blockedDepth = 0;
+    for (const token of tokens) {
+        if (token.type === 'text') {
+            if (blockedDepth === 0)
+                output.push(escapeHtml((_a = token.content) !== null && _a !== void 0 ? _a : ''));
+            continue;
+        }
+        const tagName = normalizeTagName(token.tagName);
+        if (!tagName)
+            continue;
+        if (BLOCKED_TAGS.has(tagName) || isHtmlTagHardBlocked(tagName, policy)) {
+            if (token.type === 'tag_open')
+                blockedDepth += 1;
+            else if (token.type === 'tag_close' && blockedDepth > 0)
+                blockedDepth -= 1;
+            continue;
+        }
+        if (blockedDepth > 0)
+            continue;
+        if (policy === 'safe' && isHtmlTagBlocked(tagName, policy)) {
+            output.push(serializeLiteralHtmlTag(token));
+            continue;
+        }
+        if (token.type === 'self_closing') {
+            output.push(`<${tagName}${serializeAttrs(sanitizeAttrs((_b = token.attrs) !== null && _b !== void 0 ? _b : {}, policy, tagName))}>`);
+            continue;
+        }
+        if (token.type === 'tag_open') {
+            output.push(`<${tagName}${serializeAttrs(sanitizeAttrs((_c = token.attrs) !== null && _c !== void 0 ? _c : {}, policy, tagName))}>`);
+            if (!VOID_ELEMENTS.has(tagName))
+                stack.push(tagName);
+            continue;
+        }
+        const matchedIndex = stack.lastIndexOf(tagName);
+        if (matchedIndex === -1)
+            continue;
+        while (stack.length > matchedIndex + 1) {
+            const danglingTag = stack.pop();
+            if (danglingTag)
+                output.push(`</${danglingTag}>`);
+        }
+        const closingTag = stack.pop();
+        if (closingTag)
+            output.push(`</${closingTag}>`);
+    }
+    while (stack.length > 0) {
+        const danglingTag = stack.pop();
+        if (danglingTag)
+            output.push(`</${danglingTag}>`);
+    }
+    return output.join('');
+}

package/dist/sanitizeSvg.d.ts

@@ -0,0 +1,3 @@
+export declare function toSafeSvgMarkup(svg: string | null | undefined): string;
+export declare function extractRenderedSvg(renderResult: any): any;
+//# sourceMappingURL=sanitizeSvg.d.ts.map

package/dist/sanitizeSvg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizeSvg.d.ts","sourceRoot":"","sources":["../src/sanitizeSvg.ts"],"names":[],"mappings":"AA0DA,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,UAe7D;AAED,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,GAAG,OAUnD"}