npm - react-intlayer - Versions diffs - 9.4.3 → 9.5.0 - Mend

react-intlayer 9.4.3 → 9.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (147) hide show

package/README.md CHANGED Viewed

@@ -69,8 +69,6 @@ With **per-locale content files**, **TypeScript autocompletion**, **tree-shakabl
 | <img src="https://github.com/aymericzip/intlayer/blob/main/docs/assets/interoperability.png?raw=true" alt="Feature" width="700">                    | **Interoperability**<br><br>Allow interoperability with react-i18next, next-i18next, next-intl, react-intl, vue-i18n. <br><br> - [Intlayer and react-intl](https://intlayer.org/blog/intlayer-with-react-intl) <br> - [Intlayer and next-intl](https://intlayer.org/blog/intlayer-with-next-intl) <br> - [Intlayer and next-i18next](https://intlayer.org/blog/intlayer-with-next-i18next) <br> - [Intlayer and vue-i18n](https://intlayer.org/blog/intlayer-with-vue-i18n) <br> - [Intlayer compat adapters](https://intlayer.org/doc/compatibility) |
 | <img src="https://github.com/aymericzip/intlayer/blob/main/docs/assets/benchmark.png?raw=true" alt="Feature" width="700">                           | **Performances & Benchmark**<br><br>Uses advanced tree-shaking and dynamic loading to boost performances and keep the solution as light as possible. <br><br> - [Performances & Benchmark](https://intlayer.org/doc/benchmark)                                                                                                                                                                                                                                                                                                                        |
----
 ## 📦 Installation
 Start your journey with Intlayer today and experience a smoother, more powerful approach to internationalization.

package/dist/cjs/markdown/MarkdownProvider.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"MarkdownProvider.cjs","names":["createContext","useContext","compileMarkdown"],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"sourcesContent":["'use client';\n\nimport {\n createContext,\n type FC,\n type HTMLAttributes,\n type PropsWithChildren,\n type ReactNode,\n useContext,\n} from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\nimport {\n compileMarkdown,\n type MarkdownRendererOptions,\n type ParsedMarkdown,\n} from './processor';\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 for security. /\n tagfilter?: boolean;\n};\n\~~ntype~~ MarkdownContextValue = {\n components?: HTMLComponents<'permissive', {}>;\n renderMarkdown: (\n markdown: string \| ParsedMarkdown,\n options?: MarkdownProviderOptions,\n components?: HTMLComponents<'permissive', {}>,\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n ) => ReactNode \| Promise<ReactNode>;\n};\n\~~ntype~~ MarkdownProviderProps = PropsWithChildren<\n MarkdownProviderOptions & {\n components?: HTMLComponents<'permissive', {}>;\n wrapper?: FC<HTMLAttributes<HTMLElement>>;\n renderMarkdown?: (\n markdown: string \| ParsedMarkdown,\n options?: MarkdownProviderOptions,\n components?: HTMLComponents<'permissive', {}>,\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n ) => ReactNode \| Promise<ReactNode>;\n }\n>;\n\nconst MarkdownContext = createContext<MarkdownContextValue \| undefined>(\n undefined\n);\n\n/\n Returns the raw `MarkdownProvider` context value — the active\n * `renderMarkdown` function plus any provider-level component overrides.\n * Returns `undefined` when called outside a `<MarkdownProvider>`.\n * Prefer `useMarkdownRenderer` for most use cases; use this hook only when\n * you need direct access to the context object itself.\n /\nexport const useMarkdownContext = () => useContext(MarkdownContext);\n\nconst mergeOptions = (\n baseOptions: MarkdownRendererOptions,\n options: MarkdownProviderOptions = {},\n components: HTMLComponents<'permissive', {}> = {},\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n): MarkdownRendererOptions => {\n return {\n ...baseOptions,\n ...options,\n forceBlock: options.forceBlock ?? baseOptions.forceBlock,\n forceInline: options.forceInline ?? baseOptions.forceInline,\n preserveFrontmatter:\n options.preserveFrontmatter ?? baseOptions.preserveFrontmatter,\n tagfilter: options.tagfilter ?? baseOptions.tagfilter,\n wrapper: wrapper \|\| baseOptions.wrapper,\n\n forceWrapper: !!(wrapper \|\| baseOptions.wrapper),\n components: { ...baseOptions.components, ...components },\n };\n};\n\n/\n Provider for the MarkdownRenderer component.\n \n It will provide the `renderMarkdown` function to the context, which can be used to render markdown.\n \n ```tsx\n * const content = useIntlayer('app');\n \n return (\n * <div>\n * {content.markdown} // Will be rendered with the components and options provided to the MarkdownProvider\n * </div>\n * );\n * ```\n \n @example\n * ```tsx\n * <MarkdownProvider components={{ h1: CustomHeading }}>\n * <MarkdownRenderer>\n * {markdownContent}\n * </MarkdownRenderer>\n * </MarkdownProvider>\n * ```\n */\nexport const MarkdownProvider: FC<MarkdownProviderProps> = ({\n children,\n components,\n wrapper,\n forceBlock,\n forceInline,\n preserveFrontmatter,\n tagfilter,\n renderMarkdown: customRenderFn,\n}) => {\n const baseOptions: MarkdownRendererOptions = {\n components,\n forceBlock,\n forceInline,\n wrapper,\n forceWrapper: !!wrapper,\n preserveFrontmatter,\n tagfilter,\n };\n\n // Standard internal renderer\n const defaultRenderMarkdown = (\n markdown: string \| ParsedMarkdown,\n options?: MarkdownProviderOptions,\n components?: HTMLComponents<'permissive', {}>,\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n ) => {\n const mergedOptions = mergeOptions(\n baseOptions,\n options,\n components,\n wrapper\n );\n\n return compileMarkdown(markdown, mergedOptions);\n };\n\n // Wrapper for user-provided custom renderer\n // Note: We wrap in a clean Provider to prevent infinite recursion\n const customRenderMarkdownWrapper = (\n markdown: string \| ParsedMarkdown,\n options?: MarkdownProviderOptions,\n components?: HTMLComponents<'permissive', {}>,\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n ) => (\n <MarkdownContext.Provider value={undefined}>\n {customRenderFn?.(markdown, options, components, wrapper) as ReactNode}\n </MarkdownContext.Provider>\n );\n\n return (\n <MarkdownContext.Provider\n value={{\n components,\n renderMarkdown: customRenderFn\n ? customRenderMarkdownWrapper\n : defaultRenderMarkdown,\n }}\n >\n {children}\n </MarkdownContext.Provider>\n );\n};\n"],"mappings":";;;;;;;;AAmDA,MAAM,sBAAkBA,qBACtB,MACF;;;;;;;;AASA,MAAa,+BAA2BC,kBAAW,eAAe;AAElE,MAAM,gBACJ,aACA,UAAmC,CAAC,GACpC,aAA+C,CAAC,GAChD,YAC4B;CAC5B,OAAO;EACL,GAAG;EACH,GAAG;EACH,YAAY,QAAQ,cAAc,YAAY;EAC9C,aAAa,QAAQ,eAAe,YAAY;EAChD,qBACE,QAAQ,uBAAuB,YAAY;EAC7C,WAAW,QAAQ,aAAa,YAAY;EAC5C,SAAS,WAAW,YAAY;EAEhC,cAAc,CAAC,EAAE,WAAW,YAAY;EACxC,YAAY;GAAE,GAAG,YAAY;GAAY,GAAG;EAAW;CACzD;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,oBAA+C,EAC1D,UACA,YACA,SACA,YACA,aACA,qBACA,WACA,gBAAgB,qBACZ;CACJ,MAAM,cAAuC;EAC3C;EACA;EACA;EACA;EACA,cAAc,CAAC,CAAC;EAChB;EACA;CACF;CAGA,MAAM,yBACJ,UACA,SACA,YACA,YACG;EACH,MAAM,gBAAgB,aACpB,aACA,SACA,YACA,OACF;EAEA,OAAOC,2CAAgB,UAAU,aAAa;CAChD;CAIA,MAAM,+BACJ,UACA,SACA,YACA,YAEA,2CAAC,gBAAgB,UAAjB;EAA0B,OAAO;YAC9B,iBAAiB,UAAU,SAAS,YAAY,OAAO;CAChC;CAG5B,OACE,2CAAC,gBAAgB,UAAjB;EACE,OAAO;GACL;GACA,gBAAgB,iBACZ,8BACA;EACN;EAEC;CACuB;AAE9B"}
1	+ {"version":3,"file":"MarkdownProvider.cjs","names":["createContext","useContext","compileMarkdown"],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"sourcesContent":["'use client';\n\nimport {\n createContext,\n type FC,\n type HTMLAttributes,\n type PropsWithChildren,\n type ReactNode,\n useContext,\n} from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\nimport {\n compileMarkdown,\n type MarkdownRendererOptions,\n type ParsedMarkdown,\n} from './processor';\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 for security. /\n tagfilter?: boolean;\n};\n\nexport type MarkdownContextValue = {\n components?: HTMLComponents<'permissive', {}>;\n renderMarkdown: (\n markdown: string \| ParsedMarkdown,\n options?: MarkdownProviderOptions,\n components?: HTMLComponents<'permissive', {}>,\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n ) => ReactNode \| Promise<ReactNode>;\n};\n\nexport type MarkdownProviderProps = PropsWithChildren<\n MarkdownProviderOptions & {\n components?: HTMLComponents<'permissive', {}>;\n wrapper?: FC<HTMLAttributes<HTMLElement>>;\n renderMarkdown?: (\n markdown: string \| ParsedMarkdown,\n options?: MarkdownProviderOptions,\n components?: HTMLComponents<'permissive', {}>,\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n ) => ReactNode \| Promise<ReactNode>;\n }\n>;\n\nconst MarkdownContext = createContext<MarkdownContextValue \| undefined>(\n undefined\n);\n\n/\n Returns the raw `MarkdownProvider` context value — the active\n * `renderMarkdown` function plus any provider-level component overrides.\n * Returns `undefined` when called outside a `<MarkdownProvider>`.\n * Prefer `useMarkdownRenderer` for most use cases; use this hook only when\n * you need direct access to the context object itself.\n /\nexport const useMarkdownContext = () => useContext(MarkdownContext);\n\nconst mergeOptions = (\n baseOptions: MarkdownRendererOptions,\n options: MarkdownProviderOptions = {},\n components: HTMLComponents<'permissive', {}> = {},\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n): MarkdownRendererOptions => {\n return {\n ...baseOptions,\n ...options,\n forceBlock: options.forceBlock ?? baseOptions.forceBlock,\n forceInline: options.forceInline ?? baseOptions.forceInline,\n preserveFrontmatter:\n options.preserveFrontmatter ?? baseOptions.preserveFrontmatter,\n tagfilter: options.tagfilter ?? baseOptions.tagfilter,\n wrapper: wrapper \|\| baseOptions.wrapper,\n\n forceWrapper: !!(wrapper \|\| baseOptions.wrapper),\n components: { ...baseOptions.components, ...components },\n };\n};\n\n/\n Provider for the MarkdownRenderer component.\n \n It will provide the `renderMarkdown` function to the context, which can be used to render markdown.\n \n ```tsx\n * const content = useIntlayer('app');\n \n return (\n * <div>\n * {content.markdown} // Will be rendered with the components and options provided to the MarkdownProvider\n * </div>\n * );\n * ```\n \n @example\n * ```tsx\n * <MarkdownProvider components={{ h1: CustomHeading }}>\n * <MarkdownRenderer>\n * {markdownContent}\n * </MarkdownRenderer>\n * </MarkdownProvider>\n * ```\n */\nexport const MarkdownProvider: FC<MarkdownProviderProps> = ({\n children,\n components,\n wrapper,\n forceBlock,\n forceInline,\n preserveFrontmatter,\n tagfilter,\n renderMarkdown: customRenderFn,\n}) => {\n const baseOptions: MarkdownRendererOptions = {\n components,\n forceBlock,\n forceInline,\n wrapper,\n forceWrapper: !!wrapper,\n preserveFrontmatter,\n tagfilter,\n };\n\n // Standard internal renderer\n const defaultRenderMarkdown = (\n markdown: string \| ParsedMarkdown,\n options?: MarkdownProviderOptions,\n components?: HTMLComponents<'permissive', {}>,\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n ) => {\n const mergedOptions = mergeOptions(\n baseOptions,\n options,\n components,\n wrapper\n );\n\n return compileMarkdown(markdown, mergedOptions);\n };\n\n // Wrapper for user-provided custom renderer\n // Note: We wrap in a clean Provider to prevent infinite recursion\n const customRenderMarkdownWrapper = (\n markdown: string \| ParsedMarkdown,\n options?: MarkdownProviderOptions,\n components?: HTMLComponents<'permissive', {}>,\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n ) => (\n <MarkdownContext.Provider value={undefined}>\n {customRenderFn?.(markdown, options, components, wrapper) as ReactNode}\n </MarkdownContext.Provider>\n );\n\n return (\n <MarkdownContext.Provider\n value={{\n components,\n renderMarkdown: customRenderFn\n ? customRenderMarkdownWrapper\n : defaultRenderMarkdown,\n }}\n >\n {children}\n </MarkdownContext.Provider>\n );\n};\n"],"mappings":";;;;;;;;AAmDA,MAAM,sBAAkBA,qBACtB,MACF;;;;;;;;AASA,MAAa,+BAA2BC,kBAAW,eAAe;AAElE,MAAM,gBACJ,aACA,UAAmC,CAAC,GACpC,aAA+C,CAAC,GAChD,YAC4B;CAC5B,OAAO;EACL,GAAG;EACH,GAAG;EACH,YAAY,QAAQ,cAAc,YAAY;EAC9C,aAAa,QAAQ,eAAe,YAAY;EAChD,qBACE,QAAQ,uBAAuB,YAAY;EAC7C,WAAW,QAAQ,aAAa,YAAY;EAC5C,SAAS,WAAW,YAAY;EAEhC,cAAc,CAAC,EAAE,WAAW,YAAY;EACxC,YAAY;GAAE,GAAG,YAAY;GAAY,GAAG;EAAW;CACzD;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,oBAA+C,EAC1D,UACA,YACA,SACA,YACA,aACA,qBACA,WACA,gBAAgB,qBACZ;CACJ,MAAM,cAAuC;EAC3C;EACA;EACA;EACA;EACA,cAAc,CAAC,CAAC;EAChB;EACA;CACF;CAGA,MAAM,yBACJ,UACA,SACA,YACA,YACG;EACH,MAAM,gBAAgB,aACpB,aACA,SACA,YACA,OACF;EAEA,OAAOC,2CAAgB,UAAU,aAAa;CAChD;CAIA,MAAM,+BACJ,UACA,SACA,YACA,YAEA,2CAAC,gBAAgB,UAAjB;EAA0B,OAAO;YAC9B,iBAAiB,UAAU,SAAS,YAAY,OAAO;CAChC;CAG5B,OACE,2CAAC,gBAAgB,UAAjB;EACE,OAAO;GACL;GACA,gBAAgB,iBACZ,8BACA;EACN;EAEC;CACuB;AAE9B"}

package/dist/cjs/markdown/processor.cjs CHANGED Viewed

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_markdown_runtime = require('./runtime.cjs');
 let _intlayer_core_markdown = require("@intlayer/core/markdown");
-let react = require("react");
 //#region src/markdown/processor.tsx
 /**
@@ -9,15 +9,6 @@ let react = require("react");
 * [simple-markdown v0.2.2](https://github.com/Khan/simple-markdown) from Khan Academy.
 */
 /**
-* Default React runtime for markdown rendering.
-*/
-const DEFAULT_RUNTIME = {
-	createElement: react.createElement,
-	cloneElement: react.cloneElement,
-	Fragment: react.Fragment,
-	normalizeProps: (_tag, props) => props
-};
-/**
 * **Step 1 of 2 — parse only.**
 * Converts a raw markdown string into a `ParsedMarkdown` AST without rendering
 * any React elements. Use this when you need to:
@@ -38,7 +29,7 @@ const DEFAULT_RUNTIME = {
 const parseMarkdown = (markdown = "", options = {}) => {
 	const { disableAutoLink, disableParsingRawHTML, enforceAtxHeadings, forceBlock, forceInline, forceWrapper, namedCodesToUnicode, components, sanitizer, slugify, wrapper, preserveFrontmatter, tagfilter } = options;
 	return (0, _intlayer_core_markdown.parseMarkdown)(markdown, {
-		runtime: DEFAULT_RUNTIME,
+		runtime: require_markdown_runtime.reactRuntime,
 		components,
 		namedCodesToUnicode,
 		sanitizer,
@@ -74,9 +65,9 @@ const compileMarkdown = (input = "", options = {}) => {
 	const { createElement: customCreateElement, disableAutoLink, disableParsingRawHTML, enforceAtxHeadings, forceBlock, forceInline, forceWrapper, namedCodesToUnicode, components, renderRule, sanitizer, slugify, wrapper, preserveFrontmatter, tagfilter } = options;
 	const ctx = {
 		runtime: customCreateElement ? {
-			...DEFAULT_RUNTIME,
+			...require_markdown_runtime.reactRuntime,
 			createElement: customCreateElement
-		} : DEFAULT_RUNTIME,
+		} : require_markdown_runtime.reactRuntime,
 		components,
 		namedCodesToUnicode,
 		sanitizer,

package/dist/cjs/markdown/processor.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"processor.cjs","names":["~~createElement~~","~~coreParseMarkdown~~","coreCompile","coreRenderMarkdownAst"],"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 parseMarkdown as coreParseMarkdown,\n renderMarkdownAst as coreRenderMarkdownAst,\n type MarkdownContext,\n type MarkdownOptions,\n type ~~MarkdownRuntime,\n type~~ ParsedMarkdown,\n type RenderRuleHook,\n} from '@intlayer/core/markdown';\nimport {~~\n cloneElement,\n~~ createElement~~,\n Fragment,\n type~~ JSX~~,\n type~~ ReactNode~~,\n~~} from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\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 Intermediate AST produced by `parseMarkdown`.\n * Pass this to `compileMarkdown` or `<MarkdownRenderer>` to skip re-parsing\n * when the same content is rendered multiple times.\n /\nexport type { ParsedMarkdown };\n\n/\n Step 1 of 2 — parse only.\n * Converts a raw markdown string into a `ParsedMarkdown` AST without rendering\n * any React elements. Use this when you need to:\n * - Cache the parsed result and render it several times with different options.\n * - Inspect or transform the AST before rendering.\n * - Defer the render step to a later point in the pipeline.\n \n @param markdown - The markdown source string.\n * @param options - Options that affect parsing (sanitizer, slugify, …).\n * @returns A `ParsedMarkdown` AST ready to be passed to `compileMarkdown`.\n \n @example\n * ```tsx\n * const ast = parseMarkdown('# Hello world');\n * const element = compileMarkdown(ast, { forceBlock: true });\n * ```\n /\nexport const parseMarkdown = (\n markdown: string = '',\n options: MarkdownRendererOptions = {}\n): ParsedMarkdown => {\n const {\n disableAutoLink,\n disableParsingRawHTML,\n enforceAtxHeadings,\n forceBlock,\n forceInline,\n forceWrapper,\n namedCodesToUnicode,\n components,\n sanitizer,\n slugify,\n wrapper,\n preserveFrontmatter,\n tagfilter,\n } = options;\n\n const ctx: MarkdownContext<HTMLComponents> = {\n runtime: ~~DEFAULT_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 wrapper,\n preserveFrontmatter,\n tagfilter,\n };\n\n return coreParseMarkdown(markdown, ctx, compilerOptions);\n};\n\n/\n Steps 1 + 2 — parse and render in one shot.\n * Accepts a raw markdown string or a pre-parsed `ParsedMarkdown` AST and\n * returns a React element. Use `parseMarkdown` first when you need to reuse\n * the same AST with different options.\n \n @param input - Markdown string or pre-parsed AST.\n * @param options - Rendering options (custom components, sanitizer, slugify, …).\n * @returns A React JSX element representing the rendered markdown.\n \n @example\n * ```tsx\n * const element = compileMarkdown('# Hello world', { forceBlock: true });\n * ```\n */\nexport const compileMarkdown = (\n input: string \| ParsedMarkdown = '',\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 if (typeof input === 'string') {\n return coreCompile(input, ctx, compilerOptions) as JSX.Element;\n }\n\n return coreRenderMarkdownAst(input, ctx, compilerOptions) as JSX.Element;\n};\n"],"mappings":"~~;;;;;;;;;;;;;AAsHA~~,~~MAAM,kBAAmC;CACvC,eAAeA;CACf;CACA;CACA,iBAAiB,MAAM,UAAU;AACnC;;;;;;;;;;;;;;;;;;;AA2BA,~~MAAa,iBACX,WAAmB,IACnB,UAAmC,CAAC,MACjB;CACnB,MAAM,EACJ,iBACA,uBACA,oBACA,YACA,aACA,cACA,qBACA,YACA,WACA,SACA,SACA,qBACA,cACE;CAsBJ,~~WAAOC~~,uCAAkB,UAAU;EAnBjC,~~SAAS~~;EACT;EACA;EACW;EACX;CAemC,GAAG;EAXtC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CAGoD,CAAC;AACzD;;;;;;;;;;;;;;;;AAiBA,MAAa,mBACX,QAAiC,IACjC,UAAmC,CAAC,MACpB;CAChB,MAAM,EACJ,eAAe,qBACf,iBACA,uBACA,oBACA,YACA,aACA,cACA,qBACA,YACA,YACA,WACA,SACA,SACA,qBACA,cACE;CAMJ,MAAM,MAAuC;EAC3C,SALc,sBACZ;GAAE,~~GAAG~~;~~GAAiB~~,eAAe;EAA2B,~~IAChE~~;EAIF;EACA;EACW;EACX;CACF;CAEA,MAAM,kBAAmC;EACvC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACF;CAEA,IAAI,OAAO,UAAU,UACnB,WAAOC,iCAAY,OAAO,KAAK,eAAe;CAGhD,WAAOC,2CAAsB,OAAO,KAAK,eAAe;AAC1D"}
1	+ {"version":3,"file":"processor.cjs","names":["coreParseMarkdown","reactRuntime","coreCompile","coreRenderMarkdownAst"],"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 parseMarkdown as coreParseMarkdown,\n renderMarkdownAst as coreRenderMarkdownAst,\n type MarkdownContext,\n type MarkdownOptions,\n type ParsedMarkdown,\n type RenderRuleHook,\n} from '@intlayer/core/markdown';\nimport type { createElement, JSX, ReactNode } from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\nimport { reactRuntime } from './runtime';\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 /\n\n/\n Intermediate AST produced by `parseMarkdown`.\n * Pass this to `compileMarkdown` or `<MarkdownRenderer>` to skip re-parsing\n * when the same content is rendered multiple times.\n /\nexport type { ParsedMarkdown };\n\n/\n Step 1 of 2 — parse only.\n * Converts a raw markdown string into a `ParsedMarkdown` AST without rendering\n * any React elements. Use this when you need to:\n * - Cache the parsed result and render it several times with different options.\n * - Inspect or transform the AST before rendering.\n * - Defer the render step to a later point in the pipeline.\n \n @param markdown - The markdown source string.\n * @param options - Options that affect parsing (sanitizer, slugify, …).\n * @returns A `ParsedMarkdown` AST ready to be passed to `compileMarkdown`.\n \n @example\n * ```tsx\n * const ast = parseMarkdown('# Hello world');\n * const element = compileMarkdown(ast, { forceBlock: true });\n * ```\n /\nexport const parseMarkdown = (\n markdown: string = '',\n options: MarkdownRendererOptions = {}\n): ParsedMarkdown => {\n const {\n disableAutoLink,\n disableParsingRawHTML,\n enforceAtxHeadings,\n forceBlock,\n forceInline,\n forceWrapper,\n namedCodesToUnicode,\n components,\n sanitizer,\n slugify,\n wrapper,\n preserveFrontmatter,\n tagfilter,\n } = options;\n\n const ctx: MarkdownContext<HTMLComponents> = {\n runtime: reactRuntime,\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 wrapper,\n preserveFrontmatter,\n tagfilter,\n };\n\n return coreParseMarkdown(markdown, ctx, compilerOptions);\n};\n\n/\n Steps 1 + 2 — parse and render in one shot.\n * Accepts a raw markdown string or a pre-parsed `ParsedMarkdown` AST and\n * returns a React element. Use `parseMarkdown` first when you need to reuse\n * the same AST with different options.\n \n @param input - Markdown string or pre-parsed AST.\n * @param options - Rendering options (custom components, sanitizer, slugify, …).\n * @returns A React JSX element representing the rendered markdown.\n \n @example\n * ```tsx\n * const element = compileMarkdown('# Hello world', { forceBlock: true });\n * ```\n */\nexport const compileMarkdown = (\n input: string \| ParsedMarkdown = '',\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 ? { ...reactRuntime, createElement: customCreateElement as any }\n : reactRuntime;\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 if (typeof input === 'string') {\n return coreCompile(input, ctx, compilerOptions) as JSX.Element;\n }\n\n return coreRenderMarkdownAst(input, ctx, compilerOptions) as JSX.Element;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0IA,MAAa,iBACX,WAAmB,IACnB,UAAmC,CAAC,MACjB;CACnB,MAAM,EACJ,iBACA,uBACA,oBACA,YACA,aACA,cACA,qBACA,YACA,WACA,SACA,SACA,qBACA,cACE;CAsBJ,WAAOA,uCAAkB,UAAU;EAnBjC,SAASC;EACT;EACA;EACW;EACX;CAemC,GAAG;EAXtC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CAGoD,CAAC;AACzD;;;;;;;;;;;;;;;;AAiBA,MAAa,mBACX,QAAiC,IACjC,UAAmC,CAAC,MACpB;CAChB,MAAM,EACJ,eAAe,qBACf,iBACA,uBACA,oBACA,YACA,aACA,cACA,qBACA,YACA,YACA,WACA,SACA,SACA,qBACA,cACE;CAMJ,MAAM,MAAuC;EAC3C,SALc,sBACZ;GAAE,GAAGA;GAAc,eAAe;EAA2B,IAC7DA;EAIF;EACA;EACW;EACX;CACF;CAEA,MAAM,kBAAmC;EACvC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACF;CAEA,IAAI,OAAO,UAAU,UACnB,WAAOC,iCAAY,OAAO,KAAK,eAAe;CAGhD,WAAOC,2CAAsB,OAAO,KAAK,eAAe;AAC1D"}

package/dist/cjs/markdown/runtime.cjs CHANGED Viewed

@@ -6,15 +6,43 @@ let react = require("react");
 * React-specific runtime for the markdown processor.
 * Implements the MarkdownRuntime interface using React's primitives.
 */
+let REACT_ELEMENT_TYPE;
+try {
+	const sample = (0, react.createElement)("div");
+	REACT_ELEMENT_TYPE = sample && typeof sample === "object" && "$$typeof" in sample && typeof sample.$$typeof === "symbol" ? sample.$$typeof : Symbol.for("react.transitional.element");
+} catch {
+	REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element");
+}
+/**
+* React-specific runtime for the markdown processor.
+* Implements the MarkdownRuntime interface using React's primitives.
+*/
 const reactRuntime = {
 	/**
 	* Creates a React element.
 	* Handles the conversion of props and children to React format.
 	*/
 	createElement: (type, props, ...children) => {
-		if (children.length === 0) return (0, react.createElement)(type, props);
-		if (children.length === 1) return (0, react.createElement)(type, props, children[0]);
-		return (0, react.createElement)(type, props, ...children);
+		let key = null;
+		const finalProps = props || {};
+		if (props && props.key != null) {
+			key = String(props.key);
+			finalProps.key = void 0;
+		}
+		const childCount = children.length;
+		if (childCount === 1) finalProps.children = children[0];
+		else if (childCount > 1) finalProps.children = children;
+		return {
+			$$typeof: REACT_ELEMENT_TYPE,
+			type,
+			key,
+			ref: null,
+			props: finalProps,
+			_owner: null,
+			_store: {},
+			_debugStack: null,
+			_debugTask: null
+		};
 	},
 	/**
 	* Clones a React element with new props.

package/dist/cjs/markdown/runtime.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"runtime.cjs","names":["createElement","cloneElement"],"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"],"mappings":";;;;;;;;AAaA,MAAa,eAAgC;;;;;CAK3C,gBACE,MACA,OACA,GAAG,aACW;~~EAGd~~,IAAI,SAAS,~~WAAW~~,GACtB,~~WAAOA~~,~~qBAAc~~,MAAM,~~KAAK~~;~~EAElC~~,IAAI,~~SAAS~~,WAAW,~~GACtB~~,~~WAAOA~~,~~qBAAc~~,~~MAAM~~,~~OAAO~~,~~SAAS~~,~~EAAE~~;~~EAE/C~~,~~WAAOA~~,~~qBAAc~~,~~MAAM~~,OAAO,~~GAAG~~,QAAQ;~~CAC/C~~;;;;CAKA,eACE,SACA,OACA,GAAG,aACW;EACd,IAAI,SAAS,WAAW,GACtB,WAAOC,oBAAa,SAAyB,KAAK;EAEpD,WAAOA,oBAAa,SAAyB,OAAO,GAAG,QAAQ;CACjE;;;;CAKA;;;;;;;CAQA,iBACE,MACA,UACwB;EAIxB,OAAO;CACT;AACF;;;;;AAMA,MAAa,sBACX,UAMI,CAAC,MACe;CACpB,MAAM,EAAE,oBAAoB;CAE5B,IAAI,iBACF,OAAO;EACL,GAAG;EACH,gBACE,MACA,OACA,GAAG,aACW;GACd,OAAO,gBAAgB,MAAM,OAAO,QAAQ;EAC9C;CACF;CAGF,OAAO;AACT"}
1	+ {"version":3,"file":"runtime.cjs","names":["createElement","cloneElement"],"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 /\nlet REACT_ELEMENT_TYPE: symbol;\ntry {\n const sample = createElement('div');\n REACT_ELEMENT_TYPE =\n sample &&\n typeof sample === 'object' &&\n '$$typeof' in sample &&\n typeof sample.$$typeof === 'symbol'\n ? (sample.$$typeof as symbol)\n : Symbol.for('react.transitional.element');\n} catch {\n REACT_ELEMENT_TYPE = Symbol.for('react.transitional.element');\n}\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 let key: string \| null = null;\n const finalProps: any = props \|\| {};\n\n if (props && props.key != null) {\n key = String(props.key);\n finalProps.key = undefined;\n }\n\n const childCount = children.length;\n if (childCount === 1) {\n finalProps.children = children[0];\n } else if (childCount > 1) {\n finalProps.children = children;\n }\n\n return {\n $$typeof: REACT_ELEMENT_TYPE,\n type,\n key,\n ref: null,\n props: finalProps,\n _owner: null,\n _store: {},\n _debugStack: null,\n _debugTask: null,\n } as unknown as ReactNode;\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"],"mappings":";;;;;;;;AAaA,IAAI;AACJ,IAAI;CACF,MAAM,aAASA,qBAAc,KAAK;CAClC,qBACE,UACA,OAAO,WAAW,YAClB,cAAc,UACd,OAAO,OAAO,aAAa,WACtB,OAAO,WACR,OAAO,IAAI,4BAA4B;AAC/C,QAAQ;CACN,qBAAqB,OAAO,IAAI,4BAA4B;AAC9D;;;;;AAMA,MAAa,eAAgC;;;;;CAK3C,gBACE,MACA,OACA,GAAG,aACW;EACd,IAAI,MAAqB;EACzB,MAAM,aAAkB,SAAS,CAAC;EAElC,IAAI,SAAS,MAAM,OAAO,MAAM;GAC9B,MAAM,OAAO,MAAM,GAAG;GACtB,WAAW,MAAM;EACnB;EAEA,MAAM,aAAa,SAAS;EAC5B,IAAI,eAAe,GACjB,WAAW,WAAW,SAAS;OAC1B,IAAI,aAAa,GACtB,WAAW,WAAW;EAGxB,OAAO;GACL,UAAU;GACV;GACA;GACA,KAAK;GACL,OAAO;GACP,QAAQ;GACR,QAAQ,CAAC;GACT,aAAa;GACb,YAAY;EACd;CACF;;;;CAKA,eACE,SACA,OACA,GAAG,aACW;EACd,IAAI,SAAS,WAAW,GACtB,WAAOC,oBAAa,SAAyB,KAAK;EAEpD,WAAOA,oBAAa,SAAyB,OAAO,GAAG,QAAQ;CACjE;;;;CAKA;;;;;;;CAQA,iBACE,MACA,UACwB;EAIxB,OAAO;CACT;AACF;;;;;AAMA,MAAa,sBACX,UAMI,CAAC,MACe;CACpB,MAAM,EAAE,oBAAoB;CAE5B,IAAI,iBACF,OAAO;EACL,GAAG;EACH,gBACE,MACA,OACA,GAAG,aACW;GACd,OAAO,gBAAgB,MAAM,OAAO,QAAQ;EAC9C;CACF;CAGF,OAAO;AACT"}

package/dist/esm/markdown/MarkdownProvider.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"MarkdownProvider.mjs","names":[],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"sourcesContent":["'use client';\n\nimport {\n createContext,\n type FC,\n type HTMLAttributes,\n type PropsWithChildren,\n type ReactNode,\n useContext,\n} from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\nimport {\n compileMarkdown,\n type MarkdownRendererOptions,\n type ParsedMarkdown,\n} from './processor';\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 for security. /\n tagfilter?: boolean;\n};\n\~~ntype~~ MarkdownContextValue = {\n components?: HTMLComponents<'permissive', {}>;\n renderMarkdown: (\n markdown: string \| ParsedMarkdown,\n options?: MarkdownProviderOptions,\n components?: HTMLComponents<'permissive', {}>,\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n ) => ReactNode \| Promise<ReactNode>;\n};\n\~~ntype~~ MarkdownProviderProps = PropsWithChildren<\n MarkdownProviderOptions & {\n components?: HTMLComponents<'permissive', {}>;\n wrapper?: FC<HTMLAttributes<HTMLElement>>;\n renderMarkdown?: (\n markdown: string \| ParsedMarkdown,\n options?: MarkdownProviderOptions,\n components?: HTMLComponents<'permissive', {}>,\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n ) => ReactNode \| Promise<ReactNode>;\n }\n>;\n\nconst MarkdownContext = createContext<MarkdownContextValue \| undefined>(\n undefined\n);\n\n/\n Returns the raw `MarkdownProvider` context value — the active\n * `renderMarkdown` function plus any provider-level component overrides.\n * Returns `undefined` when called outside a `<MarkdownProvider>`.\n * Prefer `useMarkdownRenderer` for most use cases; use this hook only when\n * you need direct access to the context object itself.\n /\nexport const useMarkdownContext = () => useContext(MarkdownContext);\n\nconst mergeOptions = (\n baseOptions: MarkdownRendererOptions,\n options: MarkdownProviderOptions = {},\n components: HTMLComponents<'permissive', {}> = {},\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n): MarkdownRendererOptions => {\n return {\n ...baseOptions,\n ...options,\n forceBlock: options.forceBlock ?? baseOptions.forceBlock,\n forceInline: options.forceInline ?? baseOptions.forceInline,\n preserveFrontmatter:\n options.preserveFrontmatter ?? baseOptions.preserveFrontmatter,\n tagfilter: options.tagfilter ?? baseOptions.tagfilter,\n wrapper: wrapper \|\| baseOptions.wrapper,\n\n forceWrapper: !!(wrapper \|\| baseOptions.wrapper),\n components: { ...baseOptions.components, ...components },\n };\n};\n\n/\n Provider for the MarkdownRenderer component.\n \n It will provide the `renderMarkdown` function to the context, which can be used to render markdown.\n \n ```tsx\n * const content = useIntlayer('app');\n \n return (\n * <div>\n * {content.markdown} // Will be rendered with the components and options provided to the MarkdownProvider\n * </div>\n * );\n * ```\n \n @example\n * ```tsx\n * <MarkdownProvider components={{ h1: CustomHeading }}>\n * <MarkdownRenderer>\n * {markdownContent}\n * </MarkdownRenderer>\n * </MarkdownProvider>\n * ```\n */\nexport const MarkdownProvider: FC<MarkdownProviderProps> = ({\n children,\n components,\n wrapper,\n forceBlock,\n forceInline,\n preserveFrontmatter,\n tagfilter,\n renderMarkdown: customRenderFn,\n}) => {\n const baseOptions: MarkdownRendererOptions = {\n components,\n forceBlock,\n forceInline,\n wrapper,\n forceWrapper: !!wrapper,\n preserveFrontmatter,\n tagfilter,\n };\n\n // Standard internal renderer\n const defaultRenderMarkdown = (\n markdown: string \| ParsedMarkdown,\n options?: MarkdownProviderOptions,\n components?: HTMLComponents<'permissive', {}>,\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n ) => {\n const mergedOptions = mergeOptions(\n baseOptions,\n options,\n components,\n wrapper\n );\n\n return compileMarkdown(markdown, mergedOptions);\n };\n\n // Wrapper for user-provided custom renderer\n // Note: We wrap in a clean Provider to prevent infinite recursion\n const customRenderMarkdownWrapper = (\n markdown: string \| ParsedMarkdown,\n options?: MarkdownProviderOptions,\n components?: HTMLComponents<'permissive', {}>,\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n ) => (\n <MarkdownContext.Provider value={undefined}>\n {customRenderFn?.(markdown, options, components, wrapper) as ReactNode}\n </MarkdownContext.Provider>\n );\n\n return (\n <MarkdownContext.Provider\n value={{\n components,\n renderMarkdown: customRenderFn\n ? customRenderMarkdownWrapper\n : defaultRenderMarkdown,\n }}\n >\n {children}\n </MarkdownContext.Provider>\n );\n};\n"],"mappings":";;;;;;;AAmDA,MAAM,kBAAkB,cACtB,MACF;;;;;;;;AASA,MAAa,2BAA2B,WAAW,eAAe;AAElE,MAAM,gBACJ,aACA,UAAmC,CAAC,GACpC,aAA+C,CAAC,GAChD,YAC4B;CAC5B,OAAO;EACL,GAAG;EACH,GAAG;EACH,YAAY,QAAQ,cAAc,YAAY;EAC9C,aAAa,QAAQ,eAAe,YAAY;EAChD,qBACE,QAAQ,uBAAuB,YAAY;EAC7C,WAAW,QAAQ,aAAa,YAAY;EAC5C,SAAS,WAAW,YAAY;EAEhC,cAAc,CAAC,EAAE,WAAW,YAAY;EACxC,YAAY;GAAE,GAAG,YAAY;GAAY,GAAG;EAAW;CACzD;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,oBAA+C,EAC1D,UACA,YACA,SACA,YACA,aACA,qBACA,WACA,gBAAgB,qBACZ;CACJ,MAAM,cAAuC;EAC3C;EACA;EACA;EACA;EACA,cAAc,CAAC,CAAC;EAChB;EACA;CACF;CAGA,MAAM,yBACJ,UACA,SACA,YACA,YACG;EACH,MAAM,gBAAgB,aACpB,aACA,SACA,YACA,OACF;EAEA,OAAO,gBAAgB,UAAU,aAAa;CAChD;CAIA,MAAM,+BACJ,UACA,SACA,YACA,YAEA,oBAAC,gBAAgB,UAAjB;EAA0B,OAAO;YAC9B,iBAAiB,UAAU,SAAS,YAAY,OAAO;CAChC;CAG5B,OACE,oBAAC,gBAAgB,UAAjB;EACE,OAAO;GACL;GACA,gBAAgB,iBACZ,8BACA;EACN;EAEC;CACuB;AAE9B"}
1	+ {"version":3,"file":"MarkdownProvider.mjs","names":[],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"sourcesContent":["'use client';\n\nimport {\n createContext,\n type FC,\n type HTMLAttributes,\n type PropsWithChildren,\n type ReactNode,\n useContext,\n} from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\nimport {\n compileMarkdown,\n type MarkdownRendererOptions,\n type ParsedMarkdown,\n} from './processor';\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 for security. /\n tagfilter?: boolean;\n};\n\nexport type MarkdownContextValue = {\n components?: HTMLComponents<'permissive', {}>;\n renderMarkdown: (\n markdown: string \| ParsedMarkdown,\n options?: MarkdownProviderOptions,\n components?: HTMLComponents<'permissive', {}>,\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n ) => ReactNode \| Promise<ReactNode>;\n};\n\nexport type MarkdownProviderProps = PropsWithChildren<\n MarkdownProviderOptions & {\n components?: HTMLComponents<'permissive', {}>;\n wrapper?: FC<HTMLAttributes<HTMLElement>>;\n renderMarkdown?: (\n markdown: string \| ParsedMarkdown,\n options?: MarkdownProviderOptions,\n components?: HTMLComponents<'permissive', {}>,\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n ) => ReactNode \| Promise<ReactNode>;\n }\n>;\n\nconst MarkdownContext = createContext<MarkdownContextValue \| undefined>(\n undefined\n);\n\n/\n Returns the raw `MarkdownProvider` context value — the active\n * `renderMarkdown` function plus any provider-level component overrides.\n * Returns `undefined` when called outside a `<MarkdownProvider>`.\n * Prefer `useMarkdownRenderer` for most use cases; use this hook only when\n * you need direct access to the context object itself.\n /\nexport const useMarkdownContext = () => useContext(MarkdownContext);\n\nconst mergeOptions = (\n baseOptions: MarkdownRendererOptions,\n options: MarkdownProviderOptions = {},\n components: HTMLComponents<'permissive', {}> = {},\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n): MarkdownRendererOptions => {\n return {\n ...baseOptions,\n ...options,\n forceBlock: options.forceBlock ?? baseOptions.forceBlock,\n forceInline: options.forceInline ?? baseOptions.forceInline,\n preserveFrontmatter:\n options.preserveFrontmatter ?? baseOptions.preserveFrontmatter,\n tagfilter: options.tagfilter ?? baseOptions.tagfilter,\n wrapper: wrapper \|\| baseOptions.wrapper,\n\n forceWrapper: !!(wrapper \|\| baseOptions.wrapper),\n components: { ...baseOptions.components, ...components },\n };\n};\n\n/\n Provider for the MarkdownRenderer component.\n \n It will provide the `renderMarkdown` function to the context, which can be used to render markdown.\n \n ```tsx\n * const content = useIntlayer('app');\n \n return (\n * <div>\n * {content.markdown} // Will be rendered with the components and options provided to the MarkdownProvider\n * </div>\n * );\n * ```\n \n @example\n * ```tsx\n * <MarkdownProvider components={{ h1: CustomHeading }}>\n * <MarkdownRenderer>\n * {markdownContent}\n * </MarkdownRenderer>\n * </MarkdownProvider>\n * ```\n */\nexport const MarkdownProvider: FC<MarkdownProviderProps> = ({\n children,\n components,\n wrapper,\n forceBlock,\n forceInline,\n preserveFrontmatter,\n tagfilter,\n renderMarkdown: customRenderFn,\n}) => {\n const baseOptions: MarkdownRendererOptions = {\n components,\n forceBlock,\n forceInline,\n wrapper,\n forceWrapper: !!wrapper,\n preserveFrontmatter,\n tagfilter,\n };\n\n // Standard internal renderer\n const defaultRenderMarkdown = (\n markdown: string \| ParsedMarkdown,\n options?: MarkdownProviderOptions,\n components?: HTMLComponents<'permissive', {}>,\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n ) => {\n const mergedOptions = mergeOptions(\n baseOptions,\n options,\n components,\n wrapper\n );\n\n return compileMarkdown(markdown, mergedOptions);\n };\n\n // Wrapper for user-provided custom renderer\n // Note: We wrap in a clean Provider to prevent infinite recursion\n const customRenderMarkdownWrapper = (\n markdown: string \| ParsedMarkdown,\n options?: MarkdownProviderOptions,\n components?: HTMLComponents<'permissive', {}>,\n wrapper?: FC<HTMLAttributes<HTMLElement>>\n ) => (\n <MarkdownContext.Provider value={undefined}>\n {customRenderFn?.(markdown, options, components, wrapper) as ReactNode}\n </MarkdownContext.Provider>\n );\n\n return (\n <MarkdownContext.Provider\n value={{\n components,\n renderMarkdown: customRenderFn\n ? customRenderMarkdownWrapper\n : defaultRenderMarkdown,\n }}\n >\n {children}\n </MarkdownContext.Provider>\n );\n};\n"],"mappings":";;;;;;;AAmDA,MAAM,kBAAkB,cACtB,MACF;;;;;;;;AASA,MAAa,2BAA2B,WAAW,eAAe;AAElE,MAAM,gBACJ,aACA,UAAmC,CAAC,GACpC,aAA+C,CAAC,GAChD,YAC4B;CAC5B,OAAO;EACL,GAAG;EACH,GAAG;EACH,YAAY,QAAQ,cAAc,YAAY;EAC9C,aAAa,QAAQ,eAAe,YAAY;EAChD,qBACE,QAAQ,uBAAuB,YAAY;EAC7C,WAAW,QAAQ,aAAa,YAAY;EAC5C,SAAS,WAAW,YAAY;EAEhC,cAAc,CAAC,EAAE,WAAW,YAAY;EACxC,YAAY;GAAE,GAAG,YAAY;GAAY,GAAG;EAAW;CACzD;AACF;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,oBAA+C,EAC1D,UACA,YACA,SACA,YACA,aACA,qBACA,WACA,gBAAgB,qBACZ;CACJ,MAAM,cAAuC;EAC3C;EACA;EACA;EACA;EACA,cAAc,CAAC,CAAC;EAChB;EACA;CACF;CAGA,MAAM,yBACJ,UACA,SACA,YACA,YACG;EACH,MAAM,gBAAgB,aACpB,aACA,SACA,YACA,OACF;EAEA,OAAO,gBAAgB,UAAU,aAAa;CAChD;CAIA,MAAM,+BACJ,UACA,SACA,YACA,YAEA,oBAAC,gBAAgB,UAAjB;EAA0B,OAAO;YAC9B,iBAAiB,UAAU,SAAS,YAAY,OAAO;CAChC;CAG5B,OACE,oBAAC,gBAAgB,UAAjB;EACE,OAAO;GACL;GACA,gBAAgB,iBACZ,8BACA;EACN;EAEC;CACuB;AAE9B"}

package/dist/esm/markdown/processor.mjs CHANGED Viewed

@@ -1,5 +1,5 @@
+import { reactRuntime } from "./runtime.mjs";
 import { compile, parseMarkdown as parseMarkdown$1, renderMarkdownAst } from "@intlayer/core/markdown";
-import { Fragment, cloneElement, createElement } from "react";
 //#region src/markdown/processor.tsx
 /**
@@ -8,15 +8,6 @@ import { Fragment, cloneElement, createElement } from "react";
 * [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
-};
-/**
 * **Step 1 of 2 — parse only.**
 * Converts a raw markdown string into a `ParsedMarkdown` AST without rendering
 * any React elements. Use this when you need to:
@@ -37,7 +28,7 @@ const DEFAULT_RUNTIME = {
 const parseMarkdown = (markdown = "", options = {}) => {
 	const { disableAutoLink, disableParsingRawHTML, enforceAtxHeadings, forceBlock, forceInline, forceWrapper, namedCodesToUnicode, components, sanitizer, slugify, wrapper, preserveFrontmatter, tagfilter } = options;
 	return parseMarkdown$1(markdown, {
-		runtime: DEFAULT_RUNTIME,
+		runtime: reactRuntime,
 		components,
 		namedCodesToUnicode,
 		sanitizer,
@@ -73,9 +64,9 @@ const compileMarkdown = (input = "", options = {}) => {
 	const { createElement: customCreateElement, disableAutoLink, disableParsingRawHTML, enforceAtxHeadings, forceBlock, forceInline, forceWrapper, namedCodesToUnicode, components, renderRule, sanitizer, slugify, wrapper, preserveFrontmatter, tagfilter } = options;
 	const ctx = {
 		runtime: customCreateElement ? {
-			...DEFAULT_RUNTIME,
+			...reactRuntime,
 			createElement: customCreateElement
-		} : DEFAULT_RUNTIME,
+		} : reactRuntime,
 		components,
 		namedCodesToUnicode,
 		sanitizer,

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

	@@ -1 +1 @@
1	- {"version":3,"file":"processor.mjs","names":["coreParseMarkdown","coreCompile","coreRenderMarkdownAst"],"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 parseMarkdown as coreParseMarkdown,\n renderMarkdownAst as coreRenderMarkdownAst,\n type MarkdownContext,\n type MarkdownOptions,\n type ~~MarkdownRuntime,\n type~~ ParsedMarkdown,\n type RenderRuleHook,\n} from '@intlayer/core/markdown';\nimport {~~\n cloneElement,\n~~ createElement~~,\n Fragment,\n type~~ JSX~~,\n type~~ ReactNode~~,\n~~} from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\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 Intermediate AST produced by `parseMarkdown`.\n * Pass this to `compileMarkdown` or `<MarkdownRenderer>` to skip re-parsing\n * when the same content is rendered multiple times.\n /\nexport type { ParsedMarkdown };\n\n/\n Step 1 of 2 — parse only.\n * Converts a raw markdown string into a `ParsedMarkdown` AST without rendering\n * any React elements. Use this when you need to:\n * - Cache the parsed result and render it several times with different options.\n * - Inspect or transform the AST before rendering.\n * - Defer the render step to a later point in the pipeline.\n \n @param markdown - The markdown source string.\n * @param options - Options that affect parsing (sanitizer, slugify, …).\n * @returns A `ParsedMarkdown` AST ready to be passed to `compileMarkdown`.\n \n @example\n * ```tsx\n * const ast = parseMarkdown('# Hello world');\n * const element = compileMarkdown(ast, { forceBlock: true });\n * ```\n /\nexport const parseMarkdown = (\n markdown: string = '',\n options: MarkdownRendererOptions = {}\n): ParsedMarkdown => {\n const {\n disableAutoLink,\n disableParsingRawHTML,\n enforceAtxHeadings,\n forceBlock,\n forceInline,\n forceWrapper,\n namedCodesToUnicode,\n components,\n sanitizer,\n slugify,\n wrapper,\n preserveFrontmatter,\n tagfilter,\n } = options;\n\n const ctx: MarkdownContext<HTMLComponents> = {\n runtime: ~~DEFAULT_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 wrapper,\n preserveFrontmatter,\n tagfilter,\n };\n\n return coreParseMarkdown(markdown, ctx, compilerOptions);\n};\n\n/\n Steps 1 + 2 — parse and render in one shot.\n * Accepts a raw markdown string or a pre-parsed `ParsedMarkdown` AST and\n * returns a React element. Use `parseMarkdown` first when you need to reuse\n * the same AST with different options.\n \n @param input - Markdown string or pre-parsed AST.\n * @param options - Rendering options (custom components, sanitizer, slugify, …).\n * @returns A React JSX element representing the rendered markdown.\n \n @example\n * ```tsx\n * const element = compileMarkdown('# Hello world', { forceBlock: true });\n * ```\n */\nexport const compileMarkdown = (\n input: string \| ParsedMarkdown = '',\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 if (typeof input === 'string') {\n return coreCompile(input, ctx, compilerOptions) as JSX.Element;\n }\n\n return coreRenderMarkdownAst(input, ctx, compilerOptions) as JSX.Element;\n};\n"],"mappings":"~~;;;;;;;;;;;;AAsHA~~,~~MAAM,kBAAmC;CACxB;CACf;CACA;CACA,iBAAiB,MAAM,UAAU;AACnC;;;;;;;;;;;;;;;;;;;AA2BA,~~MAAa,iBACX,WAAmB,IACnB,UAAmC,CAAC,MACjB;CACnB,MAAM,EACJ,iBACA,uBACA,oBACA,YACA,aACA,cACA,qBACA,YACA,WACA,SACA,SACA,qBACA,cACE;CAsBJ,OAAOA,gBAAkB,UAAU;EAnBjC,SAAS;EACT;EACA;EACW;EACX;CAemC,GAAG;EAXtC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CAGoD,CAAC;AACzD;;;;;;;;;;;;;;;;AAiBA,MAAa,mBACX,QAAiC,IACjC,UAAmC,CAAC,MACpB;CAChB,MAAM,EACJ,eAAe,qBACf,iBACA,uBACA,oBACA,YACA,aACA,cACA,qBACA,YACA,YACA,WACA,SACA,SACA,qBACA,cACE;CAMJ,MAAM,MAAuC;EAC3C,SALc,sBACZ;GAAE,GAAG;~~GAAiB~~,eAAe;EAA2B,~~IAChE~~;EAIF;EACA;EACW;EACX;CACF;CAEA,MAAM,kBAAmC;EACvC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACF;CAEA,IAAI,OAAO,UAAU,UACnB,OAAOC,QAAY,OAAO,KAAK,eAAe;CAGhD,OAAOC,kBAAsB,OAAO,KAAK,eAAe;AAC1D"}
1	+ {"version":3,"file":"processor.mjs","names":["coreParseMarkdown","coreCompile","coreRenderMarkdownAst"],"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 parseMarkdown as coreParseMarkdown,\n renderMarkdownAst as coreRenderMarkdownAst,\n type MarkdownContext,\n type MarkdownOptions,\n type ParsedMarkdown,\n type RenderRuleHook,\n} from '@intlayer/core/markdown';\nimport type { createElement, JSX, ReactNode } from 'react';\nimport type { HTMLComponents } from '../html/HTMLComponentTypes';\nimport { reactRuntime } from './runtime';\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 /\n\n/\n Intermediate AST produced by `parseMarkdown`.\n * Pass this to `compileMarkdown` or `<MarkdownRenderer>` to skip re-parsing\n * when the same content is rendered multiple times.\n /\nexport type { ParsedMarkdown };\n\n/\n Step 1 of 2 — parse only.\n * Converts a raw markdown string into a `ParsedMarkdown` AST without rendering\n * any React elements. Use this when you need to:\n * - Cache the parsed result and render it several times with different options.\n * - Inspect or transform the AST before rendering.\n * - Defer the render step to a later point in the pipeline.\n \n @param markdown - The markdown source string.\n * @param options - Options that affect parsing (sanitizer, slugify, …).\n * @returns A `ParsedMarkdown` AST ready to be passed to `compileMarkdown`.\n \n @example\n * ```tsx\n * const ast = parseMarkdown('# Hello world');\n * const element = compileMarkdown(ast, { forceBlock: true });\n * ```\n /\nexport const parseMarkdown = (\n markdown: string = '',\n options: MarkdownRendererOptions = {}\n): ParsedMarkdown => {\n const {\n disableAutoLink,\n disableParsingRawHTML,\n enforceAtxHeadings,\n forceBlock,\n forceInline,\n forceWrapper,\n namedCodesToUnicode,\n components,\n sanitizer,\n slugify,\n wrapper,\n preserveFrontmatter,\n tagfilter,\n } = options;\n\n const ctx: MarkdownContext<HTMLComponents> = {\n runtime: reactRuntime,\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 wrapper,\n preserveFrontmatter,\n tagfilter,\n };\n\n return coreParseMarkdown(markdown, ctx, compilerOptions);\n};\n\n/\n Steps 1 + 2 — parse and render in one shot.\n * Accepts a raw markdown string or a pre-parsed `ParsedMarkdown` AST and\n * returns a React element. Use `parseMarkdown` first when you need to reuse\n * the same AST with different options.\n \n @param input - Markdown string or pre-parsed AST.\n * @param options - Rendering options (custom components, sanitizer, slugify, …).\n * @returns A React JSX element representing the rendered markdown.\n \n @example\n * ```tsx\n * const element = compileMarkdown('# Hello world', { forceBlock: true });\n * ```\n */\nexport const compileMarkdown = (\n input: string \| ParsedMarkdown = '',\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 ? { ...reactRuntime, createElement: customCreateElement as any }\n : reactRuntime;\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 if (typeof input === 'string') {\n return coreCompile(input, ctx, compilerOptions) as JSX.Element;\n }\n\n return coreRenderMarkdownAst(input, ctx, compilerOptions) as JSX.Element;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA0IA,MAAa,iBACX,WAAmB,IACnB,UAAmC,CAAC,MACjB;CACnB,MAAM,EACJ,iBACA,uBACA,oBACA,YACA,aACA,cACA,qBACA,YACA,WACA,SACA,SACA,qBACA,cACE;CAsBJ,OAAOA,gBAAkB,UAAU;EAnBjC,SAAS;EACT;EACA;EACW;EACX;CAemC,GAAG;EAXtC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CAGoD,CAAC;AACzD;;;;;;;;;;;;;;;;AAiBA,MAAa,mBACX,QAAiC,IACjC,UAAmC,CAAC,MACpB;CAChB,MAAM,EACJ,eAAe,qBACf,iBACA,uBACA,oBACA,YACA,aACA,cACA,qBACA,YACA,YACA,WACA,SACA,SACA,qBACA,cACE;CAMJ,MAAM,MAAuC;EAC3C,SALc,sBACZ;GAAE,GAAG;GAAc,eAAe;EAA2B,IAC7D;EAIF;EACA;EACW;EACX;CACF;CAEA,MAAM,kBAAmC;EACvC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACF;CAEA,IAAI,OAAO,UAAU,UACnB,OAAOC,QAAY,OAAO,KAAK,eAAe;CAGhD,OAAOC,kBAAsB,OAAO,KAAK,eAAe;AAC1D"}

package/dist/esm/markdown/runtime.mjs CHANGED Viewed

@@ -5,15 +5,43 @@ import { Fragment, cloneElement, createElement } from "react";
 * React-specific runtime for the markdown processor.
 * Implements the MarkdownRuntime interface using React's primitives.
 */
+let REACT_ELEMENT_TYPE;
+try {
+	const sample = createElement("div");
+	REACT_ELEMENT_TYPE = sample && typeof sample === "object" && "$$typeof" in sample && typeof sample.$$typeof === "symbol" ? sample.$$typeof : Symbol.for("react.transitional.element");
+} catch {
+	REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element");
+}
+/**
+* React-specific runtime for the markdown processor.
+* Implements the MarkdownRuntime interface using React's primitives.
+*/
 const reactRuntime = {
 	/**
 	* Creates a React element.
 	* Handles the conversion of props and children to React format.
 	*/
 	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);
+		let key = null;
+		const finalProps = props || {};
+		if (props && props.key != null) {
+			key = String(props.key);
+			finalProps.key = void 0;
+		}
+		const childCount = children.length;
+		if (childCount === 1) finalProps.children = children[0];
+		else if (childCount > 1) finalProps.children = children;
+		return {
+			$$typeof: REACT_ELEMENT_TYPE,
+			type,
+			key,
+			ref: null,
+			props: finalProps,
+			_owner: null,
+			_store: {},
+			_debugStack: null,
+			_debugTask: null
+		};
 	},
 	/**
 	* Clones a React element with new props.

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

	@@ -1 +1 @@
1	- {"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"],"mappings":";;;;;;;AAaA,MAAa,eAAgC;;;;;CAK3C,gBACE,MACA,OACA,GAAG,aACW;~~EAGd~~,IAAI,SAAS,~~WAAW~~,~~GACtB~~,OAAO,~~cAAc~~,MAAM,~~KAAK~~;~~EAElC~~,~~IAAI~~,SAAS,WAAW,~~GACtB~~,~~OAAO~~,~~cAAc~~,~~MAAM~~,~~OAAO~~,~~SAAS~~,~~EAAE~~;~~EAE/C~~,OAAO,~~cAAc~~,~~MAAM~~,OAAO,~~GAAG~~,QAAQ;~~CAC/C~~;;;;CAKA,eACE,SACA,OACA,GAAG,aACW;EACd,IAAI,SAAS,WAAW,GACtB,OAAO,aAAa,SAAyB,KAAK;EAEpD,OAAO,aAAa,SAAyB,OAAO,GAAG,QAAQ;CACjE;;;;CAKA;;;;;;;CAQA,iBACE,MACA,UACwB;EAIxB,OAAO;CACT;AACF;;;;;AAMA,MAAa,sBACX,UAMI,CAAC,MACe;CACpB,MAAM,EAAE,oBAAoB;CAE5B,IAAI,iBACF,OAAO;EACL,GAAG;EACH,gBACE,MACA,OACA,GAAG,aACW;GACd,OAAO,gBAAgB,MAAM,OAAO,QAAQ;EAC9C;CACF;CAGF,OAAO;AACT"}
1	+ {"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 /\nlet REACT_ELEMENT_TYPE: symbol;\ntry {\n const sample = createElement('div');\n REACT_ELEMENT_TYPE =\n sample &&\n typeof sample === 'object' &&\n '$$typeof' in sample &&\n typeof sample.$$typeof === 'symbol'\n ? (sample.$$typeof as symbol)\n : Symbol.for('react.transitional.element');\n} catch {\n REACT_ELEMENT_TYPE = Symbol.for('react.transitional.element');\n}\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 let key: string \| null = null;\n const finalProps: any = props \|\| {};\n\n if (props && props.key != null) {\n key = String(props.key);\n finalProps.key = undefined;\n }\n\n const childCount = children.length;\n if (childCount === 1) {\n finalProps.children = children[0];\n } else if (childCount > 1) {\n finalProps.children = children;\n }\n\n return {\n $$typeof: REACT_ELEMENT_TYPE,\n type,\n key,\n ref: null,\n props: finalProps,\n _owner: null,\n _store: {},\n _debugStack: null,\n _debugTask: null,\n } as unknown as ReactNode;\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"],"mappings":";;;;;;;AAaA,IAAI;AACJ,IAAI;CACF,MAAM,SAAS,cAAc,KAAK;CAClC,qBACE,UACA,OAAO,WAAW,YAClB,cAAc,UACd,OAAO,OAAO,aAAa,WACtB,OAAO,WACR,OAAO,IAAI,4BAA4B;AAC/C,QAAQ;CACN,qBAAqB,OAAO,IAAI,4BAA4B;AAC9D;;;;;AAMA,MAAa,eAAgC;;;;;CAK3C,gBACE,MACA,OACA,GAAG,aACW;EACd,IAAI,MAAqB;EACzB,MAAM,aAAkB,SAAS,CAAC;EAElC,IAAI,SAAS,MAAM,OAAO,MAAM;GAC9B,MAAM,OAAO,MAAM,GAAG;GACtB,WAAW,MAAM;EACnB;EAEA,MAAM,aAAa,SAAS;EAC5B,IAAI,eAAe,GACjB,WAAW,WAAW,SAAS;OAC1B,IAAI,aAAa,GACtB,WAAW,WAAW;EAGxB,OAAO;GACL,UAAU;GACV;GACA;GACA,KAAK;GACL,OAAO;GACP,QAAQ;GACR,QAAQ,CAAC;GACT,aAAa;GACb,YAAY;EACd;CACF;;;;CAKA,eACE,SACA,OACA,GAAG,aACW;EACd,IAAI,SAAS,WAAW,GACtB,OAAO,aAAa,SAAyB,KAAK;EAEpD,OAAO,aAAa,SAAyB,OAAO,GAAG,QAAQ;CACjE;;;;CAKA;;;;;;;CAQA,iBACE,MACA,UACwB;EAIxB,OAAO;CACT;AACF;;;;;AAMA,MAAa,sBACX,UAMI,CAAC,MACe;CACpB,MAAM,EAAE,oBAAoB;CAE5B,IAAI,iBACF,OAAO;EACL,GAAG;EACH,gBACE,MACA,OACA,GAAG,aACW;GACd,OAAO,gBAAgB,MAAM,OAAO,QAAQ;EAC9C;CACF;CAGF,OAAO;AACT"}

package/dist/types/IntlayerNode.d.ts CHANGED Viewed

@@ -2,7 +2,7 @@ import { NodeProps } from "@intlayer/core/interpreter";
 import { ResolvedEditor } from "@intlayer/types/module_augmentation";
 import { PropsWithChildren, ReactNode } from "react";
 //#region src/IntlayerNode.d.ts
-type IntlayerNode<T = NodeProps['children'], AdditionalProps = Record<string, never>> = ResolvedEditor<T, ReactNode> & {
+export type IntlayerNode<T = NodeProps['children'], AdditionalProps = Record<string, never>> = ResolvedEditor<T, ReactNode> & {
   value: T;
 } & AdditionalProps & T;
 type RenderIntlayerNodeProps<T> = PropsWithChildren<{
@@ -12,7 +12,6 @@ type RenderIntlayerNodeProps<T> = PropsWithChildren<{
     [key: string]: any;
   };
 }>;
-declare const renderIntlayerNode: <T>({ children, value, additionalProps }: RenderIntlayerNodeProps<T>) => IntlayerNode<T>;
+export declare const renderIntlayerNode: <T>({ children, value, additionalProps }: RenderIntlayerNodeProps<T>) => IntlayerNode<T>;
 //#endregion
-export { IntlayerNode, renderIntlayerNode };
 //# sourceMappingURL=IntlayerNode.d.ts.map

package/dist/types/IntlayerNode.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"IntlayerNode.d.ts","names":[],"sources":["../../src/IntlayerNode.tsx"],"mappings":";;;;~~KASY~~,aACV,IAAI,uBACJ,kBAAkB,yBAChB,eAAe,GAAG;EACpB,OAAO;IACL,kBACF;KAEG,wBAAwB,KAAK;EAChC,OAAO;EACP,UAAU;EACV;KAAqB;;;~~cAGV~~,qBACX,KAAC,UAAA,OAAA,mBAKA,wBAAwB,OAAK,aAAa"}
1	+ {"version":3,"file":"IntlayerNode.d.ts","names":[],"sources":["../../src/IntlayerNode.tsx"],"mappings":";;;;YASY,aACV,IAAI,uBACJ,kBAAkB,yBAChB,eAAe,GAAG;EACpB,OAAO;IACL,kBACF;KAEG,wBAAwB,KAAK;EAChC,OAAO;EACP,UAAU;EACV;KAAqB;;;qBAGV,qBACX,KAAC,UAAA,OAAA,mBAKA,wBAAwB,OAAK,aAAa"}

package/dist/types/UI/ContentSelector.d.ts CHANGED Viewed

@@ -8,7 +8,6 @@ type ContentSelectorProps = {
   pressDuration?: number;
   isSelecting?: boolean;
 } & Omit<HTMLAttributes<HTMLDivElement>, 'content'>;
-declare const ContentSelector: FC<ContentSelectorProps>;
+export declare const ContentSelector: FC<ContentSelectorProps>;
 //#endregion
-export { ContentSelector };
 //# sourceMappingURL=ContentSelector.d.ts.map

package/dist/types/UI/ContentSelector.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"ContentSelector.d.ts","names":[],"sources":["../../../src/UI/ContentSelector.tsx"],"mappings":";;KAcK;EACH;EACA;EACA;EACA;EACA;EACA;IACE,KAAK,eAAe;~~cAEX~~,iBAAiB,GAAG"}
1	+ {"version":3,"file":"ContentSelector.d.ts","names":[],"sources":["../../../src/UI/ContentSelector.tsx"],"mappings":";;KAcK;EACH;EACA;EACA;EACA;EACA;EACA;IACE,KAAK,eAAe;qBAEX,iBAAiB,GAAG"}

package/dist/types/analytics/AnalyticsProvider.d.ts CHANGED Viewed

@@ -4,7 +4,6 @@ import { FC, PropsWithChildren } from "react";
  * Runs {@link useAnalytics} and renders its children unchanged. Mounted inside
  * {@link IntlayerProvider} alongside `EditorProvider`.
  */
-declare const AnalyticsProvider: FC<PropsWithChildren>;
+export declare const AnalyticsProvider: FC<PropsWithChildren>;
 //#endregion
-export { AnalyticsProvider };
 //# sourceMappingURL=AnalyticsProvider.d.ts.map

package/dist/types/analytics/AnalyticsProvider.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"AnalyticsProvider.d.ts","names":[],"sources":["../../../src/analytics/AnalyticsProvider.tsx"],"mappings":";;;;;;~~cAOa~~,mBAAmB,GAAG"}
1	+ {"version":3,"file":"AnalyticsProvider.d.ts","names":[],"sources":["../../../src/analytics/AnalyticsProvider.tsx"],"mappings":";;;;;;qBAOa,mBAAmB,GAAG"}

package/dist/types/analytics/exposureSink.d.ts CHANGED Viewed

@@ -5,28 +5,27 @@ import { KeyPath } from "@intlayer/types/keyPath";
  * only) so the interpreter hot path in `plugins.tsx` never statically imports
  * `@intlayer/analytics` — the package stays optional and tree-shakeable.
  */
-type ExposureInput = {
+export type ExposureInput = {
   dictionaryKey: string;
   keyPath: KeyPath[];
   locale?: string;
   nodeType?: string;
 };
 /** Consumer of exposure reports, installed by `useAnalytics` after init. */
-type ExposureSink = (input: ExposureInput) => void;
+export type ExposureSink = (input: ExposureInput) => void;
 /**
  * Installs (or clears) the exposure sink. `useAnalytics` sets this once the
  * analytics client has loaded, and clears it on unmount.
  *
  * @param next - The sink to install, or `null` to clear.
  */
-declare const setExposureSink: (next: ExposureSink | null) => void;
+export declare const setExposureSink: (next: ExposureSink | null) => void;
 /**
  * Forwards a content exposure to the installed sink. A cheap null-check when
  * analytics is not running, so it is safe to call from every node resolution.
  *
  * @param input - The node metadata to report.
  */
-declare const reportExposure: (input: ExposureInput) => void;
+export declare const reportExposure: (input: ExposureInput) => void;
 //#endregion
-export { ExposureInput, ExposureSink, reportExposure, setExposureSink };
 //# sourceMappingURL=exposureSink.d.ts.map

package/dist/types/analytics/exposureSink.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"exposureSink.d.ts","names":[],"sources":["../../../src/analytics/exposureSink.ts"],"mappings":";;;;;;;~~KAOY~~;EACV;EACA,SAAS;EACT;EACA;;;~~KAIU~~,gBAAgB,OAAO;;;;;;;~~cAUtB~~,kBAAe,MAAU;;;;;;;~~cAUzB~~,iBAAc,OAAW"}
1	+ {"version":3,"file":"exposureSink.d.ts","names":[],"sources":["../../../src/analytics/exposureSink.ts"],"mappings":";;;;;;;YAOY;EACV;EACA,SAAS;EACT;EACA;;;YAIU,gBAAgB,OAAO;;;;;;;qBAUtB,kBAAe,MAAU;;;;;;;qBAUzB,iBAAc,OAAW"}

package/dist/types/analytics/useAnalytics.d.ts CHANGED Viewed

@@ -9,7 +9,6 @@
  * `@intlayer/analytics`, pay nothing — the whole body is guarded by
  * `INTLAYER_ANALYTICS_ENABLED` and dead-code-eliminated at build time.
  */
-declare const useAnalytics: () => void;
+export declare const useAnalytics: () => void;
 //#endregion
-export { useAnalytics };
 //# sourceMappingURL=useAnalytics.d.ts.map

package/dist/types/analytics/useAnalytics.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"useAnalytics.d.ts","names":[],"sources":["../../../src/analytics/useAnalytics.tsx"],"mappings":";;;;;;;;;;;~~cAkBa~~"}
1	+ {"version":3,"file":"useAnalytics.d.ts","names":[],"sources":["../../../src/analytics/useAnalytics.tsx"],"mappings":";;;;;;;;;;;qBAkBa"}

package/dist/types/analytics/useConversion.d.ts CHANGED Viewed

@@ -2,7 +2,7 @@
 /**
  * Parameters describing a conversion to record.
  */
-type ConversionParams = {
+export type ConversionParams = {
   /** The experiment this conversion is attributed to. */
   experimentKey: string;
   /** The variant the session was assigned. */
@@ -25,7 +25,6 @@ type ConversionParams = {
  * })}>Get started</button>
  * ```
  */
-declare const useConversion: () => (params: ConversionParams) => void;
+export declare const useConversion: () => (params: ConversionParams) => void;
 //#endregion
-export { ConversionParams, useConversion };
 //# sourceMappingURL=useConversion.d.ts.map

package/dist/types/analytics/useConversion.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"useConversion.d.ts","names":[],"sources":["../../../src/analytics/useConversion.tsx"],"mappings":";;;;~~KAQY~~;;EAEV;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;~~cAgBW~~,sBAAa,QACI"}
1	+ {"version":3,"file":"useConversion.d.ts","names":[],"sources":["../../../src/analytics/useConversion.tsx"],"mappings":";;;;YAQY;;EAEV;;EAEA;;EAEA;;EAEA;;;;;;;;;;;;;;;qBAgBW,sBAAa,QACI"}

package/dist/types/analytics/useExperiment.d.ts CHANGED Viewed

@@ -2,7 +2,7 @@
 /**
  * The state of an A/B experiment for the current session.
  */
-type ExperimentState = {
+export type ExperimentState = {
   /**
    * The variant assigned to this session. Until assignment resolves (and on
    * the server, or when analytics is disabled), this is the first variant —
@@ -35,7 +35,6 @@ type ExperimentState = {
  * const content = useIntlayer(variant === 'b' ? 'hero-b' : 'hero');
  * ```
  */
-declare const useExperiment: (experimentKey: string, variants: string[], weights?: number[]) => ExperimentState;
+export declare const useExperiment: (experimentKey: string, variants: string[], weights?: number[]) => ExperimentState;
 //#endregion
-export { ExperimentState, useExperiment };
 //# sourceMappingURL=useExperiment.d.ts.map

package/dist/types/analytics/useExperiment.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"useExperiment.d.ts","names":[],"sources":["../../../src/analytics/useExperiment.tsx"],"mappings":";;;;~~KAQY~~;;;;;;EAMV;;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;~~cAsBW~~,gBAAa,uBACH,oBACH,uBAEjB"}
1	+ {"version":3,"file":"useExperiment.d.ts","names":[],"sources":["../../../src/analytics/useExperiment.tsx"],"mappings":";;;;YAQY;;;;;;EAMV;;;;;;EAMA;;;;;;;;;;;;;;;;;;;;;qBAsBW,gBAAa,uBACH,oBACH,uBAEjB"}

package/dist/types/client/IntlayerProvider.d.ts CHANGED Viewed

@@ -15,17 +15,17 @@ type IntlayerValue = {
 /**
  * Context that stores the current locale on the client side.
  */
-declare const IntlayerClientContext: import("react").Context<IntlayerValue>;
+export declare const IntlayerClientContext: import("react").Context<IntlayerValue>;
 /**
  * Hook that provides the current Intlayer client context.
  *
  * @returns The current Intlayer context values.
  */
-declare const useIntlayerContext: () => {};
+export declare const useIntlayerContext: () => {};
 /**
  * Props for the IntlayerProvider component.
  */
-type IntlayerProviderProps = PropsWithChildren<{
+export type IntlayerProviderProps = PropsWithChildren<{
   /**
    * The locale to use. If not provided, it will be detected from storage or configuration.
    */
@@ -74,7 +74,7 @@ type IntlayerProviderProps = PropsWithChildren<{
  * @param props - The provider props.
  * @returns The provider component.
  */
-declare const IntlayerProviderContent: FC<IntlayerProviderProps>;
+export declare const IntlayerProviderContent: FC<IntlayerProviderProps>;
 /**
  * Main provider for Intlayer in React applications.
  *
@@ -95,7 +95,6 @@ declare const IntlayerProviderContent: FC<IntlayerProviderProps>;
  * );
  * ```
  */
-declare const IntlayerProvider: FC<IntlayerProviderProps>;
+export declare const IntlayerProvider: FC<IntlayerProviderProps>;
 //#endregion
-export { IntlayerClientContext, IntlayerProvider, IntlayerProviderContent, IntlayerProviderProps, useIntlayerContext };
 //# sourceMappingURL=IntlayerProvider.d.ts.map

package/dist/types/client/IntlayerProvider.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"IntlayerProvider.d.ts","names":[],"sources":["../../../src/client/IntlayerProvider.tsx"],"mappings":";;;KAqBK;EACH,QAAQ;EACR,YAAY,WAAW;;;;;EAKvB,UAAU;EACV;EACA;;;;;~~cAMW~~,uCAAqB,QAAA;;;;;;~~cAWrB~~;;;;~~KAKD~~,wBAAwB;;;;EAIlC,SAAS;;;;;;;;;;;;;;;;;;;EAmBT,UAAU;;;;EAIV,gBAAgB;;;;EAIhB,aAAa,QAAQ;;;;EAIrB;;;;EAIA;;;;;;;;;;~~cAWW~~,yBAAyB,GAAG;;;;;;;;;;;;;;;;;;;;;~~cAgF5B~~,kBAAkB,GAAG"}
1	+ {"version":3,"file":"IntlayerProvider.d.ts","names":[],"sources":["../../../src/client/IntlayerProvider.tsx"],"mappings":";;;KAqBK;EACH,QAAQ;EACR,YAAY,WAAW;;;;;EAKvB,UAAU;EACV;EACA;;;;;qBAMW,uCAAqB,QAAA;;;;;;qBAWrB;;;;YAKD,wBAAwB;;;;EAIlC,SAAS;;;;;;;;;;;;;;;;;;;EAmBT,UAAU;;;;EAIV,gBAAgB;;;;EAIhB,aAAa,QAAQ;;;;EAIrB;;;;EAIA;;;;;;;;;;qBAWW,yBAAyB,GAAG;;;;;;;;;;;;;;;;;;;;;qBAgF5B,kBAAkB,GAAG"}

package/dist/types/client/format/useCompact.d.ts CHANGED Viewed

@@ -1,4 +1,3 @@
-import { LocalesValues } from "../../intlayer/dist/types/index.js";
 //#region src/client/format/useCompact.d.ts
 /**
  * React client hook that provides a compact number formatter
@@ -10,9 +9,8 @@ import { LocalesValues } from "../../intlayer/dist/types/index.js";
  * formatCompact(1500); // "1.5K"
  * ```
  */
-declare const useCompact: () => (value: string | number, options?: Intl.NumberFormatOptions & {
-  locale?: LocalesValues;
+export declare const useCompact: () => (value: string | number, options?: Intl.NumberFormatOptions & {
+  locale?: import("@intlayer/types").LocalesValues;
 }) => string;
 //#endregion
-export { useCompact };
 //# sourceMappingURL=useCompact.d.ts.map