react-intlayer 8.1.2 → 8.1.3

package/dist/esm/markdown/MarkdownRenderer.mjs

@@ -1,196 +1,2 @@
-import { compiler } from "./processor.mjs";
-import { useMarkdownContext } from "./MarkdownProvider.mjs";
-import { Fragment, jsx } from "react/jsx-runtime";
-
-//#region src/markdown/MarkdownRenderer.tsx
-/**
-* Renders markdown content to JSX with the provided components and options.
-*
-* This function does not use context from MarkdownProvider. Use `useMarkdownRenderer`
-* hook if you want to leverage provider context.
-*
-* @param content - The markdown string to render
-* @param props - Configuration options for rendering
-* @param props.components - Component overrides for HTML tags
-* @param props.wrapper - Wrapper component for multiple children
-* @returns JSX element representing the rendered markdown
-*
-* @example
-* ```tsx
-* import { renderMarkdown } from '@intlayer/react-intlayer/markdown';
-*
-* const markdown = '# Hello World\n\nThis is **bold** text.';
-* const jsx = renderMarkdown(markdown, {
-*   components: {
-*     h1: ({ children }) => <h1 className="title">{children}</h1>,
-*   },
-*   forceBlock: true,
-* });
-* ```
-*/
-const renderMarkdown = (content, { components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter } = {}) => {
-	return compiler(content, {
-		components,
-		forceBlock,
-		forceInline,
-		wrapper,
-		forceWrapper: !!wrapper,
-		preserveFrontmatter,
-		tagfilter
-	});
-};
-/**
-* Hook that returns a function to render markdown content.
-*
-* This hook considers the configuration from the `MarkdownProvider` context if available,
-* falling back to the provided props or default behavior.
-*
-* @param props - Optional configuration that will override context values
-* @param props.components - Component overrides for HTML tags (overrides context)
-* @param props.wrapper - Wrapper component (overrides context)
-* @returns A function that takes markdown content and returns JSX
-*
-* @example
-* ```tsx
-* import { useMarkdownRenderer } from '@intlayer/react-intlayer/markdown';
-*
-* function MyComponent() {
-*   const renderMarkdown = useMarkdownRenderer({
-*     components: {
-*       h1: ({ children }) => <h1 className="custom">{children}</h1>,
-*     },
-*   });
-*
-*   return (
-*     <div>
-*       {renderMarkdown('# Hello\n\nThis is **markdown**')}
-*     </div>
-*   );
-* }
-* ```
-*
-* @example
-* ```tsx
-* // With MarkdownProvider context
-* function App() {
-*   return (
-*     <MarkdownProvider
-*       components={{ h1: CustomHeading }}
-*       forceBlock={true}
-*     >
-*       <MyComponent />
-*     </MarkdownProvider>
-*   );
-* }
-* ```
-*/
-const useMarkdownRenderer = ({ components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter } = {}) => {
-	const context = useMarkdownContext();
-	return (content) => {
-		if (context) return context.renderMarkdown(content, {
-			forceBlock,
-			forceInline,
-			preserveFrontmatter,
-			tagfilter
-		}, components, wrapper);
-		return renderMarkdown(content, {
-			components,
-			wrapper,
-			forceBlock,
-			forceInline,
-			preserveFrontmatter,
-			tagfilter
-		});
-	};
-};
-/**
-* React component that renders markdown content to JSX.
-*
-* This component uses the `renderMarkdown` function from the `MarkdownProvider` context
-* if available. Otherwise, it falls back to the default compiler with provided components
-* and options. You can also provide a custom `renderMarkdown` function prop to override
-* all rendering behavior.
-*
-* @example
-* ```tsx
-* import { MarkdownRenderer } from '@intlayer/react-intlayer/markdown';
-*
-* function MyComponent() {
-*   return (
-*     <MarkdownRenderer>
-*       {`# Hello World
-*
-* This is a paragraph with **bold** and *italic* text.
-*
-* - List item 1
-* - List item 2`}
-*     </MarkdownRenderer>
-*   );
-* }
-* ```
-*
-* @example
-* ```tsx
-* // With custom components
-* <MarkdownRenderer
-*   components={{
-*     h1: ({ children }) => <h1 className="text-4xl font-bold">{children}</h1>,
-*     a: ({ href, children }) => (
-*       <a href={href} className="text-blue-500 hover:underline">
-*         {children}
-*       </a>
-*     ),
-*   }}
-*   forceBlock={true}
-* >
-*   {markdownContent}
-* </MarkdownRenderer>
-* ```
-*
-* @example
-* ```tsx
-* // With MarkdownProvider context
-* function App() {
-*   return (
-*     <MarkdownProvider
-*       components={{ h1: CustomHeading }}
-*       forceBlock={true}
-*     >
-*       <MarkdownRenderer>
-*         {markdownContent}
-*       </MarkdownRenderer>
-*     </MarkdownProvider>
-*   );
-* }
-* ```
-*/
-const MarkdownRenderer = ({ children = "", components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter, renderMarkdown }) => {
-	const context = useMarkdownContext();
-	if (renderMarkdown) return /* @__PURE__ */ jsx(Fragment, { children: renderMarkdown(children, {
-		components,
-		wrapper,
-		forceBlock,
-		forceInline,
-		preserveFrontmatter,
-		tagfilter
-	}) });
-	if (context) return /* @__PURE__ */ jsx(Fragment, { children: context.renderMarkdown(children, {
-		forceBlock,
-		forceInline,
-		preserveFrontmatter,
-		tagfilter
-	}, components, wrapper) });
-	return /* @__PURE__ */ jsx(Fragment, { children: compiler(children, {
-		components,
-		forceBlock,
-		forceInline,
-		wrapper,
-		forceWrapper: !!wrapper,
-		preserveFrontmatter,
-		tagfilter
-	}) });
-};
-
-//#endregion
-export { MarkdownRenderer, renderMarkdown, useMarkdownRenderer };
+import{compiler as e}from"./processor.mjs";import{useMarkdownContext as t}from"./MarkdownProvider.mjs";import{Fragment as n,jsx as r}from"react/jsx-runtime";const i=(t,{components:n,wrapper:r,forceBlock:i,forceInline:a,preserveFrontmatter:o,tagfilter:s}={})=>e(t,{components:n,forceBlock:i,forceInline:a,wrapper:r,forceWrapper:!!r,preserveFrontmatter:o,tagfilter:s}),a=({components:e,wrapper:n,forceBlock:r,forceInline:a,preserveFrontmatter:o,tagfilter:s}={})=>{let c=t();return t=>c?c.renderMarkdown(t,{forceBlock:r,forceInline:a,preserveFrontmatter:o,tagfilter:s},e,n):i(t,{components:e,wrapper:n,forceBlock:r,forceInline:a,preserveFrontmatter:o,tagfilter:s})},o=({children:i=``,components:a,wrapper:o,forceBlock:s,forceInline:c,preserveFrontmatter:l,tagfilter:u,renderMarkdown:d})=>{let f=t();return d?r(n,{children:d(i,{components:a,wrapper:o,forceBlock:s,forceInline:c,preserveFrontmatter:l,tagfilter:u})}):f?r(n,{children:f.renderMarkdown(i,{forceBlock:s,forceInline:c,preserveFrontmatter:l,tagfilter:u},a,o)}):r(n,{children:e(i,{components:a,forceBlock:s,forceInline:c,wrapper:o,forceWrapper:!!o,preserveFrontmatter:l,tagfilter:u})})};export{o as MarkdownRenderer,i as renderMarkdown,a as useMarkdownRenderer};
 //# sourceMappingURL=MarkdownRenderer.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"MarkdownRenderer.mjs","names":[],"sources":["../../../src/markdown/MarkdownRenderer.tsx"],"sourcesContent":["import type { FC, HTMLAttributes, JSX, ReactNode } from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\nimport {\n  type MarkdownProviderOptions,\n  useMarkdownContext,\n} from './MarkdownProvider';\nimport { compiler, type MarkdownRendererOptions } from './processor';\n\n/**\n * Props for rendering markdown content.\n *\n * @example\n * ```tsx\n * const props: RenderMarkdownProps = {\n *   components: {\n *     h1: ({ children }) => <h1 className=\"text-3xl\">{children}</h1>,\n *     p: ({ children }) => <p className=\"text-gray-700\">{children}</p>,\n *   },\n *   wrapper: ({ children }) => <article>{children}</article>,\n *   options: {\n *     forceBlock: true,\n *     preserveFrontmatter: false,\n *     tagfilter: true,\n *   },\n * };\n * ```\n */\nexport type RenderMarkdownProps = MarkdownProviderOptions & {\n  /**\n   * Component overrides for HTML tags.\n   * Allows you to customize how specific HTML elements are rendered.\n   * Only used if not wrapped in a MarkdownProvider.\n   *\n   * @example\n   * ```tsx\n   * components={{\n   *   h1: ({ children }) => <h1 className=\"title\">{children}</h1>,\n   *   a: ({ href, children }) => <Link to={href}>{children}</Link>,\n   * }}\n   * ```\n   */\n  components?: HTMLComponents<'permissive', {}>;\n  /**\n   * Wrapper element or component to be used when there are multiple children.\n   * Only used if not wrapped in a MarkdownProvider.\n   *\n   * @example\n   * ```tsx\n   * wrapper={({ children }) => <div className=\"markdown-content\">{children}</div>}\n   * ```\n   */\n  wrapper?: FC<HTMLAttributes<HTMLElement>>;\n};\n\n/**\n * Renders markdown content to JSX with the provided components and options.\n *\n * This function does not use context from MarkdownProvider. Use `useMarkdownRenderer`\n * hook if you want to leverage provider context.\n *\n * @param content - The markdown string to render\n * @param props - Configuration options for rendering\n * @param props.components - Component overrides for HTML tags\n * @param props.wrapper - Wrapper component for multiple children\n * @returns JSX element representing the rendered markdown\n *\n * @example\n * ```tsx\n * import { renderMarkdown } from '@intlayer/react-intlayer/markdown';\n *\n * const markdown = '# Hello World\\n\\nThis is **bold** text.';\n * const jsx = renderMarkdown(markdown, {\n *   components: {\n *     h1: ({ children }) => <h1 className=\"title\">{children}</h1>,\n *   },\n *   forceBlock: true,\n * });\n * ```\n */\nexport const renderMarkdown = (\n  content: string,\n  {\n    components,\n    wrapper,\n    forceBlock,\n    forceInline,\n    preserveFrontmatter,\n    tagfilter,\n  }: RenderMarkdownProps = {}\n): JSX.Element => {\n  // Map public options to internal processor options\n  const internalOptions: MarkdownRendererOptions = {\n    components,\n    forceBlock,\n    forceInline,\n    wrapper,\n    forceWrapper: !!wrapper,\n    preserveFrontmatter,\n    tagfilter,\n  };\n\n  return compiler(content, internalOptions);\n};\n\n/**\n * Hook that returns a function to render markdown content.\n *\n * This hook considers the configuration from the `MarkdownProvider` context if available,\n * falling back to the provided props or default behavior.\n *\n * @param props - Optional configuration that will override context values\n * @param props.components - Component overrides for HTML tags (overrides context)\n * @param props.wrapper - Wrapper component (overrides context)\n * @returns A function that takes markdown content and returns JSX\n *\n * @example\n * ```tsx\n * import { useMarkdownRenderer } from '@intlayer/react-intlayer/markdown';\n *\n * function MyComponent() {\n *   const renderMarkdown = useMarkdownRenderer({\n *     components: {\n *       h1: ({ children }) => <h1 className=\"custom\">{children}</h1>,\n *     },\n *   });\n *\n *   return (\n *     <div>\n *       {renderMarkdown('# Hello\\n\\nThis is **markdown**')}\n *     </div>\n *   );\n * }\n * ```\n *\n * @example\n * ```tsx\n * // With MarkdownProvider context\n * function App() {\n *   return (\n *     <MarkdownProvider\n *       components={{ h1: CustomHeading }}\n *       forceBlock={true}\n *     >\n *       <MyComponent />\n *     </MarkdownProvider>\n *   );\n * }\n * ```\n */\nexport const useMarkdownRenderer = ({\n  components,\n  wrapper,\n  forceBlock,\n  forceInline,\n  preserveFrontmatter,\n  tagfilter,\n}: RenderMarkdownProps = {}) => {\n  const context = useMarkdownContext();\n\n  return (content: string) => {\n    if (context) {\n      return context.renderMarkdown(\n        content,\n        {\n          forceBlock,\n          forceInline,\n          preserveFrontmatter,\n          tagfilter,\n        },\n        components,\n        wrapper\n      );\n    }\n\n    return renderMarkdown(content, {\n      components,\n      wrapper,\n      forceBlock,\n      forceInline,\n      preserveFrontmatter,\n      tagfilter,\n    });\n  };\n};\n\n/**\n * Props for the MarkdownRenderer component.\n *\n * @example\n * ```tsx\n * const props: MarkdownRendererProps = {\n *   children: '# Hello World\\n\\nThis is **bold** text.',\n *   components: {\n *     h1: ({ children }) => <h1 className=\"title\">{children}</h1>,\n *   },\n *   wrapper: ({ children }) => <article>{children}</article>,\n *   forceBlock: true,\n * };\n * ```\n */\nexport type MarkdownRendererProps = RenderMarkdownProps & {\n  /**\n   * The markdown content to render as a string.\n   *\n   * @example\n   * ```tsx\n   * <MarkdownRenderer>\n   *   {`# Title\\n\\nParagraph with **bold** text.`}\n   * </MarkdownRenderer>\n   * ```\n   */\n  children: string;\n  /**\n   * Custom render function for markdown.\n   * If provided, it will overwrite context and default rendering.\n   *\n   * @param markdown - The markdown string to render\n   * @param options - Optional rendering options\n   * @returns React node representing the rendered markdown\n   *\n   * @example\n   * ```tsx\n   * <MarkdownRenderer\n   *   renderMarkdown={(md, opts) => {\n   *     // Custom rendering logic\n   *     return <div dangerouslySetInnerHTML={{ __html: customParser(md) }} />;\n   *   }}\n   * >\n   *   {markdownContent}\n   * </MarkdownRenderer>\n   * ```\n   */\n  renderMarkdown?: (\n    markdown: string,\n    options?: {\n      components?: HTMLComponents<'permissive', {}>;\n      wrapper?: FC;\n      forceBlock?: boolean;\n      forceInline?: boolean;\n      preserveFrontmatter?: boolean;\n      tagfilter?: boolean;\n    }\n  ) => ReactNode;\n};\n\n/**\n * React component that renders markdown content to JSX.\n *\n * This component uses the `renderMarkdown` function from the `MarkdownProvider` context\n * if available. Otherwise, it falls back to the default compiler with provided components\n * and options. You can also provide a custom `renderMarkdown` function prop to override\n * all rendering behavior.\n *\n * @example\n * ```tsx\n * import { MarkdownRenderer } from '@intlayer/react-intlayer/markdown';\n *\n * function MyComponent() {\n *   return (\n *     <MarkdownRenderer>\n *       {`# Hello World\n *\n * This is a paragraph with **bold** and *italic* text.\n *\n * - List item 1\n * - List item 2`}\n *     </MarkdownRenderer>\n *   );\n * }\n * ```\n *\n * @example\n * ```tsx\n * // With custom components\n * <MarkdownRenderer\n *   components={{\n *     h1: ({ children }) => <h1 className=\"text-4xl font-bold\">{children}</h1>,\n *     a: ({ href, children }) => (\n *       <a href={href} className=\"text-blue-500 hover:underline\">\n *         {children}\n *       </a>\n *     ),\n *   }}\n *   forceBlock={true}\n * >\n *   {markdownContent}\n * </MarkdownRenderer>\n * ```\n *\n * @example\n * ```tsx\n * // With MarkdownProvider context\n * function App() {\n *   return (\n *     <MarkdownProvider\n *       components={{ h1: CustomHeading }}\n *       forceBlock={true}\n *     >\n *       <MarkdownRenderer>\n *         {markdownContent}\n *       </MarkdownRenderer>\n *     </MarkdownProvider>\n *   );\n * }\n * ```\n */\nexport const MarkdownRenderer: FC<MarkdownRendererProps> = ({\n  children = '',\n  components,\n  wrapper,\n  forceBlock,\n  forceInline,\n  preserveFrontmatter,\n  tagfilter,\n  renderMarkdown,\n}) => {\n  const context = useMarkdownContext();\n\n  if (renderMarkdown) {\n    return (\n      <>\n        {renderMarkdown(children, {\n          components,\n          wrapper,\n          forceBlock,\n          forceInline,\n          preserveFrontmatter,\n          tagfilter,\n        })}\n      </>\n    );\n  }\n\n  if (context) {\n    return (\n      <>\n        {context.renderMarkdown(\n          children,\n          {\n            forceBlock,\n            forceInline,\n            preserveFrontmatter,\n            tagfilter,\n          },\n          components,\n          wrapper\n        )}\n      </>\n    );\n  }\n\n  // Map public options to internal processor options\n  const internalOptions: MarkdownRendererOptions = {\n    components,\n    forceBlock,\n    forceInline,\n    wrapper,\n    forceWrapper: !!wrapper,\n    preserveFrontmatter,\n    tagfilter,\n  };\n\n  return <>{compiler(children, internalOptions)}</>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+EA,MAAa,kBACX,SACA,EACE,YACA,SACA,YACA,aACA,qBACA,cACuB,EAAE,KACX;AAYhB,QAAO,SAAS,SAViC;EAC/C;EACA;EACA;EACA;EACA,cAAc,CAAC,CAAC;EAChB;EACA;EACD,CAEwC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgD3C,MAAa,uBAAuB,EAClC,YACA,SACA,YACA,aACA,qBACA,cACuB,EAAE,KAAK;CAC9B,MAAM,UAAU,oBAAoB;AAEpC,SAAQ,YAAoB;AAC1B,MAAI,QACF,QAAO,QAAQ,eACb,SACA;GACE;GACA;GACA;GACA;GACD,EACD,YACA,QACD;AAGH,SAAO,eAAe,SAAS;GAC7B;GACA;GACA;GACA;GACA;GACA;GACD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6HN,MAAa,oBAA+C,EAC1D,WAAW,IACX,YACA,SACA,YACA,aACA,qBACA,WACA,qBACI;CACJ,MAAM,UAAU,oBAAoB;AAEpC,KAAI,eACF,QACE,0CACG,eAAe,UAAU;EACxB;EACA;EACA;EACA;EACA;EACA;EACD,CAAC,GACD;AAIP,KAAI,QACF,QACE,0CACG,QAAQ,eACP,UACA;EACE;EACA;EACA;EACA;EACD,EACD,YACA,QACD,GACA;AAeP,QAAO,0CAAG,SAAS,UAV8B;EAC/C;EACA;EACA;EACA;EACA,cAAc,CAAC,CAAC;EAChB;EACA;EACD,CAE4C,GAAI"}
+{"version":3,"file":"MarkdownRenderer.mjs","names":[],"sources":["../../../src/markdown/MarkdownRenderer.tsx"],"sourcesContent":["import type { FC, HTMLAttributes, JSX, ReactNode } from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\nimport {\n  type MarkdownProviderOptions,\n  useMarkdownContext,\n} from './MarkdownProvider';\nimport { compiler, type MarkdownRendererOptions } from './processor';\n\n/**\n * Props for rendering markdown content.\n *\n * @example\n * ```tsx\n * const props: RenderMarkdownProps = {\n *   components: {\n *     h1: ({ children }) => <h1 className=\"text-3xl\">{children}</h1>,\n *     p: ({ children }) => <p className=\"text-gray-700\">{children}</p>,\n *   },\n *   wrapper: ({ children }) => <article>{children}</article>,\n *   options: {\n *     forceBlock: true,\n *     preserveFrontmatter: false,\n *     tagfilter: true,\n *   },\n * };\n * ```\n */\nexport type RenderMarkdownProps = MarkdownProviderOptions & {\n  /**\n   * Component overrides for HTML tags.\n   * Allows you to customize how specific HTML elements are rendered.\n   * Only used if not wrapped in a MarkdownProvider.\n   *\n   * @example\n   * ```tsx\n   * components={{\n   *   h1: ({ children }) => <h1 className=\"title\">{children}</h1>,\n   *   a: ({ href, children }) => <Link to={href}>{children}</Link>,\n   * }}\n   * ```\n   */\n  components?: HTMLComponents<'permissive', {}>;\n  /**\n   * Wrapper element or component to be used when there are multiple children.\n   * Only used if not wrapped in a MarkdownProvider.\n   *\n   * @example\n   * ```tsx\n   * wrapper={({ children }) => <div className=\"markdown-content\">{children}</div>}\n   * ```\n   */\n  wrapper?: FC<HTMLAttributes<HTMLElement>>;\n};\n\n/**\n * Renders markdown content to JSX with the provided components and options.\n *\n * This function does not use context from MarkdownProvider. Use `useMarkdownRenderer`\n * hook if you want to leverage provider context.\n *\n * @param content - The markdown string to render\n * @param props - Configuration options for rendering\n * @param props.components - Component overrides for HTML tags\n * @param props.wrapper - Wrapper component for multiple children\n * @returns JSX element representing the rendered markdown\n *\n * @example\n * ```tsx\n * import { renderMarkdown } from '@intlayer/react-intlayer/markdown';\n *\n * const markdown = '# Hello World\\n\\nThis is **bold** text.';\n * const jsx = renderMarkdown(markdown, {\n *   components: {\n *     h1: ({ children }) => <h1 className=\"title\">{children}</h1>,\n *   },\n *   forceBlock: true,\n * });\n * ```\n */\nexport const renderMarkdown = (\n  content: string,\n  {\n    components,\n    wrapper,\n    forceBlock,\n    forceInline,\n    preserveFrontmatter,\n    tagfilter,\n  }: RenderMarkdownProps = {}\n): JSX.Element => {\n  // Map public options to internal processor options\n  const internalOptions: MarkdownRendererOptions = {\n    components,\n    forceBlock,\n    forceInline,\n    wrapper,\n    forceWrapper: !!wrapper,\n    preserveFrontmatter,\n    tagfilter,\n  };\n\n  return compiler(content, internalOptions);\n};\n\n/**\n * Hook that returns a function to render markdown content.\n *\n * This hook considers the configuration from the `MarkdownProvider` context if available,\n * falling back to the provided props or default behavior.\n *\n * @param props - Optional configuration that will override context values\n * @param props.components - Component overrides for HTML tags (overrides context)\n * @param props.wrapper - Wrapper component (overrides context)\n * @returns A function that takes markdown content and returns JSX\n *\n * @example\n * ```tsx\n * import { useMarkdownRenderer } from '@intlayer/react-intlayer/markdown';\n *\n * function MyComponent() {\n *   const renderMarkdown = useMarkdownRenderer({\n *     components: {\n *       h1: ({ children }) => <h1 className=\"custom\">{children}</h1>,\n *     },\n *   });\n *\n *   return (\n *     <div>\n *       {renderMarkdown('# Hello\\n\\nThis is **markdown**')}\n *     </div>\n *   );\n * }\n * ```\n *\n * @example\n * ```tsx\n * // With MarkdownProvider context\n * function App() {\n *   return (\n *     <MarkdownProvider\n *       components={{ h1: CustomHeading }}\n *       forceBlock={true}\n *     >\n *       <MyComponent />\n *     </MarkdownProvider>\n *   );\n * }\n * ```\n */\nexport const useMarkdownRenderer = ({\n  components,\n  wrapper,\n  forceBlock,\n  forceInline,\n  preserveFrontmatter,\n  tagfilter,\n}: RenderMarkdownProps = {}) => {\n  const context = useMarkdownContext();\n\n  return (content: string) => {\n    if (context) {\n      return context.renderMarkdown(\n        content,\n        {\n          forceBlock,\n          forceInline,\n          preserveFrontmatter,\n          tagfilter,\n        },\n        components,\n        wrapper\n      );\n    }\n\n    return renderMarkdown(content, {\n      components,\n      wrapper,\n      forceBlock,\n      forceInline,\n      preserveFrontmatter,\n      tagfilter,\n    });\n  };\n};\n\n/**\n * Props for the MarkdownRenderer component.\n *\n * @example\n * ```tsx\n * const props: MarkdownRendererProps = {\n *   children: '# Hello World\\n\\nThis is **bold** text.',\n *   components: {\n *     h1: ({ children }) => <h1 className=\"title\">{children}</h1>,\n *   },\n *   wrapper: ({ children }) => <article>{children}</article>,\n *   forceBlock: true,\n * };\n * ```\n */\nexport type MarkdownRendererProps = RenderMarkdownProps & {\n  /**\n   * The markdown content to render as a string.\n   *\n   * @example\n   * ```tsx\n   * <MarkdownRenderer>\n   *   {`# Title\\n\\nParagraph with **bold** text.`}\n   * </MarkdownRenderer>\n   * ```\n   */\n  children: string;\n  /**\n   * Custom render function for markdown.\n   * If provided, it will overwrite context and default rendering.\n   *\n   * @param markdown - The markdown string to render\n   * @param options - Optional rendering options\n   * @returns React node representing the rendered markdown\n   *\n   * @example\n   * ```tsx\n   * <MarkdownRenderer\n   *   renderMarkdown={(md, opts) => {\n   *     // Custom rendering logic\n   *     return <div dangerouslySetInnerHTML={{ __html: customParser(md) }} />;\n   *   }}\n   * >\n   *   {markdownContent}\n   * </MarkdownRenderer>\n   * ```\n   */\n  renderMarkdown?: (\n    markdown: string,\n    options?: {\n      components?: HTMLComponents<'permissive', {}>;\n      wrapper?: FC;\n      forceBlock?: boolean;\n      forceInline?: boolean;\n      preserveFrontmatter?: boolean;\n      tagfilter?: boolean;\n    }\n  ) => ReactNode;\n};\n\n/**\n * React component that renders markdown content to JSX.\n *\n * This component uses the `renderMarkdown` function from the `MarkdownProvider` context\n * if available. Otherwise, it falls back to the default compiler with provided components\n * and options. You can also provide a custom `renderMarkdown` function prop to override\n * all rendering behavior.\n *\n * @example\n * ```tsx\n * import { MarkdownRenderer } from '@intlayer/react-intlayer/markdown';\n *\n * function MyComponent() {\n *   return (\n *     <MarkdownRenderer>\n *       {`# Hello World\n *\n * This is a paragraph with **bold** and *italic* text.\n *\n * - List item 1\n * - List item 2`}\n *     </MarkdownRenderer>\n *   );\n * }\n * ```\n *\n * @example\n * ```tsx\n * // With custom components\n * <MarkdownRenderer\n *   components={{\n *     h1: ({ children }) => <h1 className=\"text-4xl font-bold\">{children}</h1>,\n *     a: ({ href, children }) => (\n *       <a href={href} className=\"text-blue-500 hover:underline\">\n *         {children}\n *       </a>\n *     ),\n *   }}\n *   forceBlock={true}\n * >\n *   {markdownContent}\n * </MarkdownRenderer>\n * ```\n *\n * @example\n * ```tsx\n * // With MarkdownProvider context\n * function App() {\n *   return (\n *     <MarkdownProvider\n *       components={{ h1: CustomHeading }}\n *       forceBlock={true}\n *     >\n *       <MarkdownRenderer>\n *         {markdownContent}\n *       </MarkdownRenderer>\n *     </MarkdownProvider>\n *   );\n * }\n * ```\n */\nexport const MarkdownRenderer: FC<MarkdownRendererProps> = ({\n  children = '',\n  components,\n  wrapper,\n  forceBlock,\n  forceInline,\n  preserveFrontmatter,\n  tagfilter,\n  renderMarkdown,\n}) => {\n  const context = useMarkdownContext();\n\n  if (renderMarkdown) {\n    return (\n      <>\n        {renderMarkdown(children, {\n          components,\n          wrapper,\n          forceBlock,\n          forceInline,\n          preserveFrontmatter,\n          tagfilter,\n        })}\n      </>\n    );\n  }\n\n  if (context) {\n    return (\n      <>\n        {context.renderMarkdown(\n          children,\n          {\n            forceBlock,\n            forceInline,\n            preserveFrontmatter,\n            tagfilter,\n          },\n          components,\n          wrapper\n        )}\n      </>\n    );\n  }\n\n  // Map public options to internal processor options\n  const internalOptions: MarkdownRendererOptions = {\n    components,\n    forceBlock,\n    forceInline,\n    wrapper,\n    forceWrapper: !!wrapper,\n    preserveFrontmatter,\n    tagfilter,\n  };\n\n  return <>{compiler(children, internalOptions)}</>;\n};\n"],"mappings":"6JA+EA,MAAa,GACX,EACA,CACE,aACA,UACA,aACA,cACA,sBACA,aACuB,EAAE,GAapB,EAAS,EAViC,CAC/C,aACA,aACA,cACA,UACA,aAAc,CAAC,CAAC,EAChB,sBACA,YACD,CAEwC,CAgD9B,GAAuB,CAClC,aACA,UACA,aACA,cACA,sBACA,aACuB,EAAE,GAAK,CAC9B,IAAM,EAAU,GAAoB,CAEpC,MAAQ,IACF,EACK,EAAQ,eACb,EACA,CACE,aACA,cACA,sBACA,YACD,CACD,EACA,EACD,CAGI,EAAe,EAAS,CAC7B,aACA,UACA,aACA,cACA,sBACA,YACD,CAAC,EA6HO,GAA+C,CAC1D,WAAW,GACX,aACA,UACA,aACA,cACA,sBACA,YACA,oBACI,CACJ,IAAM,EAAU,GAAoB,CA8CpC,OA5CI,EAEA,EAAA,EAAA,CAAA,SACG,EAAe,EAAU,CACxB,aACA,UACA,aACA,cACA,sBACA,YACD,CAAC,CAAA,CACD,CAIH,EAEA,EAAA,EAAA,CAAA,SACG,EAAQ,eACP,EACA,CACE,aACA,cACA,sBACA,YACD,CACD,EACA,EACD,CAAA,CACA,CAeA,EAAA,EAAA,CAAA,SAAG,EAAS,EAV8B,CAC/C,aACA,aACA,cACA,UACA,aAAc,CAAC,CAAC,EAChB,sBACA,YACD,CAE4C,CAAA,CAAI"}

package/dist/esm/markdown/MarkdownRendererPlugin.mjs

@@ -1,31 +1,2 @@
-'use client';
-
-import { useEditedContentRenderer } from "../editor/useEditedContentRenderer.mjs";
-import { useMarkdownContext } from "./MarkdownProvider.mjs";
-import { getContentNodeByKeyPath, getMarkdownMetadata } from "@intlayer/core";
-import { useEditorLocale } from "@intlayer/editor-react";
-
-//#region src/markdown/MarkdownRendererPlugin.tsx
-const MarkdownRendererPlugin = (props) => {
-	const { dictionaryKey, keyPath, children, locale, ...components } = props;
-	const renderMarkdown = useMarkdownContext()?.renderMarkdown ?? ((md) => md);
-	const editedContentContext = useEditedContentRenderer({
-		dictionaryKey,
-		keyPath,
-		children
-	});
-	return renderMarkdown(typeof editedContentContext === "string" ? editedContentContext : children, components);
-};
-const MarkdownMetadataRenderer = ({ dictionaryKey, keyPath, children, metadataKeyPath }) => {
-	const editedContentContext = useEditedContentRenderer({
-		dictionaryKey,
-		keyPath,
-		children
-	});
-	const currentLocale = useEditorLocale();
-	return getContentNodeByKeyPath(getMarkdownMetadata(editedContentContext), metadataKeyPath, currentLocale);
-};
-
-//#endregion
-export { MarkdownMetadataRenderer, MarkdownRendererPlugin };
+"use client";import{useEditedContentRenderer as e}from"../editor/useEditedContentRenderer.mjs";import{useMarkdownContext as t}from"./MarkdownProvider.mjs";import{getMarkdownMetadata as n}from"@intlayer/core/markdown";import{useEditorLocale as r}from"@intlayer/editor-react";import{getContentNodeByKeyPath as i}from"@intlayer/core/dictionaryManipulator";const a=n=>{let{dictionaryKey:r,keyPath:i,children:a,locale:o,...s}=n,c=t()?.renderMarkdown??(e=>e),l=e({dictionaryKey:r,keyPath:i,children:a});return c(typeof l==`string`?l:a,s)},o=({dictionaryKey:t,keyPath:a,children:o,metadataKeyPath:s})=>{let c=e({dictionaryKey:t,keyPath:a,children:o}),l=r();return i(n(c),s,l)};export{o as MarkdownMetadataRenderer,a as MarkdownRendererPlugin};
 //# sourceMappingURL=MarkdownRendererPlugin.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"MarkdownRendererPlugin.mjs","names":[],"sources":["../../../src/markdown/MarkdownRendererPlugin.tsx"],"sourcesContent":["'use client';\n\nimport { getContentNodeByKeyPath, getMarkdownMetadata } from '@intlayer/core';\nimport { useEditorLocale } from '@intlayer/editor-react';\nimport type { ContentNode, KeyPath, LocalesValues } from '@intlayer/types';\nimport type { FC, ReactNode } from 'react';\nimport { useEditedContentRenderer } from '../editor/useEditedContentRenderer';\nimport { useMarkdownContext } from './MarkdownProvider';\n\ntype MarkdownRendererPluginProps = {\n  dictionaryKey: string;\n  keyPath: KeyPath[];\n  locale?: LocalesValues;\n  children: string;\n  [key: string]: any;\n};\n\nexport const MarkdownRendererPlugin: FC<MarkdownRendererPluginProps> = (\n  props\n): ReactNode => {\n  const { dictionaryKey, keyPath, children, locale, ...components } = props;\n  const context = useMarkdownContext();\n  const renderMarkdown = context?.renderMarkdown ?? ((md) => md);\n  const editedContentContext = useEditedContentRenderer({\n    dictionaryKey,\n    keyPath,\n    children,\n  });\n\n  const contentToRender =\n    typeof editedContentContext === 'string' ? editedContentContext : children;\n\n  return renderMarkdown(contentToRender, components);\n};\n\ntype MarkdownMetadataRendererProps = MarkdownRendererPluginProps & {\n  metadataKeyPath: KeyPath[];\n};\n\nexport const MarkdownMetadataRenderer: FC<MarkdownMetadataRendererProps> = ({\n  dictionaryKey,\n  keyPath,\n  children,\n  metadataKeyPath,\n}): ReactNode => {\n  const editedContentContext = useEditedContentRenderer({\n    dictionaryKey,\n    keyPath,\n    children,\n  });\n  const currentLocale = useEditorLocale();\n\n  const metadata = getMarkdownMetadata(editedContentContext);\n\n  const metadataEl = getContentNodeByKeyPath(\n    metadata as ContentNode,\n    metadataKeyPath,\n    currentLocale\n  );\n\n  return metadataEl as ReactNode;\n};\n"],"mappings":";;;;;;;;AAiBA,MAAa,0BACX,UACc;CACd,MAAM,EAAE,eAAe,SAAS,UAAU,QAAQ,GAAG,eAAe;CAEpE,MAAM,iBADU,oBAAoB,EACJ,oBAAoB,OAAO;CAC3D,MAAM,uBAAuB,yBAAyB;EACpD;EACA;EACA;EACD,CAAC;AAKF,QAAO,eAFL,OAAO,yBAAyB,WAAW,uBAAuB,UAE7B,WAAW;;AAOpD,MAAa,4BAA+D,EAC1E,eACA,SACA,UACA,sBACe;CACf,MAAM,uBAAuB,yBAAyB;EACpD;EACA;EACA;EACD,CAAC;CACF,MAAM,gBAAgB,iBAAiB;AAUvC,QANmB,wBAFF,oBAAoB,qBAAqB,EAIxD,iBACA,cACD"}
+{"version":3,"file":"MarkdownRendererPlugin.mjs","names":[],"sources":["../../../src/markdown/MarkdownRendererPlugin.tsx"],"sourcesContent":["'use client';\n\nimport { getContentNodeByKeyPath } from '@intlayer/core/dictionaryManipulator';\nimport { getMarkdownMetadata } from '@intlayer/core/markdown';\nimport { useEditorLocale } from '@intlayer/editor-react';\nimport type { ContentNode, KeyPath, LocalesValues } from '@intlayer/types';\nimport type { FC, ReactNode } from 'react';\nimport { useEditedContentRenderer } from '../editor/useEditedContentRenderer';\nimport { useMarkdownContext } from './MarkdownProvider';\n\ntype MarkdownRendererPluginProps = {\n  dictionaryKey: string;\n  keyPath: KeyPath[];\n  locale?: LocalesValues;\n  children: string;\n  [key: string]: any;\n};\n\nexport const MarkdownRendererPlugin: FC<MarkdownRendererPluginProps> = (\n  props\n): ReactNode => {\n  const { dictionaryKey, keyPath, children, locale, ...components } = props;\n  const context = useMarkdownContext();\n  const renderMarkdown = context?.renderMarkdown ?? ((md) => md);\n  const editedContentContext = useEditedContentRenderer({\n    dictionaryKey,\n    keyPath,\n    children,\n  });\n\n  const contentToRender =\n    typeof editedContentContext === 'string' ? editedContentContext : children;\n\n  return renderMarkdown(contentToRender, components);\n};\n\ntype MarkdownMetadataRendererProps = MarkdownRendererPluginProps & {\n  metadataKeyPath: KeyPath[];\n};\n\nexport const MarkdownMetadataRenderer: FC<MarkdownMetadataRendererProps> = ({\n  dictionaryKey,\n  keyPath,\n  children,\n  metadataKeyPath,\n}): ReactNode => {\n  const editedContentContext = useEditedContentRenderer({\n    dictionaryKey,\n    keyPath,\n    children,\n  });\n  const currentLocale = useEditorLocale();\n\n  const metadata = getMarkdownMetadata(editedContentContext);\n\n  const metadataEl = getContentNodeByKeyPath(\n    metadata as ContentNode,\n    metadataKeyPath,\n    currentLocale\n  );\n\n  return metadataEl as ReactNode;\n};\n"],"mappings":"iWAkBA,MAAa,EACX,GACc,CACd,GAAM,CAAE,gBAAe,UAAS,WAAU,SAAQ,GAAG,GAAe,EAE9D,EADU,GAAoB,EACJ,iBAAoB,GAAO,GACrD,EAAuB,EAAyB,CACpD,gBACA,UACA,WACD,CAAC,CAKF,OAAO,EAFL,OAAO,GAAyB,SAAW,EAAuB,EAE7B,EAAW,EAOvC,GAA+D,CAC1E,gBACA,UACA,WACA,qBACe,CACf,IAAM,EAAuB,EAAyB,CACpD,gBACA,UACA,WACD,CAAC,CACI,EAAgB,GAAiB,CAUvC,OANmB,EAFF,EAAoB,EAAqB,CAIxD,EACA,EACD"}

package/dist/esm/markdown/index.mjs

@@ -1,7 +1 @@
-import { LegacyMarkdownRenderer, RuleType, compile, compileMarkdown, compiler, sanitizer as defaultSanitizer, slugify as defaultSlugify } from "./processor.mjs";
-import { MarkdownProvider, useMarkdownContext } from "./MarkdownProvider.mjs";
-import { MarkdownRenderer, renderMarkdown, useMarkdownRenderer } from "./MarkdownRenderer.mjs";
-import { MarkdownMetadataRenderer, MarkdownRendererPlugin } from "./MarkdownRendererPlugin.mjs";
-import reactRuntime, { createReactRuntime } from "./runtime.mjs";
-
-export { LegacyMarkdownRenderer, MarkdownMetadataRenderer, MarkdownProvider, MarkdownRenderer, MarkdownRendererPlugin, RuleType, compile, compileMarkdown, compiler, createReactRuntime, reactRuntime, renderMarkdown, defaultSanitizer as sanitizer, defaultSlugify as slugify, useMarkdownContext, useMarkdownRenderer };
+import{LegacyMarkdownRenderer as e,RuleType as t,compile as n,compileMarkdown as r,compiler as i,sanitizer as a,slugify as o}from"./processor.mjs";import{MarkdownProvider as s,useMarkdownContext as c}from"./MarkdownProvider.mjs";import{MarkdownRenderer as l,renderMarkdown as u,useMarkdownRenderer as d}from"./MarkdownRenderer.mjs";import{MarkdownMetadataRenderer as f,MarkdownRendererPlugin as p}from"./MarkdownRendererPlugin.mjs";import m,{createReactRuntime as h}from"./runtime.mjs";export{e as LegacyMarkdownRenderer,f as MarkdownMetadataRenderer,s as MarkdownProvider,l as MarkdownRenderer,p as MarkdownRendererPlugin,t as RuleType,n as compile,r as compileMarkdown,i as compiler,h as createReactRuntime,m as reactRuntime,u as renderMarkdown,a as sanitizer,o as slugify,c as useMarkdownContext,d as useMarkdownRenderer};

package/dist/esm/markdown/processor.mjs

@@ -1,59 +1,2 @@
-import { Fragment, cloneElement, createElement } from "react";
-import { RuleType, compile as compile$1, sanitizer as defaultSanitizer, slugify as defaultSlugify } from "@intlayer/core";
-
-//#region src/markdown/processor.tsx
-/**
-* it's a fork
-* [markdown-to-jsx v7.7.14](https://github.com/quantizor/markdown-to-jsx) from quantizor
-* [simple-markdown v0.2.2](https://github.com/Khan/simple-markdown) from Khan Academy.
-*/
-/**
-* Default React runtime for markdown rendering.
-*/
-const DEFAULT_RUNTIME = {
-	createElement,
-	cloneElement,
-	Fragment,
-	normalizeProps: (_tag, props) => props
-};
-/**
-* Compile markdown to React elements.
-* This is the primary export - use this for new code.
-*/
-const compileMarkdown = (markdown = "", options = {}) => {
-	const { createElement: customCreateElement, disableAutoLink, disableParsingRawHTML, enforceAtxHeadings, forceBlock, forceInline, forceWrapper, namedCodesToUnicode, components, renderRule, sanitizer, slugify, wrapper, preserveFrontmatter, tagfilter } = options;
-	return compile$1(markdown, {
-		runtime: customCreateElement ? {
-			...DEFAULT_RUNTIME,
-			createElement: customCreateElement
-		} : DEFAULT_RUNTIME,
-		components,
-		namedCodesToUnicode,
-		sanitizer,
-		slugify
-	}, {
-		disableAutoLink,
-		disableParsingRawHTML,
-		enforceAtxHeadings,
-		forceBlock,
-		forceInline,
-		forceWrapper,
-		renderRule,
-		wrapper,
-		preserveFrontmatter,
-		tagfilter
-	});
-};
-const compiler = compileMarkdown;
-const compile = compileMarkdown;
-/**
-* React component that renders markdown to JSX (legacy).
-*/
-const LegacyMarkdownRenderer = ({ children = "", options, ...props }) => {
-	if (process.env.NODE_ENV !== "production" && typeof children !== "string") console.error("intlayer: <Markdown> component only accepts a single string as a child, received:", children);
-	return cloneElement(compiler(children, options), props);
-};
-
-//#endregion
-export { LegacyMarkdownRenderer, RuleType, compile, compileMarkdown, compiler, defaultSanitizer as sanitizer, defaultSlugify as slugify };
+import{Fragment as e,cloneElement as t,createElement as n}from"react";import{RuleType as r,compile as i,sanitizer as a,slugify as o}from"@intlayer/core/markdown";const s={createElement:n,cloneElement:t,Fragment:e,normalizeProps:(e,t)=>t},c=(e=``,t={})=>{let{createElement:n,disableAutoLink:r,disableParsingRawHTML:a,enforceAtxHeadings:o,forceBlock:c,forceInline:l,forceWrapper:u,namedCodesToUnicode:d,components:f,renderRule:p,sanitizer:m,slugify:h,wrapper:g,preserveFrontmatter:_,tagfilter:v}=t;return i(e,{runtime:n?{...s,createElement:n}:s,components:f,namedCodesToUnicode:d,sanitizer:m,slugify:h},{disableAutoLink:r,disableParsingRawHTML:a,enforceAtxHeadings:o,forceBlock:c,forceInline:l,forceWrapper:u,renderRule:p,wrapper:g,preserveFrontmatter:_,tagfilter:v})},l=c,u=c,d=({children:e=``,options:n,...r})=>(process.env.NODE_ENV!==`production`&&typeof e!=`string`&&console.error(`intlayer: <Markdown> component only accepts a single string as a child, received:`,e),t(l(e,n),r));export{d as LegacyMarkdownRenderer,r as RuleType,u as compile,c as compileMarkdown,l as compiler,a as sanitizer,o as slugify};
 //# sourceMappingURL=processor.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"processor.mjs","names":["coreCompile"],"sources":["../../../src/markdown/processor.tsx"],"sourcesContent":["/**\n * it's a fork\n * [markdown-to-jsx v7.7.14](https://github.com/quantizor/markdown-to-jsx) from quantizor\n * [simple-markdown v0.2.2](https://github.com/Khan/simple-markdown) from Khan Academy.\n */\n\nimport {\n  compile as coreCompile,\n  sanitizer as defaultSanitizer,\n  slugify as defaultSlugify,\n  type MarkdownContext,\n  type MarkdownOptions,\n  type MarkdownRuntime,\n  type RenderRuleHook,\n  RuleType,\n} from '@intlayer/core';\nimport {\n  cloneElement,\n  createElement,\n  type FC,\n  Fragment,\n  type HTMLAttributes,\n  type JSX,\n  type ReactNode,\n} from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\n\n// Re-export RuleType for compatibility\nexport { RuleType };\n\n// Re-export utilities for compatibility\nexport { defaultSlugify as slugify, defaultSanitizer as sanitizer };\n\ntype HTMLTags = keyof JSX.IntrinsicElements;\n\n/**\n * Refined MarkdownRendererOptions type.\n */\nexport type MarkdownRendererOptions = Partial<{\n  /**\n   * Ultimate control over the output of all rendered JSX.\n   */\n  createElement: (\n    tag: Parameters<typeof createElement>[0],\n    props: JSX.IntrinsicAttributes,\n    ...children: ReactNode[]\n  ) => ReactNode;\n\n  /**\n   * The library automatically generates an anchor tag for bare URLs included in the markdown\n   * document, but this behavior can be disabled if desired.\n   */\n  disableAutoLink: boolean;\n\n  /**\n   * Disable the compiler's best-effort transcription of provided raw HTML\n   * into JSX-equivalent.\n   */\n  disableParsingRawHTML: boolean;\n\n  /**\n   * Forces the compiler to have space between hash sign and the header text.\n   */\n  enforceAtxHeadings: boolean;\n\n  /**\n   * Forces the compiler to always output content with a block-level wrapper.\n   */\n  forceBlock: boolean;\n\n  /**\n   * Forces the compiler to always output content with an inline wrapper.\n   */\n  forceInline: boolean;\n\n  /**\n   * Forces the compiler to wrap results, even if there is only a single child.\n   */\n  forceWrapper: boolean;\n\n  /**\n   * Supply additional HTML entity: unicode replacement mappings.\n   */\n  namedCodesToUnicode: {\n    [key: string]: string;\n  };\n\n  /**\n   * Selectively control the output of particular HTML tags.\n   */\n  components: HTMLComponents;\n\n  /**\n   * Allows for full control over rendering of particular rules.\n   */\n  renderRule: RenderRuleHook;\n\n  /**\n   * Override the built-in sanitizer function for URLs.\n   */\n  sanitizer: (value: string, tag: HTMLTags, attribute: string) => string | null;\n\n  /**\n   * Override normalization of non-URI-safe characters for anchor linking.\n   */\n  slugify: (input: string) => string;\n\n  /**\n   * Declare the type of the wrapper to be used when there are multiple children.\n   */\n  wrapper: any | null;\n\n  /**\n   * Whether to preserve frontmatter in the markdown content.\n   */\n  preserveFrontmatter: boolean;\n\n  /**\n   * Whether to use the GitHub Tag Filter.\n   */\n  tagfilter: boolean;\n}>;\n\n/**\n * Default React runtime for markdown rendering.\n */\nconst DEFAULT_RUNTIME: MarkdownRuntime = {\n  createElement: createElement as any,\n  cloneElement,\n  Fragment,\n  normalizeProps: (_tag, props) => props,\n};\n\n/**\n * Compile markdown to React elements.\n * This is the primary export - use this for new code.\n */\nexport const compileMarkdown = (\n  markdown: string = '',\n  options: MarkdownRendererOptions = {}\n): JSX.Element => {\n  const {\n    createElement: customCreateElement,\n    disableAutoLink,\n    disableParsingRawHTML,\n    enforceAtxHeadings,\n    forceBlock,\n    forceInline,\n    forceWrapper,\n    namedCodesToUnicode,\n    components,\n    renderRule,\n    sanitizer,\n    slugify,\n    wrapper,\n    preserveFrontmatter,\n    tagfilter,\n  } = options;\n\n  const runtime = customCreateElement\n    ? { ...DEFAULT_RUNTIME, createElement: customCreateElement as any }\n    : DEFAULT_RUNTIME;\n\n  const ctx: MarkdownContext<HTMLComponents> = {\n    runtime,\n    components,\n    namedCodesToUnicode,\n    sanitizer: sanitizer as any,\n    slugify,\n  };\n\n  const compilerOptions: MarkdownOptions = {\n    disableAutoLink,\n    disableParsingRawHTML,\n    enforceAtxHeadings,\n    forceBlock,\n    forceInline,\n    forceWrapper,\n    renderRule,\n    wrapper,\n    preserveFrontmatter,\n    tagfilter,\n  };\n\n  return coreCompile(markdown, ctx, compilerOptions) as JSX.Element;\n};\n\n// Backward compatibility aliases\nexport const compiler = compileMarkdown;\nexport const compile = compileMarkdown;\n\n/**\n * React component that renders markdown to JSX (legacy).\n */\nexport const LegacyMarkdownRenderer: FC<\n  Omit<HTMLAttributes<Element>, 'children'> & {\n    children: string;\n    options?: MarkdownRendererOptions;\n  }\n> = ({ children = '', options, ...props }) => {\n  if (process.env.NODE_ENV !== 'production' && typeof children !== 'string') {\n    console.error(\n      'intlayer: <Markdown> component only accepts a single string as a child, received:',\n      children\n    );\n  }\n\n  return cloneElement(\n    compiler(children, options),\n    props as JSX.IntrinsicAttributes\n  );\n};\n"],"mappings":";;;;;;;;;;;;AA8HA,MAAM,kBAAmC;CACxB;CACf;CACA;CACA,iBAAiB,MAAM,UAAU;CAClC;;;;;AAMD,MAAa,mBACX,WAAmB,IACnB,UAAmC,EAAE,KACrB;CAChB,MAAM,EACJ,eAAe,qBACf,iBACA,uBACA,oBACA,YACA,aACA,cACA,qBACA,YACA,YACA,WACA,SACA,SACA,qBACA,cACE;AA2BJ,QAAOA,UAAY,UArB0B;EAC3C,SALc,sBACZ;GAAE,GAAG;GAAiB,eAAe;GAA4B,GACjE;EAIF;EACA;EACW;EACX;EACD,EAEwC;EACvC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACD,CAEiD;;AAIpD,MAAa,WAAW;AACxB,MAAa,UAAU;;;;AAKvB,MAAa,0BAKR,EAAE,WAAW,IAAI,SAAS,GAAG,YAAY;AAC5C,KAAI,QAAQ,IAAI,aAAa,gBAAgB,OAAO,aAAa,SAC/D,SAAQ,MACN,qFACA,SACD;AAGH,QAAO,aACL,SAAS,UAAU,QAAQ,EAC3B,MACD"}
+{"version":3,"file":"processor.mjs","names":["coreCompile"],"sources":["../../../src/markdown/processor.tsx"],"sourcesContent":["/**\n * it's a fork\n * [markdown-to-jsx v7.7.14](https://github.com/quantizor/markdown-to-jsx) from quantizor\n * [simple-markdown v0.2.2](https://github.com/Khan/simple-markdown) from Khan Academy.\n */\n\nimport {\n  compile as coreCompile,\n  sanitizer as defaultSanitizer,\n  slugify as defaultSlugify,\n  type MarkdownContext,\n  type MarkdownOptions,\n  type MarkdownRuntime,\n  type RenderRuleHook,\n  RuleType,\n} from '@intlayer/core/markdown';\nimport {\n  cloneElement,\n  createElement,\n  type FC,\n  Fragment,\n  type HTMLAttributes,\n  type JSX,\n  type ReactNode,\n} from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\n\n// Re-export RuleType for compatibility\nexport { RuleType };\n\n// Re-export utilities for compatibility\nexport { defaultSlugify as slugify, defaultSanitizer as sanitizer };\n\ntype HTMLTags = keyof JSX.IntrinsicElements;\n\n/**\n * Refined MarkdownRendererOptions type.\n */\nexport type MarkdownRendererOptions = Partial<{\n  /**\n   * Ultimate control over the output of all rendered JSX.\n   */\n  createElement: (\n    tag: Parameters<typeof createElement>[0],\n    props: JSX.IntrinsicAttributes,\n    ...children: ReactNode[]\n  ) => ReactNode;\n\n  /**\n   * The library automatically generates an anchor tag for bare URLs included in the markdown\n   * document, but this behavior can be disabled if desired.\n   */\n  disableAutoLink: boolean;\n\n  /**\n   * Disable the compiler's best-effort transcription of provided raw HTML\n   * into JSX-equivalent.\n   */\n  disableParsingRawHTML: boolean;\n\n  /**\n   * Forces the compiler to have space between hash sign and the header text.\n   */\n  enforceAtxHeadings: boolean;\n\n  /**\n   * Forces the compiler to always output content with a block-level wrapper.\n   */\n  forceBlock: boolean;\n\n  /**\n   * Forces the compiler to always output content with an inline wrapper.\n   */\n  forceInline: boolean;\n\n  /**\n   * Forces the compiler to wrap results, even if there is only a single child.\n   */\n  forceWrapper: boolean;\n\n  /**\n   * Supply additional HTML entity: unicode replacement mappings.\n   */\n  namedCodesToUnicode: {\n    [key: string]: string;\n  };\n\n  /**\n   * Selectively control the output of particular HTML tags.\n   */\n  components: HTMLComponents;\n\n  /**\n   * Allows for full control over rendering of particular rules.\n   */\n  renderRule: RenderRuleHook;\n\n  /**\n   * Override the built-in sanitizer function for URLs.\n   */\n  sanitizer: (value: string, tag: HTMLTags, attribute: string) => string | null;\n\n  /**\n   * Override normalization of non-URI-safe characters for anchor linking.\n   */\n  slugify: (input: string) => string;\n\n  /**\n   * Declare the type of the wrapper to be used when there are multiple children.\n   */\n  wrapper: any | null;\n\n  /**\n   * Whether to preserve frontmatter in the markdown content.\n   */\n  preserveFrontmatter: boolean;\n\n  /**\n   * Whether to use the GitHub Tag Filter.\n   */\n  tagfilter: boolean;\n}>;\n\n/**\n * Default React runtime for markdown rendering.\n */\nconst DEFAULT_RUNTIME: MarkdownRuntime = {\n  createElement: createElement as any,\n  cloneElement,\n  Fragment,\n  normalizeProps: (_tag, props) => props,\n};\n\n/**\n * Compile markdown to React elements.\n * This is the primary export - use this for new code.\n */\nexport const compileMarkdown = (\n  markdown: string = '',\n  options: MarkdownRendererOptions = {}\n): JSX.Element => {\n  const {\n    createElement: customCreateElement,\n    disableAutoLink,\n    disableParsingRawHTML,\n    enforceAtxHeadings,\n    forceBlock,\n    forceInline,\n    forceWrapper,\n    namedCodesToUnicode,\n    components,\n    renderRule,\n    sanitizer,\n    slugify,\n    wrapper,\n    preserveFrontmatter,\n    tagfilter,\n  } = options;\n\n  const runtime = customCreateElement\n    ? { ...DEFAULT_RUNTIME, createElement: customCreateElement as any }\n    : DEFAULT_RUNTIME;\n\n  const ctx: MarkdownContext<HTMLComponents> = {\n    runtime,\n    components,\n    namedCodesToUnicode,\n    sanitizer: sanitizer as any,\n    slugify,\n  };\n\n  const compilerOptions: MarkdownOptions = {\n    disableAutoLink,\n    disableParsingRawHTML,\n    enforceAtxHeadings,\n    forceBlock,\n    forceInline,\n    forceWrapper,\n    renderRule,\n    wrapper,\n    preserveFrontmatter,\n    tagfilter,\n  };\n\n  return coreCompile(markdown, ctx, compilerOptions) as JSX.Element;\n};\n\n// Backward compatibility aliases\nexport const compiler = compileMarkdown;\nexport const compile = compileMarkdown;\n\n/**\n * React component that renders markdown to JSX (legacy).\n */\nexport const LegacyMarkdownRenderer: FC<\n  Omit<HTMLAttributes<Element>, 'children'> & {\n    children: string;\n    options?: MarkdownRendererOptions;\n  }\n> = ({ children = '', options, ...props }) => {\n  if (process.env.NODE_ENV !== 'production' && typeof children !== 'string') {\n    console.error(\n      'intlayer: <Markdown> component only accepts a single string as a child, received:',\n      children\n    );\n  }\n\n  return cloneElement(\n    compiler(children, options),\n    props as JSX.IntrinsicAttributes\n  );\n};\n"],"mappings":"kKA8HA,MAAM,EAAmC,CACxB,gBACf,eACA,WACA,gBAAiB,EAAM,IAAU,EAClC,CAMY,GACX,EAAmB,GACnB,EAAmC,EAAE,GACrB,CAChB,GAAM,CACJ,cAAe,EACf,kBACA,wBACA,qBACA,aACA,cACA,eACA,sBACA,aACA,aACA,YACA,UACA,UACA,sBACA,aACE,EA2BJ,OAAOA,EAAY,EArB0B,CAC3C,QALc,EACZ,CAAE,GAAG,EAAiB,cAAe,EAA4B,CACjE,EAIF,aACA,sBACW,YACX,UACD,CAEwC,CACvC,kBACA,wBACA,qBACA,aACA,cACA,eACA,aACA,UACA,sBACA,YACD,CAEiD,EAIvC,EAAW,EACX,EAAU,EAKV,GAKR,CAAE,WAAW,GAAI,UAAS,GAAG,MAC5B,QAAQ,IAAI,WAAa,cAAgB,OAAO,GAAa,UAC/D,QAAQ,MACN,oFACA,EACD,CAGI,EACL,EAAS,EAAU,EAAQ,CAC3B,EACD"}

package/dist/esm/markdown/runtime.mjs

@@ -1,40 +1,2 @@
-import { Fragment, cloneElement, createElement } from "react";
-
-//#region src/markdown/runtime.ts
-/**
-* React-specific runtime for the markdown processor.
-* Implements the MarkdownRuntime interface using React's primitives.
-*/
-const reactRuntime = {
-	createElement: (type, props, ...children) => {
-		if (children.length === 0) return createElement(type, props);
-		if (children.length === 1) return createElement(type, props, children[0]);
-		return createElement(type, props, ...children);
-	},
-	cloneElement: (element, props, ...children) => {
-		if (children.length === 0) return cloneElement(element, props);
-		return cloneElement(element, props, ...children);
-	},
-	Fragment,
-	normalizeProps: (_tag, props) => {
-		return props;
-	}
-};
-/**
-* Creates a React runtime with custom createElement for advanced use cases.
-* Useful for wrapping elements or adding middleware.
-*/
-const createReactRuntime = (options = {}) => {
-	const { onCreateElement } = options;
-	if (onCreateElement) return {
-		...reactRuntime,
-		createElement: (type, props, ...children) => {
-			return onCreateElement(type, props, children);
-		}
-	};
-	return reactRuntime;
-};
-
-//#endregion
-export { createReactRuntime, reactRuntime as default, reactRuntime };
+import{Fragment as e,cloneElement as t,createElement as n}from"react";const r={createElement:(e,t,...r)=>r.length===0?n(e,t):r.length===1?n(e,t,r[0]):n(e,t,...r),cloneElement:(e,n,...r)=>r.length===0?t(e,n):t(e,n,...r),Fragment:e,normalizeProps:(e,t)=>t},i=(e={})=>{let{onCreateElement:t}=e;return t?{...r,createElement:(e,n,...r)=>t(e,n,r)}:r};export{i as createReactRuntime,r as default,r as reactRuntime};
 //# sourceMappingURL=runtime.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"runtime.mjs","names":[],"sources":["../../../src/markdown/runtime.ts"],"sourcesContent":["import type { HTMLTag, MarkdownRuntime } from '@intlayer/core';\nimport {\n  cloneElement,\n  createElement,\n  Fragment,\n  type ReactElement,\n  type ReactNode,\n} from 'react';\n\n/**\n * React-specific runtime for the markdown processor.\n * Implements the MarkdownRuntime interface using React's primitives.\n */\nexport const reactRuntime: MarkdownRuntime = {\n  /**\n   * Creates a React element.\n   * Handles the conversion of props and children to React format.\n   */\n  createElement: (\n    type: string | any,\n    props: Record<string, any> | null,\n    ...children: any[]\n  ): ReactNode => {\n    // React accepts children as rest args or as a single array\n    // If there's only one child, pass it directly to avoid unnecessary array\n    if (children.length === 0) {\n      return createElement(type, props);\n    }\n    if (children.length === 1) {\n      return createElement(type, props, children[0]);\n    }\n    return createElement(type, props, ...children);\n  },\n\n  /**\n   * Clones a React element with new props.\n   */\n  cloneElement: (\n    element: unknown,\n    props: Record<string, any>,\n    ...children: any[]\n  ): ReactNode => {\n    if (children.length === 0) {\n      return cloneElement(element as ReactElement, props);\n    }\n    return cloneElement(element as ReactElement, props, ...children);\n  },\n\n  /**\n   * React Fragment component.\n   */\n  Fragment,\n\n  /**\n   * React-specific prop normalization.\n   * React uses className instead of class, htmlFor instead of for, etc.\n   * The core processor already handles ATTRIBUTE_TO_NODE_PROP_MAP,\n   * so this is mostly a no-op but can be used for additional React-specific transforms.\n   */\n  normalizeProps: (\n    _tag: HTMLTag,\n    props: Record<string, any>\n  ): Record<string, any> => {\n    // The core already handles class -> className and for -> htmlFor\n    // via ATTRIBUTE_TO_NODE_PROP_MAP in the attrStringToMap function.\n    // This hook is available for any additional React-specific transforms.\n    return props;\n  },\n};\n\n/**\n * Creates a React runtime with custom createElement for advanced use cases.\n * Useful for wrapping elements or adding middleware.\n */\nexport const createReactRuntime = (\n  options: {\n    onCreateElement?: (\n      type: string | any,\n      props: Record<string, any> | null,\n      children: any[]\n    ) => ReactNode;\n  } = {}\n): MarkdownRuntime => {\n  const { onCreateElement } = options;\n\n  if (onCreateElement) {\n    return {\n      ...reactRuntime,\n      createElement: (\n        type: string | any,\n        props: Record<string, any> | null,\n        ...children: any[]\n      ): ReactNode => {\n        return onCreateElement(type, props, children);\n      },\n    };\n  }\n\n  return reactRuntime;\n};\n\nexport default reactRuntime;\n"],"mappings":";;;;;;;AAaA,MAAa,eAAgC;CAK3C,gBACE,MACA,OACA,GAAG,aACW;AAGd,MAAI,SAAS,WAAW,EACtB,QAAO,cAAc,MAAM,MAAM;AAEnC,MAAI,SAAS,WAAW,EACtB,QAAO,cAAc,MAAM,OAAO,SAAS,GAAG;AAEhD,SAAO,cAAc,MAAM,OAAO,GAAG,SAAS;;CAMhD,eACE,SACA,OACA,GAAG,aACW;AACd,MAAI,SAAS,WAAW,EACtB,QAAO,aAAa,SAAyB,MAAM;AAErD,SAAO,aAAa,SAAyB,OAAO,GAAG,SAAS;;CAMlE;CAQA,iBACE,MACA,UACwB;AAIxB,SAAO;;CAEV;;;;;AAMD,MAAa,sBACX,UAMI,EAAE,KACc;CACpB,MAAM,EAAE,oBAAoB;AAE5B,KAAI,gBACF,QAAO;EACL,GAAG;EACH,gBACE,MACA,OACA,GAAG,aACW;AACd,UAAO,gBAAgB,MAAM,OAAO,SAAS;;EAEhD;AAGH,QAAO"}
+{"version":3,"file":"runtime.mjs","names":[],"sources":["../../../src/markdown/runtime.ts"],"sourcesContent":["import type { HTMLTag, MarkdownRuntime } from '@intlayer/core/markdown';\nimport {\n  cloneElement,\n  createElement,\n  Fragment,\n  type ReactElement,\n  type ReactNode,\n} from 'react';\n\n/**\n * React-specific runtime for the markdown processor.\n * Implements the MarkdownRuntime interface using React's primitives.\n */\nexport const reactRuntime: MarkdownRuntime = {\n  /**\n   * Creates a React element.\n   * Handles the conversion of props and children to React format.\n   */\n  createElement: (\n    type: string | any,\n    props: Record<string, any> | null,\n    ...children: any[]\n  ): ReactNode => {\n    // React accepts children as rest args or as a single array\n    // If there's only one child, pass it directly to avoid unnecessary array\n    if (children.length === 0) {\n      return createElement(type, props);\n    }\n    if (children.length === 1) {\n      return createElement(type, props, children[0]);\n    }\n    return createElement(type, props, ...children);\n  },\n\n  /**\n   * Clones a React element with new props.\n   */\n  cloneElement: (\n    element: unknown,\n    props: Record<string, any>,\n    ...children: any[]\n  ): ReactNode => {\n    if (children.length === 0) {\n      return cloneElement(element as ReactElement, props);\n    }\n    return cloneElement(element as ReactElement, props, ...children);\n  },\n\n  /**\n   * React Fragment component.\n   */\n  Fragment,\n\n  /**\n   * React-specific prop normalization.\n   * React uses className instead of class, htmlFor instead of for, etc.\n   * The core processor already handles ATTRIBUTE_TO_NODE_PROP_MAP,\n   * so this is mostly a no-op but can be used for additional React-specific transforms.\n   */\n  normalizeProps: (\n    _tag: HTMLTag,\n    props: Record<string, any>\n  ): Record<string, any> => {\n    // The core already handles class -> className and for -> htmlFor\n    // via ATTRIBUTE_TO_NODE_PROP_MAP in the attrStringToMap function.\n    // This hook is available for any additional React-specific transforms.\n    return props;\n  },\n};\n\n/**\n * Creates a React runtime with custom createElement for advanced use cases.\n * Useful for wrapping elements or adding middleware.\n */\nexport const createReactRuntime = (\n  options: {\n    onCreateElement?: (\n      type: string | any,\n      props: Record<string, any> | null,\n      children: any[]\n    ) => ReactNode;\n  } = {}\n): MarkdownRuntime => {\n  const { onCreateElement } = options;\n\n  if (onCreateElement) {\n    return {\n      ...reactRuntime,\n      createElement: (\n        type: string | any,\n        props: Record<string, any> | null,\n        ...children: any[]\n      ): ReactNode => {\n        return onCreateElement(type, props, children);\n      },\n    };\n  }\n\n  return reactRuntime;\n};\n\nexport default reactRuntime;\n"],"mappings":"sEAaA,MAAa,EAAgC,CAK3C,eACE,EACA,EACA,GAAG,IAIC,EAAS,SAAW,EACf,EAAc,EAAM,EAAM,CAE/B,EAAS,SAAW,EACf,EAAc,EAAM,EAAO,EAAS,GAAG,CAEzC,EAAc,EAAM,EAAO,GAAG,EAAS,CAMhD,cACE,EACA,EACA,GAAG,IAEC,EAAS,SAAW,EACf,EAAa,EAAyB,EAAM,CAE9C,EAAa,EAAyB,EAAO,GAAG,EAAS,CAMlE,WAQA,gBACE,EACA,IAKO,EAEV,CAMY,GACX,EAMI,EAAE,GACc,CACpB,GAAM,CAAE,mBAAoB,EAe5B,OAbI,EACK,CACL,GAAG,EACH,eACE,EACA,EACA,GAAG,IAEI,EAAgB,EAAM,EAAO,EAAS,CAEhD,CAGI"}

package/dist/esm/plugins.mjs

@@ -1,173 +1,2 @@
-import { renderIntlayerNode } from "./IntlayerNode.mjs";
-import { ContentSelectorRenderer } from "./editor/ContentSelectorWrapper.mjs";
-import { EditedContentRenderer } from "./editor/useEditedContentRenderer.mjs";
-import { HTMLRendererPlugin } from "./html/HTMLRendererPlugin.mjs";
-import { MarkdownMetadataRenderer, MarkdownRendererPlugin } from "./markdown/MarkdownRendererPlugin.mjs";
-import { renderReactElement } from "./reactElement/renderReactElement.mjs";
-import { Fragment, createElement } from "react";
-import { jsx } from "react/jsx-runtime";
-import { getMarkdownMetadata, splitInsertionTemplate } from "@intlayer/core";
-import { NodeType } from "@intlayer/types";
-
-//#region src/plugins.tsx
-/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
-const intlayerNodePlugins = {
-	id: "intlayer-node-plugin",
-	canHandle: (node) => typeof node === "bigint" || typeof node === "string" || typeof node === "number",
-	transform: (_node, { plugins, ...rest }) => renderIntlayerNode({
-		...rest,
-		value: rest.children,
-		children: /* @__PURE__ */ jsx(EditedContentRenderer, {
-			...rest,
-			children: rest.children
-		})
-	})
-};
-/** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
-const reactNodePlugins = {
-	id: "react-node-plugin",
-	canHandle: (node) => typeof node === "object" && typeof node?.props !== "undefined" && typeof node.key !== "undefined",
-	transform: (node, { plugins, ...rest }) => renderIntlayerNode({
-		...rest,
-		value: "[[react-element]]",
-		children: /* @__PURE__ */ jsx(ContentSelectorRenderer, {
-			...rest,
-			children: renderReactElement(node)
-		})
-	})
-};
-/**
-* Split insertion string and join with React nodes using shared core logic
-*/
-const splitAndJoinInsertion = (template, values) => {
-	const result = splitInsertionTemplate(template, values);
-	if (result.isSimple) return result.parts;
-	return createElement(Fragment, null, ...result.parts.map((part, index) => createElement(Fragment, { key: index }, part)));
-};
-/** Insertion plugin for React. Handles component/node insertion. */
-const insertionPlugin = {
-	id: "insertion-plugin",
-	canHandle: (node) => typeof node === "object" && node?.nodeType === NodeType.Insertion,
-	transform: (node, props, deepTransformNode) => {
-		const newKeyPath = [...props.keyPath, { type: NodeType.Insertion }];
-		const children = node[NodeType.Insertion];
-		/** Insertion string plugin. Replaces string node with a component that render the insertion. */
-		const insertionStringPlugin = {
-			id: "insertion-string-plugin",
-			canHandle: (node) => typeof node === "string",
-			transform: (node, subProps, deepTransformNode) => {
-				const transformedResult = deepTransformNode(node, {
-					...subProps,
-					children: node,
-					plugins: [...(props.plugins ?? []).filter((plugin) => plugin.id !== "intlayer-node-plugin")]
-				});
-				return (values) => {
-					const result = splitAndJoinInsertion(transformedResult, values);
-					return deepTransformNode(result, {
-						...subProps,
-						plugins: props.plugins,
-						children: result
-					});
-				};
-			}
-		};
-		const result = deepTransformNode(children, {
-			...props,
-			children,
-			keyPath: newKeyPath,
-			plugins: [insertionStringPlugin, ...props.plugins ?? []]
-		});
-		if (typeof children === "object" && children !== null && "nodeType" in children && [NodeType.Enumeration, NodeType.Condition].includes(children.nodeType)) return (values) => (arg) => {
-			const inner = result(arg);
-			if (typeof inner === "function") return inner(values);
-			return inner;
-		};
-		return result;
-	}
-};
-/** Markdown string plugin. Replaces string node with a component that render the markdown. */
-const markdownStringPlugin = {
-	id: "markdown-string-plugin",
-	canHandle: (node) => typeof node === "string",
-	transform: (node, props, deepTransformNode) => {
-		const { plugins, ...rest } = props;
-		const metadataNodes = deepTransformNode(getMarkdownMetadata(node), {
-			plugins: [{
-				id: "markdown-metadata-plugin",
-				canHandle: (metadataNode) => typeof metadataNode === "string" || typeof metadataNode === "number" || typeof metadataNode === "boolean" || !metadataNode,
-				transform: (metadataNode, props) => renderIntlayerNode({
-					...props,
-					value: metadataNode,
-					children: /* @__PURE__ */ jsx(ContentSelectorRenderer, {
-						...rest,
-						children: /* @__PURE__ */ jsx(MarkdownMetadataRenderer, {
-							...rest,
-							metadataKeyPath: props.keyPath,
-							children: node
-						})
-					})
-				})
-			}],
-			dictionaryKey: rest.dictionaryKey,
-			keyPath: []
-		});
-		const render = (components) => renderIntlayerNode({
-			...props,
-			value: node,
-			children: /* @__PURE__ */ jsx(ContentSelectorRenderer, {
-				...rest,
-				children: /* @__PURE__ */ jsx(MarkdownRendererPlugin, {
-					...rest,
-					...components ?? {},
-					children: node
-				})
-			}),
-			additionalProps: { metadata: metadataNodes }
-		});
-		const element = render();
-		return new Proxy(element, { get(target, prop, receiver) {
-			if (prop === "value") return node;
-			if (prop === "metadata") return metadataNodes;
-			if (prop === "use") return (components) => render(components);
-			return Reflect.get(target, prop, receiver);
-		} });
-	}
-};
-const markdownPlugin = {
-	id: "markdown-plugin",
-	canHandle: (node) => typeof node === "object" && node?.nodeType === NodeType.Markdown,
-	transform: (node, props, deepTransformNode) => {
-		const newKeyPath = [...props.keyPath, { type: NodeType.Markdown }];
-		const children = node[NodeType.Markdown];
-		return deepTransformNode(children, {
-			...props,
-			children,
-			keyPath: newKeyPath,
-			plugins: [markdownStringPlugin, ...props.plugins ?? []]
-		});
-	}
-};
-/** HTML plugin. Replaces node with a function that takes components => ReactNode. */
-const htmlPlugin = {
-	id: "html-plugin",
-	canHandle: (node) => typeof node === "object" && node?.nodeType === NodeType.HTML,
-	transform: (node, props) => {
-		const html = node[NodeType.HTML];
-		const { plugins, ...rest } = props;
-		const render = (userComponents) => createElement(HTMLRendererPlugin, {
-			...rest,
-			html,
-			userComponents
-		});
-		const element = render();
-		return new Proxy(element, { get(target, prop, receiver) {
-			if (prop === "value") return html;
-			if (prop === "use") return (userComponents) => render(userComponents);
-			return Reflect.get(target, prop, receiver);
-		} });
-	}
-};
-
-//#endregion
-export { htmlPlugin, insertionPlugin, intlayerNodePlugins, markdownPlugin, markdownStringPlugin, reactNodePlugins };
+import{renderIntlayerNode as e}from"./IntlayerNode.mjs";import{ContentSelectorRenderer as t}from"./editor/ContentSelectorWrapper.mjs";import{EditedContentRenderer as n}from"./editor/useEditedContentRenderer.mjs";import{HTMLRendererPlugin as r}from"./html/HTMLRendererPlugin.mjs";import{MarkdownMetadataRenderer as i,MarkdownRendererPlugin as a}from"./markdown/MarkdownRendererPlugin.mjs";import{renderReactElement as o}from"./reactElement/renderReactElement.mjs";import{Fragment as s,createElement as c}from"react";import{jsx as l}from"react/jsx-runtime";import{splitInsertionTemplate as u}from"@intlayer/core/interpreter";import{getMarkdownMetadata as d}from"@intlayer/core/markdown";import{NodeType as f}from"@intlayer/types";const p={id:`intlayer-node-plugin`,canHandle:e=>typeof e==`bigint`||typeof e==`string`||typeof e==`number`,transform:(t,{plugins:r,...i})=>e({...i,value:i.children,children:l(n,{...i,children:i.children})})},m={id:`react-node-plugin`,canHandle:e=>typeof e==`object`&&e?.props!==void 0&&e.key!==void 0,transform:(n,{plugins:r,...i})=>e({...i,value:`[[react-element]]`,children:l(t,{...i,children:o(n)})})},h=(e,t)=>{let n=u(e,t);return n.isSimple?n.parts:c(s,null,...n.parts.map((e,t)=>c(s,{key:t},e)))},g={id:`insertion-plugin`,canHandle:e=>typeof e==`object`&&e?.nodeType===f.Insertion,transform:(e,t,n)=>{let r=[...t.keyPath,{type:f.Insertion}],i=e[f.Insertion],a={id:`insertion-string-plugin`,canHandle:e=>typeof e==`string`,transform:(e,n,r)=>{let i=r(e,{...n,children:e,plugins:[...(t.plugins??[]).filter(e=>e.id!==`intlayer-node-plugin`)]});return e=>{let a=h(i,e);return r(a,{...n,plugins:t.plugins,children:a})}}},o=n(i,{...t,children:i,keyPath:r,plugins:[a,...t.plugins??[]]});return typeof i==`object`&&i&&`nodeType`in i&&[f.Enumeration,f.Condition].includes(i.nodeType)?e=>t=>{let n=o(t);return typeof n==`function`?n(e):n}:o}},_={id:`markdown-string-plugin`,canHandle:e=>typeof e==`string`,transform:(n,r,o)=>{let{plugins:s,...c}=r,u=o(d(n),{plugins:[{id:`markdown-metadata-plugin`,canHandle:e=>typeof e==`string`||typeof e==`number`||typeof e==`boolean`||!e,transform:(r,a)=>e({...a,value:r,children:l(t,{...c,children:l(i,{...c,metadataKeyPath:a.keyPath,children:n})})})}],dictionaryKey:c.dictionaryKey,keyPath:[]}),f=i=>e({...r,value:n,children:l(t,{...c,children:l(a,{...c,...i??{},children:n})}),additionalProps:{metadata:u}}),p=f();return new Proxy(p,{get(e,t,r){return t===`value`?n:t===`metadata`?u:t===`use`?e=>f(e):Reflect.get(e,t,r)}})}},v={id:`markdown-plugin`,canHandle:e=>typeof e==`object`&&e?.nodeType===f.Markdown,transform:(e,t,n)=>{let r=[...t.keyPath,{type:f.Markdown}],i=e[f.Markdown];return n(i,{...t,children:i,keyPath:r,plugins:[_,...t.plugins??[]]})}},y={id:`html-plugin`,canHandle:e=>typeof e==`object`&&e?.nodeType===f.HTML,transform:(e,t)=>{let n=e[f.HTML],{plugins:i,...a}=t,o=e=>c(r,{...a,html:n,userComponents:e}),s=o();return new Proxy(s,{get(e,t,r){return t===`value`?n:t===`use`?e=>o(e):Reflect.get(e,t,r)}})}};export{y as htmlPlugin,g as insertionPlugin,p as intlayerNodePlugins,v as markdownPlugin,_ as markdownStringPlugin,m as reactNodePlugins};
 //# sourceMappingURL=plugins.mjs.map