vanilla-intlayer 8.8.0 → 8.9.0

package/dist/esm/markdown/MarkdownRenderer.mjs

@@ -1,19 +1,39 @@
-import { compileMarkdown as e } from "./compiler.mjs";
-import { useMarkdown as t } from "./installIntlayerMarkdown.mjs";
+import { compileMarkdown } from "./compiler.mjs";
+import { useMarkdown } from "./installIntlayerMarkdown.mjs";
+
 //#region src/markdown/MarkdownRenderer.ts
-var n = (t, { forceBlock: n, forceInline: r, preserveFrontmatter: i, tagfilter: a } = {}) => e(t, {
-	forceBlock: n,
-	forceInline: r,
-	preserveFrontmatter: i,
-	tagfilter: a
-}), r = (e = {}) => {
-	let n = t();
-	return (t) => n.renderMarkdown(t, {
-		forceBlock: e.forceBlock,
-		forceInline: e.forceInline,
-		preserveFrontmatter: e.preserveFrontmatter,
-		tagfilter: e.tagfilter
-	}, e.components, e.wrapper);
+/**
+* Renders markdown to an HTML string without using the global provider.
+*
+* @example
+* ```ts
+* import { renderMarkdown } from 'vanilla-intlayer/markdown';
+*
+* document.querySelector('#content').innerHTML = renderMarkdown('# Hello **World**');
+* ```
+*/
+const renderMarkdown = (content, { forceBlock, forceInline, preserveFrontmatter, tagfilter } = {}) => {
+	return compileMarkdown(content, {
+		forceBlock,
+		forceInline,
+		preserveFrontmatter,
+		tagfilter
+	});
 };
+/**
+* Returns a render function that uses the global provider's configuration
+* (installed via `installIntlayerMarkdown`), falling back to `compileMarkdown`.
+*/
+const useMarkdownRenderer = (props = {}) => {
+	const provider = useMarkdown();
+	return (content) => provider.renderMarkdown(content, {
+		forceBlock: props.forceBlock,
+		forceInline: props.forceInline,
+		preserveFrontmatter: props.preserveFrontmatter,
+		tagfilter: props.tagfilter
+	}, props.components, props.wrapper);
+};
+
 //#endregion
-export { n as renderMarkdown, r as useMarkdownRenderer };
+export { renderMarkdown, useMarkdownRenderer };
+//# sourceMappingURL=MarkdownRenderer.mjs.map

package/dist/esm/markdown/MarkdownRenderer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"MarkdownRenderer.mjs","names":[],"sources":["../../../src/markdown/MarkdownRenderer.ts"],"sourcesContent":["import type { HTMLComponents } from '../html/types';\nimport { compileMarkdown, type MarkdownCompilerOptions } from './compiler';\nimport {\n  type MarkdownProviderOptions,\n  type RenderMarkdownFunction,\n  useMarkdown,\n} from './installIntlayerMarkdown';\n\nexport type RenderMarkdownProps = MarkdownProviderOptions & {\n  components?: HTMLComponents<'permissive', {}>;\n  wrapper?: string;\n};\n\n/**\n * Renders markdown to an HTML string without using the global provider.\n *\n * @example\n * ```ts\n * import { renderMarkdown } from 'vanilla-intlayer/markdown';\n *\n * document.querySelector('#content').innerHTML = renderMarkdown('# Hello **World**');\n * ```\n */\nexport const renderMarkdown = (\n  content: string,\n  {\n    forceBlock,\n    forceInline,\n    preserveFrontmatter,\n    tagfilter,\n  }: RenderMarkdownProps = {}\n): string => {\n  const options: MarkdownCompilerOptions = {\n    forceBlock,\n    forceInline,\n    preserveFrontmatter,\n    tagfilter,\n  };\n  return compileMarkdown(content, options);\n};\n\n/**\n * Returns a render function that uses the global provider's configuration\n * (installed via `installIntlayerMarkdown`), falling back to `compileMarkdown`.\n */\nexport const useMarkdownRenderer = (\n  props: RenderMarkdownProps = {}\n): ((content: string) => string | Promise<string>) => {\n  const provider = useMarkdown();\n\n  return (content: string) =>\n    provider.renderMarkdown(\n      content,\n      {\n        forceBlock: props.forceBlock,\n        forceInline: props.forceInline,\n        preserveFrontmatter: props.preserveFrontmatter,\n        tagfilter: props.tagfilter,\n      },\n      props.components,\n      props.wrapper\n    );\n};\n"],"mappings":";;;;;;;;;;;;;;AAuBA,MAAa,kBACX,SACA,EACE,YACA,aACA,qBACA,cACuB,EAAE,KAChB;AAOX,QAAO,gBAAgB,SAAS;EAL9B;EACA;EACA;EACA;EAEqC,CAAC;;;;;;AAO1C,MAAa,uBACX,QAA6B,EAAE,KACqB;CACpD,MAAM,WAAW,aAAa;AAE9B,SAAQ,YACN,SAAS,eACP,SACA;EACE,YAAY,MAAM;EAClB,aAAa,MAAM;EACnB,qBAAqB,MAAM;EAC3B,WAAW,MAAM;EAClB,EACD,MAAM,YACN,MAAM,QACP"}

package/dist/esm/markdown/compiler.mjs

@@ -1,6 +1,30 @@
-import e from "./runtime.mjs";
-import { RuleType as t, compileWithOptions as n, sanitizer as r, slugify as i } from "@intlayer/core/markdown";
+import vanillaRuntime from "./runtime.mjs";
+import { RuleType, compileWithOptions, sanitizer as defaultSanitizer, slugify as defaultSlugify } from "@intlayer/core/markdown";
+
 //#region src/markdown/compiler.ts
-var a = (t = "", r = {}) => n(t, e, r), o = a, s = a;
+/**
+* Vanilla JS adapter for the framework-agnostic markdown processor.
+*
+* Compiles markdown to an HTML string for use with `innerHTML` or the
+* `renderMarkdown` utility.
+*/
+/**
+* Compile markdown to an HTML string.
+*
+* The resulting string can be inserted into the DOM via `element.innerHTML`
+* or the `renderMarkdown` helper.
+*
+* @example
+* ```ts
+* import { compileMarkdown } from 'vanilla-intlayer/markdown';
+*
+* document.querySelector('#content').innerHTML = compileMarkdown('# Hello **World**');
+* ```
+*/
+const compileMarkdown = (markdown = "", options = {}) => compileWithOptions(markdown, vanillaRuntime, options);
+const compiler = compileMarkdown;
+const compile = compileMarkdown;
+
 //#endregion
-export { t as RuleType, s as compile, a as compileMarkdown, o as compiler, r as sanitizer, i as slugify };
+export { RuleType, compile, compileMarkdown, compiler, defaultSanitizer as sanitizer, defaultSlugify as slugify };
+//# sourceMappingURL=compiler.mjs.map

package/dist/esm/markdown/compiler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler.mjs","names":[],"sources":["../../../src/markdown/compiler.ts"],"sourcesContent":["/**\n * Vanilla JS adapter for the framework-agnostic markdown processor.\n *\n * Compiles markdown to an HTML string for use with `innerHTML` or the\n * `renderMarkdown` utility.\n */\n\nimport {\n  type CompileOptions,\n  compileWithOptions,\n  sanitizer as defaultSanitizer,\n  slugify as defaultSlugify,\n  RuleType,\n} from '@intlayer/core/markdown';\nimport { vanillaRuntime } from './runtime';\n\n// Re-export utilities for compatibility\nexport { defaultSanitizer as sanitizer, defaultSlugify as slugify, RuleType };\n\nexport type MarkdownCompilerOptions = CompileOptions;\n\n/**\n * Compile markdown to an HTML string.\n *\n * The resulting string can be inserted into the DOM via `element.innerHTML`\n * or the `renderMarkdown` helper.\n *\n * @example\n * ```ts\n * import { compileMarkdown } from 'vanilla-intlayer/markdown';\n *\n * document.querySelector('#content').innerHTML = compileMarkdown('# Hello **World**');\n * ```\n */\nexport const compileMarkdown = (\n  markdown = '',\n  options: MarkdownCompilerOptions = {}\n): string => compileWithOptions(markdown, vanillaRuntime, options) as string;\n\n// Aliases for consistency with other adapters\nexport const compiler = compileMarkdown;\nexport const compile = compileMarkdown;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAkCA,MAAa,mBACX,WAAW,IACX,UAAmC,EAAE,KAC1B,mBAAmB,UAAU,gBAAgB,QAAQ;AAGlE,MAAa,WAAW;AACxB,MAAa,UAAU"}

package/dist/esm/markdown/index.mjs

@@ -1,4 +1,5 @@
-import { compileMarkdown as e } from "./compiler.mjs";
-import { installIntlayerMarkdown as t, installIntlayerMarkdownDynamic as n, useMarkdown as r } from "./installIntlayerMarkdown.mjs";
-import { renderMarkdown as i, useMarkdownRenderer as a } from "./MarkdownRenderer.mjs";
-export { e as compileMarkdown, t as installIntlayerMarkdown, n as installIntlayerMarkdownDynamic, i as renderMarkdown, r as useMarkdown, a as useMarkdownRenderer };
+import { compileMarkdown } from "./compiler.mjs";
+import { installIntlayerMarkdown, installIntlayerMarkdownDynamic, useMarkdown } from "./installIntlayerMarkdown.mjs";
+import { renderMarkdown, useMarkdownRenderer } from "./MarkdownRenderer.mjs";
+
+export { compileMarkdown, installIntlayerMarkdown, installIntlayerMarkdownDynamic, renderMarkdown, useMarkdown, useMarkdownRenderer };

package/dist/esm/markdown/installIntlayerMarkdown.mjs

@@ -1,31 +1,94 @@
-import { compileMarkdown as e } from "./compiler.mjs";
+import { compileMarkdown } from "./compiler.mjs";
+
 //#region src/markdown/installIntlayerMarkdown.ts
-var t = null, n = (e, n) => t || (t = {
-	components: n,
-	renderMarkdown: e
-}, t), r = (t) => {
-	let r, i;
-	if (typeof t == "function") r = t;
+/**
+* Singleton instance
+*/
+let instance = null;
+/**
+* Create and return a single IntlayerMarkdownProvider instance.
+*/
+const createIntlayerMarkdownClient = (renderMarkdown, components) => {
+	if (instance) return instance;
+	instance = {
+		components,
+		renderMarkdown
+	};
+	return instance;
+};
+/**
+* Install the Intlayer Markdown provider for your vanilla JS application.
+*
+* @example
+* ```ts
+* import { installIntlayerMarkdown } from 'vanilla-intlayer/markdown';
+*
+* installIntlayerMarkdown({ forceBlock: true });
+* ```
+*/
+const installIntlayerMarkdown = (pluginOptions) => {
+	let renderMarkdown;
+	let providerComponents;
+	if (typeof pluginOptions === "function") renderMarkdown = pluginOptions;
 	else {
-		let { components: n, wrapper: a, forceBlock: o, forceInline: s, preserveFrontmatter: c, tagfilter: l, renderMarkdown: u } = t ?? {};
-		if (i = n, u) r = u;
+		const { components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter, renderMarkdown: customRender } = pluginOptions ?? {};
+		providerComponents = components;
+		if (customRender) renderMarkdown = customRender;
 		else {
-			let t = {
-				forceBlock: o,
-				forceInline: s,
-				preserveFrontmatter: c,
-				tagfilter: l
+			const internalOptions = {
+				forceBlock,
+				forceInline,
+				preserveFrontmatter,
+				tagfilter
 			};
-			r = (n, r, i, a) => e(n, {
-				...t,
-				forceBlock: r?.forceBlock ?? t.forceBlock,
-				forceInline: r?.forceInline ?? t.forceInline,
-				preserveFrontmatter: r?.preserveFrontmatter ?? t.preserveFrontmatter,
-				tagfilter: r?.tagfilter ?? t.tagfilter
+			renderMarkdown = (markdown, options, _componentsOverride, _wrapperOverride) => compileMarkdown(markdown, {
+				...internalOptions,
+				forceBlock: options?.forceBlock ?? internalOptions.forceBlock,
+				forceInline: options?.forceInline ?? internalOptions.forceInline,
+				preserveFrontmatter: options?.preserveFrontmatter ?? internalOptions.preserveFrontmatter,
+				tagfilter: options?.tagfilter ?? internalOptions.tagfilter
 			});
 		}
 	}
-	return n(r, i);
-}, i = () => t || { renderMarkdown: (t) => e(t) }, a = async (e) => t || r(await e());
+	return createIntlayerMarkdownClient(renderMarkdown, providerComponents);
+};
+/**
+* Access the installed IntlayerMarkdownProvider.
+* Returns a fallback renderer that compiles with default options if no
+* provider has been installed.
+*/
+const useMarkdown = () => {
+	if (instance) return instance;
+	return { renderMarkdown: (markdown) => compileMarkdown(markdown) };
+};
+/**
+* Asynchronously install a markdown renderer whose implementation is loaded
+* via a dynamic `import()`.
+*
+* Use this to keep the markdown compiler out of the initial bundle — the
+* loader is only called the first time this function is executed.
+*
+* The returned promise resolves once the provider is ready. Any calls to
+* `useMarkdown()` before the promise resolves will use the fallback
+* (raw-string) renderer.
+*
+* @param loader - A zero-argument async function that resolves to either a
+*   `RenderMarkdownFunction` or an `IntlayerMarkdownPluginOptions` object.
+*
+* @example
+* ```ts
+* // Load a custom markdown renderer (e.g. marked) only when needed
+* await installIntlayerMarkdownDynamic(async () => {
+*   const { marked } = await import('marked');
+*   return (markdown) => marked(markdown) as string;
+* });
+* ```
+*/
+const installIntlayerMarkdownDynamic = async (loader) => {
+	if (instance) return instance;
+	return installIntlayerMarkdown(await loader());
+};
+
 //#endregion
-export { n as createIntlayerMarkdownClient, r as installIntlayerMarkdown, a as installIntlayerMarkdownDynamic, i as useMarkdown };
+export { createIntlayerMarkdownClient, installIntlayerMarkdown, installIntlayerMarkdownDynamic, useMarkdown };
+//# sourceMappingURL=installIntlayerMarkdown.mjs.map

package/dist/esm/markdown/installIntlayerMarkdown.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"installIntlayerMarkdown.mjs","names":[],"sources":["../../../src/markdown/installIntlayerMarkdown.ts"],"sourcesContent":["import type { HTMLComponents } from '../html/types';\nimport { compileMarkdown, type MarkdownCompilerOptions } from './compiler';\n\nexport type MarkdownProviderOptions = {\n  /** Forces the compiler to always output content with a block-level wrapper. */\n  forceBlock?: boolean;\n  /** Forces the compiler to always output content with an inline wrapper. */\n  forceInline?: boolean;\n  /** Whether to preserve frontmatter in the markdown content. */\n  preserveFrontmatter?: boolean;\n  /** Whether to use the GitHub Tag Filter. */\n  tagfilter?: boolean;\n};\n\nexport type RenderMarkdownOptions = MarkdownProviderOptions & {\n  components?: HTMLComponents<'permissive', {}>;\n  wrapper?: string;\n};\n\nexport type RenderMarkdownFunction = (\n  markdown: string,\n  options?: MarkdownProviderOptions,\n  components?: HTMLComponents<'permissive', {}>,\n  wrapper?: string\n) => string | Promise<string>;\n\n/**\n * Singleton instance\n */\nlet instance: IntlayerMarkdownProvider | null = null;\n\nexport type IntlayerMarkdownProvider = {\n  components?: HTMLComponents<'permissive', {}>;\n  renderMarkdown: RenderMarkdownFunction;\n};\n\nexport type IntlayerMarkdownPluginOptions = MarkdownProviderOptions & {\n  components?: HTMLComponents<'permissive', {}>;\n  wrapper?: string;\n  renderMarkdown?: RenderMarkdownFunction;\n};\n\n/**\n * Create and return a single IntlayerMarkdownProvider instance.\n */\nexport const createIntlayerMarkdownClient = (\n  renderMarkdown: RenderMarkdownFunction,\n  components?: HTMLComponents<'permissive', {}>\n): IntlayerMarkdownProvider => {\n  if (instance) return instance;\n\n  instance = { components, renderMarkdown };\n  return instance;\n};\n\n/**\n * Install the Intlayer Markdown provider for your vanilla JS application.\n *\n * @example\n * ```ts\n * import { installIntlayerMarkdown } from 'vanilla-intlayer/markdown';\n *\n * installIntlayerMarkdown({ forceBlock: true });\n * ```\n */\nexport const installIntlayerMarkdown = (\n  pluginOptions?: IntlayerMarkdownPluginOptions | RenderMarkdownFunction\n): IntlayerMarkdownProvider => {\n  let renderMarkdown: RenderMarkdownFunction;\n  let providerComponents: HTMLComponents<'permissive', {}> | undefined;\n\n  if (typeof pluginOptions === 'function') {\n    renderMarkdown = pluginOptions;\n  } else {\n    const {\n      components,\n      wrapper,\n      forceBlock,\n      forceInline,\n      preserveFrontmatter,\n      tagfilter,\n      renderMarkdown: customRender,\n    } = pluginOptions ?? {};\n\n    providerComponents = components;\n\n    if (customRender) {\n      renderMarkdown = customRender;\n    } else {\n      const internalOptions: MarkdownCompilerOptions = {\n        forceBlock,\n        forceInline,\n        preserveFrontmatter,\n        tagfilter,\n      };\n\n      renderMarkdown = (\n        markdown,\n        options,\n        _componentsOverride,\n        _wrapperOverride\n      ) =>\n        compileMarkdown(markdown, {\n          ...internalOptions,\n          forceBlock: options?.forceBlock ?? internalOptions.forceBlock,\n          forceInline: options?.forceInline ?? internalOptions.forceInline,\n          preserveFrontmatter:\n            options?.preserveFrontmatter ?? internalOptions.preserveFrontmatter,\n          tagfilter: options?.tagfilter ?? internalOptions.tagfilter,\n        });\n    }\n  }\n\n  return createIntlayerMarkdownClient(renderMarkdown, providerComponents);\n};\n\n/**\n * Access the installed IntlayerMarkdownProvider.\n * Returns a fallback renderer that compiles with default options if no\n * provider has been installed.\n */\nexport const useMarkdown = (): IntlayerMarkdownProvider => {\n  if (instance) return instance;\n\n  return {\n    renderMarkdown: (markdown) => compileMarkdown(markdown),\n  };\n};\n\n/**\n * Asynchronously install a markdown renderer whose implementation is loaded\n * via a dynamic `import()`.\n *\n * Use this to keep the markdown compiler out of the initial bundle — the\n * loader is only called the first time this function is executed.\n *\n * The returned promise resolves once the provider is ready. Any calls to\n * `useMarkdown()` before the promise resolves will use the fallback\n * (raw-string) renderer.\n *\n * @param loader - A zero-argument async function that resolves to either a\n *   `RenderMarkdownFunction` or an `IntlayerMarkdownPluginOptions` object.\n *\n * @example\n * ```ts\n * // Load a custom markdown renderer (e.g. marked) only when needed\n * await installIntlayerMarkdownDynamic(async () => {\n *   const { marked } = await import('marked');\n *   return (markdown) => marked(markdown) as string;\n * });\n * ```\n */\nexport const installIntlayerMarkdownDynamic = async (\n  loader: () => Promise<IntlayerMarkdownPluginOptions | RenderMarkdownFunction>\n): Promise<IntlayerMarkdownProvider> => {\n  if (instance) return instance;\n  const pluginOptions = await loader();\n  return installIntlayerMarkdown(pluginOptions);\n};\n"],"mappings":";;;;;;AA6BA,IAAI,WAA4C;;;;AAgBhD,MAAa,gCACX,gBACA,eAC6B;AAC7B,KAAI,SAAU,QAAO;AAErB,YAAW;EAAE;EAAY;EAAgB;AACzC,QAAO;;;;;;;;;;;;AAaT,MAAa,2BACX,kBAC6B;CAC7B,IAAI;CACJ,IAAI;AAEJ,KAAI,OAAO,kBAAkB,WAC3B,kBAAiB;MACZ;EACL,MAAM,EACJ,YACA,SACA,YACA,aACA,qBACA,WACA,gBAAgB,iBACd,iBAAiB,EAAE;AAEvB,uBAAqB;AAErB,MAAI,aACF,kBAAiB;OACZ;GACL,MAAM,kBAA2C;IAC/C;IACA;IACA;IACA;IACD;AAED,qBACE,UACA,SACA,qBACA,qBAEA,gBAAgB,UAAU;IACxB,GAAG;IACH,YAAY,SAAS,cAAc,gBAAgB;IACnD,aAAa,SAAS,eAAe,gBAAgB;IACrD,qBACE,SAAS,uBAAuB,gBAAgB;IAClD,WAAW,SAAS,aAAa,gBAAgB;IAClD,CAAC;;;AAIR,QAAO,6BAA6B,gBAAgB,mBAAmB;;;;;;;AAQzE,MAAa,oBAA8C;AACzD,KAAI,SAAU,QAAO;AAErB,QAAO,EACL,iBAAiB,aAAa,gBAAgB,SAAS,EACxD;;;;;;;;;;;;;;;;;;;;;;;;;AA0BH,MAAa,iCAAiC,OAC5C,WACsC;AACtC,KAAI,SAAU,QAAO;AAErB,QAAO,wBAAwB,MADH,QAAQ,CACS"}

package/dist/esm/markdown/runtime.mjs

@@ -1,5 +1,5 @@
 //#region src/markdown/runtime.ts
-var e = new Set([
+const SELF_CLOSING_TAGS = new Set([
 	"area",
 	"base",
 	"br",
@@ -14,38 +14,70 @@ var e = new Set([
 	"source",
 	"track",
 	"wbr"
-]), t = (e) => e ? Object.entries(e).filter(([, e]) => e != null).map(([e, t]) => typeof t == "boolean" ? t ? e : "" : e === "_innerHTML" ? "" : `${e}="${String(t).replace(/&/g, "&").replace(/"/g, """)}"`).filter(Boolean).join(" ") : "", n = "__vanilla_fragment__", r = {
-	createElement: (r, i, ...a) => {
-		let o = a.flat(Infinity).join("");
-		if (r === n) return o;
-		if (typeof r == "string") {
-			let n = t(i), a = n ? ` ${n}` : "", s = i?._innerHTML;
-			return e.has(r) ? `<${r}${a}>` : s === void 0 ? `<${r}${a}>${o}</${r}>` : `<${r}${a}>${s}</${r}>`;
+]);
+const buildPropsString = (props) => {
+	if (!props) return "";
+	return Object.entries(props).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => {
+		if (typeof v === "boolean") return v ? k : "";
+		if (k === "_innerHTML") return "";
+		return `${k}="${String(v).replace(/&/g, "&amp;").replace(/"/g, "&quot;")}"`;
+	}).filter(Boolean).join(" ");
+};
+const VANILLA_FRAGMENT = "__vanilla_fragment__";
+/**
+* Vanilla-specific MarkdownRuntime that produces HTML strings.
+*/
+const vanillaRuntime = {
+	createElement: (type, props, ...children) => {
+		const childStr = children.flat(Infinity).join("");
+		if (type === VANILLA_FRAGMENT) return childStr;
+		if (typeof type === "string") {
+			const propsStr = buildPropsString(props);
+			const propsWithSpace = propsStr ? ` ${propsStr}` : "";
+			const innerHTML = props?._innerHTML;
+			if (SELF_CLOSING_TAGS.has(type)) return `<${type}${propsWithSpace}>`;
+			if (innerHTML !== void 0) return `<${type}${propsWithSpace}>${innerHTML}</${type}>`;
+			return `<${type}${propsWithSpace}>${childStr}</${type}>`;
 		}
-		if (typeof r == "function") try {
-			let e = r({
-				...i,
-				children: o
+		if (typeof type === "function") try {
+			const result = type({
+				...props,
+				children: childStr
 			});
-			return typeof e == "string" ? e : o;
+			return typeof result === "string" ? result : childStr;
 		} catch {
-			return o;
+			return childStr;
 		}
-		return o;
+		return childStr;
+	},
+	cloneElement: (element, _props, ..._children) => {
+		return typeof element === "string" ? element : String(element ?? "");
 	},
-	cloneElement: (e, t, ...n) => typeof e == "string" ? e : String(e ?? ""),
-	Fragment: n,
-	normalizeProps: (e, t) => {
-		let n = {};
-		for (let [e, r] of Object.entries(t)) e === "className" ? n.class = r : e === "htmlFor" ? n.for = r : e === "dangerouslySetInnerHTML" && r?.__html ? n._innerHTML = r.__html : n[e] = r;
-		return n;
+	Fragment: VANILLA_FRAGMENT,
+	/**
+	* Normalize props to standard HTML attribute names.
+	*/
+	normalizeProps: (_tag, props) => {
+		const normalized = {};
+		for (const [key, value] of Object.entries(props)) if (key === "className") normalized.class = value;
+		else if (key === "htmlFor") normalized.for = value;
+		else if (key === "dangerouslySetInnerHTML" && value?.__html) normalized._innerHTML = value.__html;
+		else normalized[key] = value;
+		return normalized;
 	}
-}, i = (e = {}) => {
-	let { onCreateElement: t } = e;
-	return t ? {
-		...r,
-		createElement: (e, n, ...r) => t(e, n, r)
-	} : r;
 };
+/**
+* Creates a vanilla runtime with a custom createElement for advanced use cases.
+*/
+const createVanillaRuntime = (options = {}) => {
+	const { onCreateElement } = options;
+	if (onCreateElement) return {
+		...vanillaRuntime,
+		createElement: (type, props, ...children) => onCreateElement(type, props, children)
+	};
+	return vanillaRuntime;
+};
+
 //#endregion
-export { i as createVanillaRuntime, r as default, r as vanillaRuntime };
+export { createVanillaRuntime, vanillaRuntime as default, vanillaRuntime };
+//# sourceMappingURL=runtime.mjs.map

package/dist/esm/markdown/runtime.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.mjs","names":[],"sources":["../../../src/markdown/runtime.ts"],"sourcesContent":["/**\n * Vanilla JS adapter for the framework-agnostic markdown processor.\n *\n * Builds HTML strings which can be inserted into the DOM via `innerHTML`\n * or the `renderMarkdown` utility.\n */\n\nimport type { HTMLTag, MarkdownRuntime } from '@intlayer/core/markdown';\n\nconst SELF_CLOSING_TAGS = new Set([\n  'area',\n  'base',\n  'br',\n  'col',\n  'embed',\n  'hr',\n  'img',\n  'input',\n  'link',\n  'meta',\n  'param',\n  'source',\n  'track',\n  'wbr',\n]);\n\nconst buildPropsString = (props: Record<string, any> | null): string => {\n  if (!props) return '';\n\n  return Object.entries(props)\n    .filter(([, v]) => v !== undefined && v !== null)\n    .map(([k, v]) => {\n      if (typeof v === 'boolean') return v ? k : '';\n      if (k === '_innerHTML') return ''; // handled separately\n      return `${k}=\"${String(v).replace(/&/g, '&amp;').replace(/\"/g, '&quot;')}\"`;\n    })\n    .filter(Boolean)\n    .join(' ');\n};\n\nconst VANILLA_FRAGMENT = '__vanilla_fragment__';\n\n/**\n * Vanilla-specific MarkdownRuntime that produces HTML strings.\n */\nexport const vanillaRuntime: MarkdownRuntime = {\n  createElement: (\n    type: any,\n    props: Record<string, any> | null,\n    ...children: any[]\n  ): string => {\n    const childStr = children.flat(Infinity).join('');\n\n    if (type === VANILLA_FRAGMENT) return childStr;\n\n    if (typeof type === 'string') {\n      const propsStr = buildPropsString(props);\n      const propsWithSpace = propsStr ? ` ${propsStr}` : '';\n      const innerHTML = props?._innerHTML;\n\n      if (SELF_CLOSING_TAGS.has(type)) {\n        return `<${type}${propsWithSpace}>`;\n      }\n\n      if (innerHTML !== undefined) {\n        return `<${type}${propsWithSpace}>${innerHTML}</${type}>`;\n      }\n\n      return `<${type}${propsWithSpace}>${childStr}</${type}>`;\n    }\n\n    // Function component override — returns a string\n    if (typeof type === 'function') {\n      try {\n        const result = type({ ...props, children: childStr });\n        return typeof result === 'string' ? result : childStr;\n      } catch {\n        return childStr;\n      }\n    }\n\n    return childStr;\n  },\n\n  cloneElement: (\n    element: unknown,\n    _props: Record<string, any>,\n    ..._children: any[]\n  ): string => {\n    return typeof element === 'string' ? element : String(element ?? '');\n  },\n\n  Fragment: VANILLA_FRAGMENT as any,\n\n  /**\n   * Normalize props to standard HTML attribute names.\n   */\n  normalizeProps: (\n    _tag: HTMLTag,\n    props: Record<string, any>\n  ): Record<string, any> => {\n    const normalized: Record<string, any> = {};\n\n    for (const [key, value] of Object.entries(props)) {\n      if (key === 'className') {\n        normalized.class = value;\n      } else if (key === 'htmlFor') {\n        normalized.for = value;\n      } else if (key === 'dangerouslySetInnerHTML' && value?.__html) {\n        normalized._innerHTML = value.__html;\n      } else {\n        normalized[key] = value;\n      }\n    }\n\n    return normalized;\n  },\n};\n\n/**\n * Creates a vanilla runtime with a custom createElement for advanced use cases.\n */\nexport const createVanillaRuntime = (\n  options: {\n    onCreateElement?: (\n      type: any,\n      props: Record<string, any> | null,\n      children: any[]\n    ) => string;\n  } = {}\n): MarkdownRuntime => {\n  const { onCreateElement } = options;\n\n  if (onCreateElement) {\n    return {\n      ...vanillaRuntime,\n      createElement: (\n        type: any,\n        props: Record<string, any> | null,\n        ...children: any[]\n      ): string => onCreateElement(type, props, children),\n    };\n  }\n\n  return vanillaRuntime;\n};\n\nexport default vanillaRuntime;\n"],"mappings":";AASA,MAAM,oBAAoB,IAAI,IAAI;CAChC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;AAEF,MAAM,oBAAoB,UAA8C;AACtE,KAAI,CAAC,MAAO,QAAO;AAEnB,QAAO,OAAO,QAAQ,MAAM,CACzB,QAAQ,GAAG,OAAO,MAAM,UAAa,MAAM,KAAK,CAChD,KAAK,CAAC,GAAG,OAAO;AACf,MAAI,OAAO,MAAM,UAAW,QAAO,IAAI,IAAI;AAC3C,MAAI,MAAM,aAAc,QAAO;AAC/B,SAAO,GAAG,EAAE,IAAI,OAAO,EAAE,CAAC,QAAQ,MAAM,QAAQ,CAAC,QAAQ,MAAM,SAAS,CAAC;GACzE,CACD,OAAO,QAAQ,CACf,KAAK,IAAI;;AAGd,MAAM,mBAAmB;;;;AAKzB,MAAa,iBAAkC;CAC7C,gBACE,MACA,OACA,GAAG,aACQ;EACX,MAAM,WAAW,SAAS,KAAK,SAAS,CAAC,KAAK,GAAG;AAEjD,MAAI,SAAS,iBAAkB,QAAO;AAEtC,MAAI,OAAO,SAAS,UAAU;GAC5B,MAAM,WAAW,iBAAiB,MAAM;GACxC,MAAM,iBAAiB,WAAW,IAAI,aAAa;GACnD,MAAM,YAAY,OAAO;AAEzB,OAAI,kBAAkB,IAAI,KAAK,CAC7B,QAAO,IAAI,OAAO,eAAe;AAGnC,OAAI,cAAc,OAChB,QAAO,IAAI,OAAO,eAAe,GAAG,UAAU,IAAI,KAAK;AAGzD,UAAO,IAAI,OAAO,eAAe,GAAG,SAAS,IAAI,KAAK;;AAIxD,MAAI,OAAO,SAAS,WAClB,KAAI;GACF,MAAM,SAAS,KAAK;IAAE,GAAG;IAAO,UAAU;IAAU,CAAC;AACrD,UAAO,OAAO,WAAW,WAAW,SAAS;UACvC;AACN,UAAO;;AAIX,SAAO;;CAGT,eACE,SACA,QACA,GAAG,cACQ;AACX,SAAO,OAAO,YAAY,WAAW,UAAU,OAAO,WAAW,GAAG;;CAGtE,UAAU;;;;CAKV,iBACE,MACA,UACwB;EACxB,MAAM,aAAkC,EAAE;AAE1C,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,CAC9C,KAAI,QAAQ,YACV,YAAW,QAAQ;WACV,QAAQ,UACjB,YAAW,MAAM;WACR,QAAQ,6BAA6B,OAAO,OACrD,YAAW,aAAa,MAAM;MAE9B,YAAW,OAAO;AAItB,SAAO;;CAEV;;;;AAKD,MAAa,wBACX,UAMI,EAAE,KACc;CACpB,MAAM,EAAE,oBAAoB;AAE5B,KAAI,gBACF,QAAO;EACL,GAAG;EACH,gBACE,MACA,OACA,GAAG,aACQ,gBAAgB,MAAM,OAAO,SAAS;EACpD;AAGH,QAAO"}