markstream-svelte 0.0.1-beta.1

package/dist/optional/d2.d.ts

@@ -0,0 +1,7 @@
+export type D2Loader = () => Promise<any> | any;
+export declare function setD2Loader(loader: D2Loader | null): void;
+export declare function enableD2(loader?: D2Loader): void;
+export declare function disableD2(): void;
+export declare function isD2Enabled(): boolean;
+export declare function getD2(): Promise<any>;
+//# sourceMappingURL=d2.d.ts.map

package/dist/optional/d2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"d2.d.ts","sourceRoot":"","sources":["../../src/optional/d2.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAAA;AA4B/C,wBAAgB,WAAW,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,QAGlD;AAED,wBAAgB,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,QAEzC;AAED,wBAAgB,SAAS,SAExB;AAED,wBAAgB,WAAW,YAE1B;AAED,wBAAsB,KAAK,iBAmC1B"}

package/dist/optional/d2.js

@@ -0,0 +1,67 @@
+const defaultD2Loader = () => import('@terrastruct/d2');
+let cachedD2 = null;
+let d2Loader = defaultD2Loader;
+let pendingImport = null;
+function resetCachedD2() {
+    cachedD2 = null;
+    pendingImport = null;
+}
+function normalizeD2Module(mod) {
+    var _a;
+    if (!mod)
+        return mod;
+    if (mod.D2 && typeof mod.D2 === 'function')
+        return mod.D2;
+    if (mod.default && mod.default.D2 && typeof mod.default.D2 === 'function')
+        return mod.default.D2;
+    const candidate = (_a = mod.default) !== null && _a !== void 0 ? _a : mod;
+    if (typeof candidate === 'function')
+        return candidate;
+    if ((candidate === null || candidate === void 0 ? void 0 : candidate.D2) && typeof candidate.D2 === 'function')
+        return candidate.D2;
+    return candidate;
+}
+export function setD2Loader(loader) {
+    d2Loader = loader;
+    resetCachedD2();
+}
+export function enableD2(loader) {
+    setD2Loader(loader !== null && loader !== void 0 ? loader : defaultD2Loader);
+}
+export function disableD2() {
+    setD2Loader(null);
+}
+export function isD2Enabled() {
+    return typeof d2Loader === 'function';
+}
+export async function getD2() {
+    if (cachedD2)
+        return cachedD2;
+    if (pendingImport)
+        return await pendingImport;
+    const loader = d2Loader;
+    if (!loader)
+        return null;
+    pendingImport = (async () => {
+        let mod;
+        try {
+            mod = await loader();
+        }
+        catch (error) {
+            if (loader === defaultD2Loader) {
+                throw new Error('Optional dependency "@terrastruct/d2" is not installed. Please install it to enable D2 diagrams.');
+            }
+            throw error;
+        }
+        if (!mod)
+            return null;
+        cachedD2 = normalizeD2Module(mod);
+        return cachedD2;
+    })();
+    try {
+        return await pendingImport;
+    }
+    finally {
+        pendingImport = null;
+    }
+}

package/dist/optional/infographic.d.ts

@@ -0,0 +1,2 @@
+export declare function getInfographic(): Promise<any>;
+//# sourceMappingURL=infographic.d.ts.map

package/dist/optional/infographic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infographic.d.ts","sourceRoot":"","sources":["../../src/optional/infographic.ts"],"names":[],"mappings":"AAGA,wBAAsB,cAAc,iBA+BnC"}

package/dist/optional/infographic.js

@@ -0,0 +1,29 @@
+let infographicPromise = null;
+let infographicInstance = null;
+export async function getInfographic() {
+    if (infographicInstance)
+        return infographicInstance;
+    if (infographicPromise)
+        return await infographicPromise;
+    infographicPromise = import('@antv/infographic')
+        .then((mod) => {
+        const defaultExport = (mod && mod.default) ? mod.default : mod;
+        let resolved = defaultExport;
+        if (typeof defaultExport === 'function' && defaultExport.prototype && defaultExport.prototype.render) {
+            resolved = defaultExport;
+        }
+        else if (mod === null || mod === void 0 ? void 0 : mod.Infographic) {
+            resolved = mod.Infographic;
+        }
+        else if (defaultExport && defaultExport.Infographic) {
+            resolved = defaultExport.Infographic;
+        }
+        infographicInstance = resolved;
+        return resolved;
+    })
+        .catch((error) => {
+        console.warn('[markstream-svelte] Failed to load @antv/infographic', error);
+        return null;
+    });
+    return await infographicPromise;
+}

package/dist/optional/katex.d.ts

@@ -0,0 +1,7 @@
+export type KatexLoader = () => Promise<any> | any;
+export declare function setKatexLoader(loader: KatexLoader | null): void;
+export declare function enableKatex(loader?: KatexLoader): void;
+export declare function disableKatex(): void;
+export declare function isKatexEnabled(): boolean;
+export declare function getKatex(): Promise<any>;
+//# sourceMappingURL=katex.d.ts.map

package/dist/optional/katex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"katex.d.ts","sourceRoot":"","sources":["../../src/optional/katex.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAAA;AA+ClD,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,QAGxD;AAED,wBAAgB,WAAW,CAAC,MAAM,CAAC,EAAE,WAAW,QAE/C;AAED,wBAAgB,YAAY,SAE3B;AAED,wBAAgB,cAAc,YAE7B;AAED,wBAAsB,QAAQ,iBA2C7B"}

package/dist/optional/katex.js

@@ -0,0 +1,93 @@
+let katex = null;
+let importAttempted = false;
+let pendingImport = null;
+let katexLoader = defaultKatexLoader;
+function normalizeKatexModule(mod) {
+    var _a;
+    const resolved = (_a = mod === null || mod === void 0 ? void 0 : mod.default) !== null && _a !== void 0 ? _a : mod;
+    if (resolved && typeof resolved.renderToString === 'function')
+        return resolved;
+    return null;
+}
+function getGlobalKatex() {
+    try {
+        const globalStore = globalThis;
+        return normalizeKatexModule(globalStore === null || globalStore === void 0 ? void 0 : globalStore.katex);
+    }
+    catch {
+        return null;
+    }
+}
+function defaultKatexLoader() {
+    return (async () => {
+        const globalKatex = getGlobalKatex();
+        if (globalKatex)
+            return globalKatex;
+        const mod = await import('katex');
+        try {
+            await import('katex/contrib/mhchem');
+        }
+        catch {
+            // Ignore optional mhchem support failures.
+        }
+        return normalizeKatexModule(mod);
+    })();
+}
+function resetCache() {
+    katex = null;
+    importAttempted = false;
+    pendingImport = null;
+}
+export function setKatexLoader(loader) {
+    katexLoader = loader;
+    resetCache();
+}
+export function enableKatex(loader) {
+    setKatexLoader(loader !== null && loader !== void 0 ? loader : defaultKatexLoader);
+}
+export function disableKatex() {
+    setKatexLoader(null);
+}
+export function isKatexEnabled() {
+    return typeof katexLoader === 'function';
+}
+export async function getKatex() {
+    const globalKatex = getGlobalKatex();
+    if (globalKatex) {
+        katex = globalKatex;
+        return katex;
+    }
+    if (katex)
+        return katex;
+    if (pendingImport)
+        return await pendingImport;
+    if (importAttempted)
+        return null;
+    const loader = katexLoader;
+    if (!loader) {
+        importAttempted = true;
+        return null;
+    }
+    pendingImport = (async () => {
+        var _a;
+        try {
+            const result = await loader();
+            const normalized = (_a = normalizeKatexModule(result)) !== null && _a !== void 0 ? _a : result;
+            if (normalized) {
+                katex = normalized;
+                return katex;
+            }
+        }
+        catch {
+            // Swallow loader errors so callers can gracefully fall back.
+        }
+        importAttempted = true;
+        return null;
+    })();
+    try {
+        return await pendingImport;
+    }
+    finally {
+        pendingImport = null;
+    }
+}

package/dist/optional/mermaid.d.ts

@@ -0,0 +1,7 @@
+export type MermaidLoader = () => Promise<any> | any;
+export declare function setMermaidLoader(loader: MermaidLoader | null): void;
+export declare function enableMermaid(loader?: MermaidLoader): void;
+export declare function disableMermaid(): void;
+export declare function isMermaidEnabled(): boolean;
+export declare function getMermaid(initConfig?: Record<string, any>): Promise<any>;
+//# sourceMappingURL=mermaid.d.ts.map

package/dist/optional/mermaid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mermaid.d.ts","sourceRoot":"","sources":["../../src/optional/mermaid.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAAA;AAqHpD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,QAG5D;AAED,wBAAgB,aAAa,CAAC,MAAM,CAAC,EAAE,aAAa,QAEnD;AAED,wBAAgB,cAAc,SAE7B;AAED,wBAAgB,gBAAgB,YAE/B;AAED,wBAAsB,UAAU,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,gBA2DhE"}

package/dist/optional/mermaid.js

@@ -0,0 +1,171 @@
+const defaultMermaidLoader = () => import('mermaid');
+const GLOBAL_MERMAID_KEY = '__MARKSTREAM_ANGULAR_MERMAID__';
+let cachedMermaid = null;
+let importAttempted = false;
+let lastInitKey = null;
+let pendingImport = null;
+let mermaidLoader = defaultMermaidLoader;
+function computeInitKey(config) {
+    var _a, _b;
+    const securityLevel = String((_a = config === null || config === void 0 ? void 0 : config.securityLevel) !== null && _a !== void 0 ? _a : 'strict');
+    const htmlLabels = (_b = config === null || config === void 0 ? void 0 : config.flowchart) === null || _b === void 0 ? void 0 : _b.htmlLabels;
+    return `${securityLevel}|htmlLabels:${htmlLabels === false ? '0' : '1'}`;
+}
+function normalizeMermaidModule(mod) {
+    var _a;
+    if (!mod)
+        return mod;
+    const candidate = (_a = mod === null || mod === void 0 ? void 0 : mod.default) !== null && _a !== void 0 ? _a : mod;
+    if (candidate && (typeof candidate.render === 'function' || typeof candidate.parse === 'function' || typeof candidate.initialize === 'function'))
+        return candidate;
+    if ((candidate === null || candidate === void 0 ? void 0 : candidate.mermaidAPI) && (typeof candidate.mermaidAPI.render === 'function' || typeof candidate.mermaidAPI.parse === 'function')) {
+        const api = candidate.mermaidAPI;
+        return {
+            ...candidate,
+            render: api.render.bind(api),
+            parse: api.parse ? api.parse.bind(api) : undefined,
+            initialize: (opts) => {
+                if (typeof candidate.initialize === 'function')
+                    return candidate.initialize(opts);
+                return api.initialize ? api.initialize(opts) : undefined;
+            },
+        };
+    }
+    if ((mod === null || mod === void 0 ? void 0 : mod.mermaid) && typeof mod.mermaid.render === 'function')
+        return mod.mermaid;
+    return candidate;
+}
+function patchInitialize(target) {
+    if (!target)
+        return;
+    try {
+        const originalInitialize = target === null || target === void 0 ? void 0 : target.initialize;
+        target.initialize = (opts) => {
+            const merged = { suppressErrorRendering: true, ...(opts || {}) };
+            if (typeof originalInitialize === 'function')
+                return originalInitialize.call(target, merged);
+            if ((target === null || target === void 0 ? void 0 : target.mermaidAPI) && typeof target.mermaidAPI.initialize === 'function')
+                return target.mermaidAPI.initialize(merged);
+            return undefined;
+        };
+    }
+    catch {
+        // Ignore patching failures and keep the original instance.
+    }
+}
+function ensureInitialized(instance, config) {
+    var _a;
+    if (!instance || !config)
+        return;
+    const key = computeInitKey(config);
+    if (lastInitKey === key)
+        return;
+    try {
+        if (typeof instance.initialize === 'function')
+            instance.initialize(config);
+        else if ((_a = instance.mermaidAPI) === null || _a === void 0 ? void 0 : _a.initialize)
+            instance.mermaidAPI.initialize(config);
+        lastInitKey = key;
+    }
+    catch {
+        // Mermaid may already be initialized; keep going.
+    }
+}
+function getGlobalMermaid() {
+    var _a;
+    try {
+        const globalStore = globalThis;
+        return normalizeMermaidModule((_a = globalStore === null || globalStore === void 0 ? void 0 : globalStore[GLOBAL_MERMAID_KEY]) !== null && _a !== void 0 ? _a : globalStore === null || globalStore === void 0 ? void 0 : globalStore.mermaid);
+    }
+    catch {
+        return null;
+    }
+}
+function setGlobalMermaid(instance) {
+    try {
+        ;
+        globalThis[GLOBAL_MERMAID_KEY] = instance;
+    }
+    catch {
+        // Ignore global cache writes when the host forbids mutation.
+    }
+}
+function resetCachedMermaid() {
+    cachedMermaid = null;
+    importAttempted = false;
+    lastInitKey = null;
+    pendingImport = null;
+    try {
+        delete globalThis[GLOBAL_MERMAID_KEY];
+    }
+    catch {
+        // Ignore failures when the global object is sealed.
+    }
+}
+export function setMermaidLoader(loader) {
+    mermaidLoader = loader;
+    resetCachedMermaid();
+}
+export function enableMermaid(loader) {
+    setMermaidLoader(loader !== null && loader !== void 0 ? loader : defaultMermaidLoader);
+}
+export function disableMermaid() {
+    setMermaidLoader(null);
+}
+export function isMermaidEnabled() {
+    return typeof mermaidLoader === 'function';
+}
+export async function getMermaid(initConfig) {
+    if (cachedMermaid) {
+        ensureInitialized(cachedMermaid, initConfig);
+        return cachedMermaid;
+    }
+    const globalMermaid = getGlobalMermaid();
+    if (globalMermaid) {
+        patchInitialize(globalMermaid);
+        cachedMermaid = globalMermaid;
+        setGlobalMermaid(cachedMermaid);
+        ensureInitialized(cachedMermaid, initConfig);
+        return cachedMermaid;
+    }
+    if (pendingImport) {
+        const instance = await pendingImport;
+        if (instance)
+            ensureInitialized(instance, initConfig);
+        return instance;
+    }
+    if (importAttempted)
+        return null;
+    const loader = mermaidLoader;
+    if (!loader) {
+        importAttempted = true;
+        return null;
+    }
+    pendingImport = (async () => {
+        try {
+            const mod = await loader();
+            const instance = normalizeMermaidModule(mod);
+            if (!instance) {
+                importAttempted = true;
+                return null;
+            }
+            patchInitialize(instance);
+            cachedMermaid = instance;
+            setGlobalMermaid(cachedMermaid);
+            return cachedMermaid;
+        }
+        catch {
+            importAttempted = true;
+            return null;
+        }
+    })();
+    try {
+        const instance = await pendingImport;
+        if (instance)
+            ensureInitialized(instance, initConfig);
+        return instance;
+    }
+    finally {
+        pendingImport = null;
+    }
+}

package/dist/optional/monaco.d.ts

@@ -0,0 +1,5 @@
+export declare function isCodeBlockRuntimeReady(): boolean;
+export declare function resetCodeBlockRuntimeReadyForTest(): void;
+export declare function preloadCodeBlockRuntime(): Promise<boolean>;
+export declare function getUseMonaco(): Promise<any>;
+//# sourceMappingURL=monaco.d.ts.map

package/dist/optional/monaco.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monaco.d.ts","sourceRoot":"","sources":["../../src/optional/monaco.ts"],"names":[],"mappings":"AAMA,wBAAgB,uBAAuB,YAEtC;AAED,wBAAgB,iCAAiC,SAEhD;AAED,wBAAsB,uBAAuB,qBAG5C;AAoCD,wBAAsB,YAAY,iBA6BjC"}

package/dist/optional/monaco.js

@@ -0,0 +1,70 @@
+let monacoModule = null;
+let importAttempted = false;
+let pendingImport = null;
+let workersPreloaded = false;
+let codeBlockRuntimeReady = false;
+export function isCodeBlockRuntimeReady() {
+    return codeBlockRuntimeReady;
+}
+export function resetCodeBlockRuntimeReadyForTest() {
+    codeBlockRuntimeReady = false;
+}
+export async function preloadCodeBlockRuntime() {
+    const runtime = await getUseMonaco();
+    return !!runtime;
+}
+async function preloadWorkers(mod) {
+    if (workersPreloaded)
+        return;
+    workersPreloaded = true;
+    const existingEnv = globalThis === null || globalThis === void 0 ? void 0 : globalThis.MonacoEnvironment;
+    if (existingEnv && (typeof existingEnv.getWorker === 'function' || typeof existingEnv.getWorkerUrl === 'function'))
+        return;
+    if (typeof (mod === null || mod === void 0 ? void 0 : mod.preloadMonacoWorkers) === 'function')
+        await mod.preloadMonacoWorkers();
+}
+async function warmupShikiTokenizer(mod) {
+    const getOrCreateHighlighter = mod === null || mod === void 0 ? void 0 : mod.getOrCreateHighlighter;
+    if (typeof getOrCreateHighlighter !== 'function')
+        return true;
+    try {
+        const highlighter = await getOrCreateHighlighter(['vitesse-dark', 'vitesse-light'], ['plaintext', 'text', 'javascript']);
+        if (highlighter && typeof highlighter.codeToTokens === 'function') {
+            highlighter.codeToTokens('const a = 1', { lang: 'javascript', theme: 'vitesse-dark' });
+        }
+        return true;
+    }
+    catch (error) {
+        console.warn('[markstream-svelte] Failed to warm up stream-monaco tokenizer.', error);
+        return false;
+    }
+}
+export async function getUseMonaco() {
+    if (monacoModule)
+        return monacoModule;
+    if (pendingImport)
+        return await pendingImport;
+    if (importAttempted)
+        return null;
+    pendingImport = (async () => {
+        var _a;
+        try {
+            const imported = await import('stream-monaco');
+            monacoModule = (_a = imported === null || imported === void 0 ? void 0 : imported.default) !== null && _a !== void 0 ? _a : imported;
+            await preloadWorkers(monacoModule);
+            codeBlockRuntimeReady = true;
+            void warmupShikiTokenizer(monacoModule);
+            return monacoModule;
+        }
+        catch {
+            importAttempted = true;
+            return null;
+        }
+    })();
+    try {
+        return await pendingImport;
+    }
+    finally {
+        pendingImport = null;
+    }
+}

package/dist/parseNestedMarkdownToNodes.d.ts

@@ -0,0 +1,15 @@
+import type { BaseNode, MarkdownIt, ParseOptions } from 'stream-markdown-parser';
+export interface NestedMarkdownNodesInput {
+    node?: (BaseNode & Record<string, any>) | null;
+    nodes?: readonly BaseNode[] | null;
+    content?: string | null;
+}
+export interface NestedMarkdownNodesOptions {
+    cacheKey?: string;
+    final?: boolean;
+    parseOptions?: ParseOptions;
+    customHtmlTags?: readonly string[];
+    customMarkdownIt?: (markdown: MarkdownIt) => MarkdownIt;
+}
+export declare function parseNestedMarkdownToNodes(input: NestedMarkdownNodesInput, options?: NestedMarkdownNodesOptions): BaseNode[];
+//# sourceMappingURL=parseNestedMarkdownToNodes.d.ts.map

package/dist/parseNestedMarkdownToNodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseNestedMarkdownToNodes.d.ts","sourceRoot":"","sources":["../src/parseNestedMarkdownToNodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAIhF,MAAM,WAAW,wBAAwB;IACvC,IAAI,CAAC,EAAE,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,GAAG,IAAI,CAAA;IAC9C,KAAK,CAAC,EAAE,SAAS,QAAQ,EAAE,GAAG,IAAI,CAAA;IAClC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACxB;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAClC,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,UAAU,KAAK,UAAU,CAAA;CACxD;AAKD,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,wBAAwB,EAC/B,OAAO,GAAE,0BAA+B,GACvC,QAAQ,EAAE,CAsBZ"}

package/dist/parseNestedMarkdownToNodes.js

@@ -0,0 +1,66 @@
+import { getMarkdown, mergeCustomHtmlTags, parseMarkdownToStructure } from 'stream-markdown-parser';
+import { hydrateCustomTagContent } from './hydrateCustomTagContent';
+const DEFAULT_CACHE_KEY = 'markstream-svelte-nested-nodes';
+const markdownCache = new Map();
+export function parseNestedMarkdownToNodes(input, options = {}) {
+    if (Array.isArray(input.nodes))
+        return input.nodes.slice();
+    const nestedNode = input.node;
+    if (nestedNode) {
+        const children = getNodeList(nestedNode.children);
+        if (children.length > 0)
+            return children.slice();
+    }
+    const content = resolveContent(input);
+    if (!content)
+        return [];
+    const parseOptions = resolveParseOptions(input, options);
+    const markdown = resolveMarkdownInstance(options);
+    return hydrateCustomTagContent(parseMarkdownToStructure(content, markdown, parseOptions), content, mergeCustomHtmlTags(options.customHtmlTags, parseOptions === null || parseOptions === void 0 ? void 0 : parseOptions.customHtmlTags));
+}
+function resolveContent(input) {
+    var _a;
+    if (typeof input.content === 'string')
+        return input.content;
+    if (typeof ((_a = input.node) === null || _a === void 0 ? void 0 : _a.content) === 'string')
+        return input.node.content;
+    return '';
+}
+function resolveParseOptions(input, options) {
+    var _a, _b;
+    const base = (_a = options.parseOptions) !== null && _a !== void 0 ? _a : {};
+    const resolvedFinal = (_b = options.final) !== null && _b !== void 0 ? _b : resolveFinalFromNode(input.node);
+    const customHtmlTags = mergeCustomHtmlTags(options.customHtmlTags, base.customHtmlTags);
+    if (resolvedFinal == null && customHtmlTags.length === 0)
+        return base;
+    return {
+        ...base,
+        ...(resolvedFinal == null ? {} : { final: resolvedFinal }),
+        ...(customHtmlTags.length === 0 ? {} : { customHtmlTags }),
+    };
+}
+function resolveFinalFromNode(node) {
+    if (!node || typeof node !== 'object')
+        return undefined;
+    if (typeof node.loading === 'boolean')
+        return !node.loading;
+    return undefined;
+}
+function resolveMarkdownInstance(options) {
+    var _a;
+    const normalizedTags = mergeCustomHtmlTags(options.customHtmlTags, (_a = options.parseOptions) === null || _a === void 0 ? void 0 : _a.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 options.customMarkdownIt
+        ? options.customMarkdownIt(markdown)
+        : markdown;
+}
+function getNodeList(value) {
+    return Array.isArray(value) ? value : [];
+}

package/dist/renderMarkdownHtml.d.ts

@@ -0,0 +1,31 @@
+import type { BaseNode, HtmlPolicy, ParsedNode, ParseOptions } from 'stream-markdown-parser';
+export type RenderableMarkdownNode = (ParsedNode | BaseNode) & Record<string, unknown>;
+type NestedClassValue = string | readonly string[] | null | undefined;
+export interface MarkstreamSvelteRenderOptions {
+    content?: string | null;
+    nodes?: readonly RenderableMarkdownNode[] | null;
+    final?: boolean;
+    parseOptions?: ParseOptions;
+    customHtmlTags?: readonly string[];
+    allowHtml?: boolean;
+    htmlPolicy?: HtmlPolicy;
+}
+export interface NestedMarkdownHtmlOptions {
+    cacheKey?: string;
+    customHtmlTags?: readonly string[];
+    allowHtml?: boolean;
+    htmlPolicy?: HtmlPolicy;
+    customNodeTag?: string;
+    customNodeClass?: NestedClassValue | ((node: RenderableMarkdownNode) => NestedClassValue);
+}
+export interface NestedMarkdownHtmlInput {
+    node?: RenderableMarkdownNode | null;
+    nodes?: readonly RenderableMarkdownNode[] | null;
+    content?: string | null;
+}
+export declare function renderMarkdownToHtml(input: MarkstreamSvelteRenderOptions): string;
+export declare function renderNestedMarkdownToHtml(input: NestedMarkdownHtmlInput, options?: NestedMarkdownHtmlOptions): string;
+export declare function renderMarkdownNodesToHtml(nodes: readonly RenderableMarkdownNode[] | null | undefined, options?: NestedMarkdownHtmlOptions): string;
+export declare function renderMarkdownNodeToHtml(node: RenderableMarkdownNode | null | undefined, options?: NestedMarkdownHtmlOptions): string;
+export {};
+//# sourceMappingURL=renderMarkdownHtml.d.ts.map

package/dist/renderMarkdownHtml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderMarkdownHtml.d.ts","sourceRoot":"","sources":["../src/renderMarkdownHtml.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAwB,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAclH,MAAM,MAAM,sBAAsB,GAAG,CAAC,UAAU,GAAG,QAAQ,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEtF,KAAK,gBAAgB,GAAG,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,CAAA;AAErE,MAAM,WAAW,6BAA6B;IAC5C,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,KAAK,CAAC,EAAE,SAAS,sBAAsB,EAAE,GAAG,IAAI,CAAA;IAChD,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,YAAY,CAAC,EAAE,YAAY,CAAA;IAC3B,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAClC,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,UAAU,CAAC,EAAE,UAAU,CAAA;CACxB;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IAClC,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,UAAU,CAAC,EAAE,UAAU,CAAA;IACvB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,eAAe,CAAC,EAAE,gBAAgB,GAAG,CAAC,CAAC,IAAI,EAAE,sBAAsB,KAAK,gBAAgB,CAAC,CAAA;CAC1F;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAAA;IACpC,KAAK,CAAC,EAAE,SAAS,sBAAsB,EAAE,GAAG,IAAI,CAAA;IAChD,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACxB;AAiDD,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,6BAA6B,GAAG,MAAM,CAYjF;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,uBAAuB,EAC9B,OAAO,GAAE,yBAA8B,GACtC,MAAM,CAGR;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,sBAAsB,EAAE,GAAG,IAAI,GAAG,SAAS,EAC3D,OAAO,GAAE,yBAA8B,GACtC,MAAM,CAGR;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,sBAAsB,GAAG,IAAI,GAAG,SAAS,EAC/C,OAAO,GAAE,yBAA8B,GACtC,MAAM,CAGR"}