react-intlayer 9.4.3 → 9.4.4

package/dist/types/client/useLocale.d.ts

@@ -1,10 +1,10 @@
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/client/useLocale.d.ts
-type UseLocaleProps = {
+export type UseLocaleProps = {
   isCookieEnabled?: boolean;
   onLocaleChange?: (locale: DeclaredLocales) => void;
 };
-type UseLocaleResult = {
+export type UseLocaleResult = {
   locale: DeclaredLocales;
   defaultLocale: DeclaredLocales;
   availableLocales: DeclaredLocales[];
@@ -33,7 +33,6 @@ type UseLocaleResult = {
  * };
  * ```
  */
-declare const useLocale: ({ isCookieEnabled, onLocaleChange }?: UseLocaleProps) => UseLocaleResult;
+export declare const useLocale: ({ isCookieEnabled, onLocaleChange }?: UseLocaleProps) => UseLocaleResult;
 //#endregion
-export { UseLocaleProps, UseLocaleResult, useLocale };
 //# sourceMappingURL=useLocale.d.ts.map

package/dist/types/client/useLocale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/client/useLocale.ts"],"mappings":";;KAWY;EACV;EACA,kBAAkB,QAAQ;;KAGhB;EACV,QAAQ;EACR,eAAe;EACf,kBAAkB;EAClB,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;cA0BT,cAAS,iBAAA,mBAGnB,mBAAsB"}
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/client/useLocale.ts"],"mappings":";;YAWY;EACV;EACA,kBAAkB,QAAQ;;YAGhB;EACV,QAAQ;EACR,eAAe;EACf,kBAAkB;EAClB,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;qBA0BT,cAAS,iBAAA,mBAGnB,mBAAsB"}

package/dist/types/client/useLocaleBase.d.ts

@@ -1,14 +1,12 @@
-import { LocalesValues } from "../intlayer/dist/types/index.js";
 //#region src/client/useLocaleBase.d.ts
 /**
  * On the client side, hook to get the current locale and all related fields
  */
-declare const useLocaleBase: () => {
-  locale: LocalesValues;
+export declare const useLocaleBase: () => {
+  locale: import("@intlayer/types").LocalesValues;
   defaultLocale: any;
   availableLocales: any;
-  setLocale: (newLocale: LocalesValues) => void;
+  setLocale: (newLocale: import("@intlayer/types").LocalesValues) => void;
 };
 //#endregion
-export { useLocaleBase };
 //# sourceMappingURL=useLocaleBase.d.ts.map

package/dist/types/client/useLocaleBase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLocaleBase.d.ts","names":[],"sources":["../../../src/client/useLocaleBase.ts"],"mappings":";;;;;cAWa;UAAA;;;yBAAA"}
+{"version":3,"file":"useLocaleBase.d.ts","names":[],"sources":["../../../src/client/useLocaleBase.ts"],"mappings":";;;;qBAWa"}

package/dist/types/client/useLocaleStorage.d.ts

@@ -1,4 +1,3 @@
-import { Locale } from "../intlayer/dist/types/index.js";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/client/useLocaleStorage.d.ts
 /**
@@ -7,28 +6,28 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
 /**
  * Get the locale cookie
  */
-declare const localeInStorage: Locale;
+export declare const localeInStorage: import("@intlayer/types").Locale;
 /**
  * @deprecated Use localeInStorage instead
  *
  * Get the locale cookie
  */
-declare const localeCookie: Locale;
+export declare const localeCookie: import("@intlayer/types").Locale;
 /**
  * Set the locale cookie
  */
-declare const setLocaleInStorage: (locale: LocalesValues, isCookieEnabled?: boolean) => void;
+export declare const setLocaleInStorage: (locale: LocalesValues, isCookieEnabled?: boolean) => void;
 /**
  * @deprecated Use setLocaleInStorage instead
  *
  * Set the locale cookie
  */
-declare const setLocaleCookie: typeof setLocaleInStorage;
+export declare const setLocaleCookie: typeof setLocaleInStorage;
 /**
  * Hook that provides the locale cookie and a function to set it
  */
-declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
-  getLocale: () => Locale;
+export declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
+  getLocale: () => import("@intlayer/types").Locale;
   setLocale: (locale: LocalesValues) => void;
 };
 /**
@@ -38,7 +37,6 @@ declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
  *
  * Hook that provides the locale cookie and a function to set it
  */
-declare const useLocaleCookie: typeof useLocaleStorage;
+export declare const useLocaleCookie: typeof useLocaleStorage;
 //#endregion
-export { localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useLocaleCookie, useLocaleStorage };
 //# sourceMappingURL=useLocaleStorage.d.ts.map

package/dist/types/client/useLocaleStorage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLocaleStorage.d.ts","names":[],"sources":["../../../src/client/useLocaleStorage.ts"],"mappings":";;;;;;;;;cAea,iBAAA;;;;;;cAMA,cAAA;;;;cAKA,qBAAkB,QACrB,eAAa;;;;;;cAaV,wBAAe;;;;cAKf,mBAAgB;mBAAhB;sBAAA;;;;;;;;;cAiBA,wBAAe"}
+{"version":3,"file":"useLocaleStorage.d.ts","names":[],"sources":["../../../src/client/useLocaleStorage.ts"],"mappings":";;;;;;;;qBAea,2CAAe;;;;;;qBAMf,wCAAY;;;;qBAKZ,qBAAkB,QACrB,eAAa;;;;;;qBAaV,wBAAe;;;;qBAKf,mBAAgB;;sBAAhB;;;;;;;;;qBAiBA,wBAAe"}

package/dist/types/client/usePathname.d.ts

@@ -17,7 +17,6 @@
  * };
  * ```
  */
-declare const usePathname: () => string;
+export declare const usePathname: () => string;
 //#endregion
-export { usePathname };
 //# sourceMappingURL=usePathname.d.ts.map

package/dist/types/client/usePathname.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePathname.d.ts","names":[],"sources":["../../../src/client/usePathname.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAuBa"}
+{"version":3,"file":"usePathname.d.ts","names":[],"sources":["../../../src/client/usePathname.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAuBa"}

package/dist/types/client/useRewriteURL.d.ts

@@ -17,7 +17,6 @@
  * };
  * ```
  */
-declare const useRewriteURL: () => void;
+export declare const useRewriteURL: () => void;
 //#endregion
-export { useRewriteURL };
 //# sourceMappingURL=useRewriteURL.d.ts.map

package/dist/types/client/useRewriteURL.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useRewriteURL.d.ts","names":[],"sources":["../../../src/client/useRewriteURL.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cA0Ba"}
+{"version":3,"file":"useRewriteURL.d.ts","names":[],"sources":["../../../src/client/useRewriteURL.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBA0Ba"}

package/dist/types/client/useTraduction.d.ts

@@ -21,7 +21,6 @@ import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
  * - this function will require each locale to be defined if defined in the project configuration.
  * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.
  */
-declare const useTranslation: <const Content = string>(languageContent: StrictModeLocaleMap<Content>) => Content;
+export declare const useTranslation: <const Content = string>(languageContent: StrictModeLocaleMap<Content>) => Content;
 //#endregion
-export { useTranslation };
 //# sourceMappingURL=useTraduction.d.ts.map

package/dist/types/client/useTraduction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTraduction.d.ts","names":[],"sources":["../../../src/client/useTraduction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cA0Ba,uBAAwB,kBAAgB,iBAClC,oBAAoB,aACpC"}
+{"version":3,"file":"useTraduction.d.ts","names":[],"sources":["../../../src/client/useTraduction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;qBA0Ba,uBAAwB,kBAAgB,iBAClC,oBAAoB,aACpC"}

package/dist/types/editor/ContentSelector.d.ts

@@ -1,8 +1,7 @@
 import { NodeProps } from "@intlayer/core/interpreter";
 import { FC, HTMLAttributes } from "react";
 //#region src/editor/ContentSelector.d.ts
-type ContentSelectorProps = NodeProps & Omit<HTMLAttributes<HTMLDivElement>, 'children'>;
-declare const ContentSelector: FC<ContentSelectorProps>;
+export type ContentSelectorProps = NodeProps & Omit<HTMLAttributes<HTMLDivElement>, 'children'>;
+export declare const ContentSelector: FC<ContentSelectorProps>;
 //#endregion
-export { ContentSelector, ContentSelectorProps };
 //# sourceMappingURL=ContentSelector.d.ts.map

package/dist/types/editor/ContentSelector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ContentSelector.d.ts","names":[],"sources":["../../../src/editor/ContentSelector.tsx"],"mappings":";;;KAMY,uBAAuB,YACjC,KAAK,eAAe;cAET,iBAAiB,GAAG"}
+{"version":3,"file":"ContentSelector.d.ts","names":[],"sources":["../../../src/editor/ContentSelector.tsx"],"mappings":";;;YAMY,uBAAuB,YACjC,KAAK,eAAe;qBAET,iBAAiB,GAAG"}

package/dist/types/editor/EditorProvider.d.ts

@@ -1,6 +1,5 @@
 import { FC, PropsWithChildren } from "react";
 //#region src/editor/EditorProvider.d.ts
-declare const EditorProvider: FC<PropsWithChildren>;
+export declare const EditorProvider: FC<PropsWithChildren>;
 //#endregion
-export { EditorProvider };
 //# sourceMappingURL=EditorProvider.d.ts.map

package/dist/types/editor/EditorProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EditorProvider.d.ts","names":[],"sources":["../../../src/editor/EditorProvider.tsx"],"mappings":";;cAGa,gBAAgB,GAAG"}
+{"version":3,"file":"EditorProvider.d.ts","names":[],"sources":["../../../src/editor/EditorProvider.tsx"],"mappings":";;qBAGa,gBAAgB,GAAG"}

package/dist/types/editor/useEditor.d.ts

@@ -4,7 +4,6 @@
  * Syncs the current locale from the Intlayer context into the editor manager so
  * the editor always knows which locale the app is displaying.
  */
-declare const useEditor: () => void;
+export declare const useEditor: () => void;
 //#endregion
-export { useEditor };
 //# sourceMappingURL=useEditor.d.ts.map

package/dist/types/editor/useEditor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useEditor.d.ts","names":[],"sources":["../../../src/editor/useEditor.tsx"],"mappings":";;;;;;cAaa"}
+{"version":3,"file":"useEditor.d.ts","names":[],"sources":["../../../src/editor/useEditor.tsx"],"mappings":";;;;;;qBAaa"}

package/dist/types/getDictionary.d.ts

@@ -7,7 +7,6 @@ import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup, Resol
  * content for the given locale or selector (`{ item }`, `{ variant }`,
  * optionally combined with `locale`).
  */
-declare const getDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => DeepTransformContent<ResolveQualifiedDictionaryContent<T, A>, ExtractSelectorLocale<A>>;
+export declare const getDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => DeepTransformContent<ResolveQualifiedDictionaryContent<T, A>, ExtractSelectorLocale<A>>;
 //#endregion
-export { getDictionary };
 //# sourceMappingURL=getDictionary.d.ts.map

package/dist/types/getDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getDictionary.d.ts","names":[],"sources":["../../src/getDictionary.ts"],"mappings":";;;;;;;;;cAmBa,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,MAClB,qBACD,kCAAkC,GAAG,IACrC,sBAAsB"}
+{"version":3,"file":"getDictionary.d.ts","names":[],"sources":["../../src/getDictionary.ts"],"mappings":";;;;;;;;;qBAmBa,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,MAClB,qBACD,kCAAkC,GAAG,IACrC,sBAAsB"}

package/dist/types/getIntlayer.d.ts

@@ -6,7 +6,6 @@ import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, DictionarySe
  * locale or selector (`{ item }`, `{ variant }`,
  * optionally combined with `locale`).
  */
-declare const getIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => DeepTransformContent<DictionaryRegistryResult<T, A>, ExtractSelectorLocale<A>>;
+export declare const getIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => DeepTransformContent<DictionaryRegistryResult<T, A>, ExtractSelectorLocale<A>>;
 //#endregion
-export { getIntlayer };
 //# sourceMappingURL=getIntlayer.d.ts.map

package/dist/types/getIntlayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getIntlayer.d.ts","names":[],"sources":["../../src/getIntlayer.ts"],"mappings":";;;;;;;;cAgBa,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,MAClB,qBACD,yBAAyB,GAAG,IAC5B,sBAAsB"}
+{"version":3,"file":"getIntlayer.d.ts","names":[],"sources":["../../src/getIntlayer.ts"],"mappings":";;;;;;;;qBAgBa,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,MAClB,qBACD,yBAAyB,GAAG,IAC5B,sBAAsB"}

package/dist/types/html/HTMLComponentTypes.d.ts

@@ -26,16 +26,15 @@ type RestHTMLComponents<T> = { [K in Exclude<keyof HTMLTagsType, keyof T>]?: FC<
 /**
  * The supported modes for the HTMLComponents type.
  */
-type HTMLComponentMode = 'permissive' | 'optional' | 'inclusive' | 'strict';
+export type HTMLComponentMode = 'permissive' | 'optional' | 'inclusive' | 'strict';
 /**
  * The main component definition with Mode support.
  */
-type HTMLComponents<Mode extends HTMLComponentMode = 'optional', T = {}> = Mode extends 'strict' ? DefinedComponents<T, true> : Mode extends 'inclusive' // Inclusive: Keys in T are required. Rest of HTML is optional.
+export type HTMLComponents<Mode extends HTMLComponentMode = 'optional', T = {}> = Mode extends 'strict' ? DefinedComponents<T, true> : Mode extends 'inclusive' // Inclusive: Keys in T are required. Rest of HTML is optional.
  ? DefinedComponents<T, true> & RestHTMLComponents<T> : Mode extends 'permissive' // Permissive: Keys in T optional. Rest of HTML optional. Any other string allowed.
  ? DefinedComponents<T, false> & RestHTMLComponents<T> & {
   [key: string]: FC<any>;
 } // Optional (Default): Keys in T optional. Rest of HTML optional.
  : DefinedComponents<T, false> & RestHTMLComponents<T>;
 //#endregion
-export { HTMLComponentMode, HTMLComponents };
 //# sourceMappingURL=HTMLComponentTypes.d.ts.map

package/dist/types/html/HTMLComponentTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HTMLComponentTypes.d.ts","names":[],"sources":["../../../src/html/HTMLComponentTypes.tsx"],"mappings":";;;;;;KAMK,YAAY,KAAK,8BAElB,8BAEE,gCAEE;;;;KAKH,gBAAgB,SAAS,0BAE1B,0BACK,KAAK,cAAc,sBAAsB,YAAY,MAAM;;;;KAM/D,aAAa,KAAK,gBAAgB,IAAI,oBACvC,eAAe,KACf,eAAe;;;;;KAMd,kBAAkB,GAAG,8BAA8B,6BAGjD,WAAW,IAAI,GAAG,aAAa,KAAK,gBAAgB,EAAE,aAItD,WAAW,KAAK,GAAG,aAAa,KAAK,gBAAgB,EAAE;;;;;KAOzD,mBAAmB,QACrB,KAAK,cAAc,oBAAoB,MAAM,GAC5C,gBAAgB,IAAI,oBAChB,eAAe,KACf,eAAe;;;;KAOX;;;;KASA,eACV,aAAa,gCACb,UACE,wBAEA,kBAAkB,WAClB;GAEE,kBAAkB,WAAW,mBAAmB,KAChD;GAEE,kBAAkB,YAChB,mBAAmB;GAChB,cAAc;;GAGnB,kBAAkB,YAAY,mBAAmB"}
+{"version":3,"file":"HTMLComponentTypes.d.ts","names":[],"sources":["../../../src/html/HTMLComponentTypes.tsx"],"mappings":";;;;;;KAMK,YAAY,KAAK,8BAElB,8BAEE,gCAEE;;;;KAKH,gBAAgB,SAAS,0BAE1B,0BACK,KAAK,cAAc,sBAAsB,YAAY,MAAM;;;;KAM/D,aAAa,KAAK,gBAAgB,IAAI,oBACvC,eAAe,KACf,eAAe;;;;;KAMd,kBAAkB,GAAG,8BAA8B,6BAGjD,WAAW,IAAI,GAAG,aAAa,KAAK,gBAAgB,EAAE,aAItD,WAAW,KAAK,GAAG,aAAa,KAAK,gBAAgB,EAAE;;;;;KAOzD,mBAAmB,QACrB,KAAK,cAAc,oBAAoB,MAAM,GAC5C,gBAAgB,IAAI,oBAChB,eAAe,KACf,eAAe;;;;YAOX;;;;YASA,eACV,aAAa,gCACb,UACE,wBAEA,kBAAkB,WAClB;GAEE,kBAAkB,WAAW,mBAAmB,KAChD;GAEE,kBAAkB,YAChB,mBAAmB;GAChB,cAAc;;GAGnB,kBAAkB,YAAY,mBAAmB"}

package/dist/types/html/HTMLProvider.d.ts

@@ -10,8 +10,7 @@ type HTMLProviderProps = PropsWithChildren<{
    */
   components?: HTMLComponents<'permissive', {}>;
 }>;
-declare const useHTMLContext: () => HTMLContextValue;
-declare const HTMLProvider: FC<HTMLProviderProps>;
+export declare const useHTMLContext: () => HTMLContextValue;
+export declare const HTMLProvider: FC<HTMLProviderProps>;
 //#endregion
-export { HTMLProvider, useHTMLContext };
 //# sourceMappingURL=HTMLProvider.d.ts.map

package/dist/types/html/HTMLProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HTMLProvider.d.ts","names":[],"sources":["../../../src/html/HTMLProvider.tsx"],"mappings":";;;KAUK;EACH,aAAa;;KAGV,oBAAoB;;;;EAIvB,aAAa;;cAKF,sBAAc;cAEd,cAAc,GAAG"}
+{"version":3,"file":"HTMLProvider.d.ts","names":[],"sources":["../../../src/html/HTMLProvider.tsx"],"mappings":";;;KAUK;EACH,aAAa;;KAGV,oBAAoB;;;;EAIvB,aAAa;;qBAKF,sBAAc;qBAEd,cAAc,GAAG"}

package/dist/types/html/HTMLRenderer.d.ts

@@ -1,7 +1,7 @@
 import { HTMLComponents } from "./HTMLComponentTypes.js";
 import { FC, JSX } from "react";
 //#region src/html/HTMLRenderer.d.ts
-type RenderHTMLProps = {
+export type RenderHTMLProps = {
   /**
    * Component overrides for HTML tags.
    * Allows you to customize how specific HTML elements are rendered.
@@ -14,15 +14,15 @@ type RenderHTMLProps = {
  * This function does not use context from HTMLProvider. Use `useHTMLRenderer`
  * hook if you want to leverage provider context.
  */
-declare const renderHTML: (content: string, { components }?: RenderHTMLProps) => JSX.Element;
+export declare const renderHTML: (content: string, { components }?: RenderHTMLProps) => JSX.Element;
 /**
  * Hook that returns a function to render HTML content.
  *
  * This hook considers the configuration from the `HTMLProvider` context if available,
  * falling back to the provided components.
  */
-declare const useHTMLRenderer: ({ components }?: RenderHTMLProps) => (content: string) => JSX.Element;
-type HTMLRendererProps = RenderHTMLProps & {
+export declare const useHTMLRenderer: ({ components }?: RenderHTMLProps) => (content: string) => JSX.Element;
+export type HTMLRendererProps = RenderHTMLProps & {
   /**
    * The HTML content to render as a string.
    */
@@ -34,7 +34,6 @@ type HTMLRendererProps = RenderHTMLProps & {
  * This component uses the components from the `HTMLProvider` context
  * if available.
  */
-declare const HTMLRenderer: FC<HTMLRendererProps>;
+export declare const HTMLRenderer: FC<HTMLRendererProps>;
 //#endregion
-export { HTMLRenderer, HTMLRendererProps, RenderHTMLProps, renderHTML, useHTMLRenderer };
 //# sourceMappingURL=HTMLRenderer.d.ts.map

package/dist/types/html/HTMLRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HTMLRenderer.d.ts","names":[],"sources":["../../../src/html/HTMLRenderer.tsx"],"mappings":";;;KAQY;;;;;EAKV,aAAa;;;;;;;;cASF,aAAU,mBACN,eACM,oBACpB,IAAI;;;;;;;cAuCM,oBAAe,eAAoB,qBAAe,oBAGtC,IAAA;KAUb,oBAAoB;;;;EAI9B;;;;;;;;cASW,cAAc,GAAG"}
+{"version":3,"file":"HTMLRenderer.d.ts","names":[],"sources":["../../../src/html/HTMLRenderer.tsx"],"mappings":";;;YAQY;;;;;EAKV,aAAa;;;;;;;;qBASF,aAAU,mBACN,eACM,oBACpB,IAAI;;;;;;;qBAuCM,oBAAe,eAAoB,qBAAe,oBAGtC,IAAA;YAUb,oBAAoB;;;;EAI9B;;;;;;;;qBASW,cAAc,GAAG"}

package/dist/types/html/HTMLRendererPlugin.d.ts

@@ -4,7 +4,6 @@ type HTMLRendererPluginProps = {
   html: string;
   userComponents?: Record<string, any>;
 };
-declare const HTMLRendererPlugin: FC<HTMLRendererPluginProps>;
+export declare const HTMLRendererPlugin: FC<HTMLRendererPluginProps>;
 //#endregion
-export { HTMLRendererPlugin };
 //# sourceMappingURL=HTMLRendererPlugin.d.ts.map

package/dist/types/html/HTMLRendererPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HTMLRendererPlugin.d.ts","names":[],"sources":["../../../src/html/HTMLRendererPlugin.tsx"],"mappings":";;KAIK;EACH;EACA,iBAAiB;;cAGN,oBAAoB,GAAG"}
+{"version":3,"file":"HTMLRendererPlugin.d.ts","names":[],"sources":["../../../src/html/HTMLRendererPlugin.tsx"],"mappings":";;KAIK;EACH;EACA,iBAAiB;;qBAGN,oBAAoB,GAAG"}

package/dist/types/html/types.d.ts

@@ -1,9 +1,8 @@
 import { ReactNode } from "react";
 //#region src/html/types.d.ts
-type ReactComponentProps = {
+export type ReactComponentProps = {
   children?: ReactNode;
   [key: string]: any;
 };
 //#endregion
-export { ReactComponentProps };
 //# sourceMappingURL=types.d.ts.map

package/dist/types/html/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/html/types.ts"],"mappings":";;KAEY;EACV,WAAW;GACV"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/html/types.ts"],"mappings":";;YAEY;EACV,WAAW;GACV"}

package/dist/types/index.d.ts

@@ -6,7 +6,6 @@ import { ExperimentState, useExperiment } from "./analytics/useExperiment.js";
 import { IntlayerClientContext, IntlayerProvider, IntlayerProviderContent, IntlayerProviderProps, useIntlayerContext } from "./client/IntlayerProvider.js";
 import { useIntl } from "./client/format/useIntl.js";
 import { t } from "./client/t.js";
-import { HTMLComponents } from "./html/HTMLComponentTypes.js";
 import { IInterpreterPluginReact } from "./plugins.js";
 import { useDictionary } from "./client/useDictionary.js";
 import { useDictionaryAsync } from "./client/useDictionaryAsync.js";
@@ -20,8 +19,7 @@ import { localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, use
 import { useRewriteURL } from "./client/useRewriteURL.js";
 import { getDictionary } from "./getDictionary.js";
 import { getIntlayer } from "./getIntlayer.js";
-import "./html/index.js";
-import { MarkdownProviderOptions as MarkdownProviderOptions$1, useMarkdownContext as useMarkdownContext$1 } from "./markdown/MarkdownProvider.js";
+import { MarkdownProviderOptions as MarkdownProviderOptions$1, MarkdownProviderProps, useMarkdownContext as useMarkdownContext$1 } from "./markdown/MarkdownProvider.js";
 import { MarkdownRendererProps as MarkdownRendererProps$1, RenderMarkdownProps as RenderMarkdownProps$1, renderMarkdown as renderMarkdown$1, useMarkdownRenderer as useMarkdownRenderer$1 } from "./markdown/MarkdownRenderer.js";
 import "./markdown/index.js";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
@@ -32,41 +30,35 @@ declare module '@intlayer/core/interpreter' {
 /**
  * @deprecated import from react-intlayer/markdown instead
  */
-declare const MarkdownProvider: import("react").FC<MarkdownProviderOptions$1 & {
-  components?: HTMLComponents<'permissive', {}>;
-  wrapper?: import("react").FC<import("react").HTMLAttributes<HTMLElement>>;
-  renderMarkdown?: (markdown: string | import("@intlayer/core/markdown").ParsedMarkdown, options?: MarkdownProviderOptions$1, components?: HTMLComponents<'permissive', {}>, wrapper?: import("react").FC<import("react").HTMLAttributes<HTMLElement>>) => import("react").ReactNode | Promise<import("react").ReactNode>;
-} & {
-  children?: import("react").ReactNode | undefined;
-}>;
+export declare const MarkdownProvider: import("react").FC<MarkdownProviderProps>;
 /**
  * @deprecated import from react-intlayer/markdown instead
  */
-declare const useMarkdownContext: typeof useMarkdownContext$1;
+export declare const useMarkdownContext: typeof useMarkdownContext$1;
 /**
  * @deprecated import from react-intlayer/markdown instead
  */
-type MarkdownProviderOptions = MarkdownProviderOptions$1;
+export type MarkdownProviderOptions = MarkdownProviderOptions$1;
 /**
  * @deprecated import from react-intlayer/markdown instead
  */
-declare const renderMarkdown: typeof renderMarkdown$1;
+export declare const renderMarkdown: typeof renderMarkdown$1;
 /**
  * @deprecated import from react-intlayer/markdown instead
  */
-declare const useMarkdownRenderer: typeof useMarkdownRenderer$1;
+export declare const useMarkdownRenderer: typeof useMarkdownRenderer$1;
 /**
  * @deprecated import from react-intlayer/markdown instead
  */
-declare const MarkdownRenderer: import("react").FC<MarkdownRendererProps$1>;
+export declare const MarkdownRenderer: import("react").FC<MarkdownRendererProps$1>;
 /**
  * @deprecated import from react-intlayer/markdown instead
  */
-type RenderMarkdownProps = RenderMarkdownProps$1;
+export type RenderMarkdownProps = RenderMarkdownProps$1;
 /**
  * @deprecated import from react-intlayer/markdown instead
  */
-type MarkdownRendererProps = MarkdownRendererProps$1;
+export type MarkdownRendererProps = MarkdownRendererProps$1;
 //#endregion
-export { AnalyticsProvider, type ConversionParams, type ExperimentState, IntlayerClientContext, type IntlayerNode, IntlayerProvider, IntlayerProviderContent, type IntlayerProviderProps, MarkdownProvider, MarkdownProviderOptions, MarkdownRenderer, MarkdownRendererProps, RenderMarkdownProps, type UseLocaleProps, type UseLocaleResult, getDictionary, getIntlayer, localeCookie, localeInStorage, renderMarkdown, setLocaleCookie, setLocaleInStorage, t, useAnalytics, useConversion, useDictionary, useDictionaryAsync, useDictionaryDynamic, useExperiment, useI18n, useIntl, useIntlayer, useIntlayerContext, useLoadDynamic, useLocale, useLocaleBase, useLocaleCookie, useLocaleStorage, useMarkdownContext, useMarkdownRenderer, useRewriteURL };
+export { AnalyticsProvider, type ConversionParams, type ExperimentState, IntlayerClientContext, type IntlayerNode, IntlayerProvider, IntlayerProviderContent, type IntlayerProviderProps, type UseLocaleProps, type UseLocaleResult, getDictionary, getIntlayer, localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, t, useAnalytics, useConversion, useDictionary, useDictionaryAsync, useDictionaryDynamic, useExperiment, useI18n, useIntl, useIntlayer, useIntlayerContext, useLoadDynamic, useLocale, useLocaleBase, useLocaleCookie, useLocaleStorage, useRewriteURL };
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAIY,mBAAmB,GAAG,GAAG,UAAU,uBACnC,wBAAwB,GAAG,GAAG;;;;;cA2D7B,kCAAgB,GAAA;eAAA;;;;;;;;;cAIhB,2BAAkB;;;;KAInB,0BAA0B;;;;cAIzB,uBAAc;;;;cAId,4BAAmB;;;;cAInB,kCAAgB,GAAA;;;;KAIjB,sBAAsB;;;;KAItB,wBAAwB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;YAIY,mBAAmB,GAAG,GAAG,UAAU,uBACnC,wBAAwB,GAAG,GAAG;;;;;qBA2D7B,kCAAgB,GAAhB;;;;qBAIA,2BAAkB;;;;YAInB,0BAA0B;;;;qBAIzB,uBAAc;;;;qBAId,4BAAmB;;;;qBAInB,kCAAgB,GAAA;;;;YAIjB,sBAAsB;;;;YAItB,wBAAwB"}

package/dist/types/markdown/MarkdownProvider.d.ts

@@ -2,7 +2,7 @@ import { HTMLComponents } from "../html/HTMLComponentTypes.js";
 import { ParsedMarkdown } from "./processor.js";
 import { FC, HTMLAttributes, PropsWithChildren, ReactNode } from "react";
 //#region src/markdown/MarkdownProvider.d.ts
-type MarkdownProviderOptions = {
+export type MarkdownProviderOptions = {
   /** Forces the compiler to always output content with a block-level wrapper. */
   forceBlock?: boolean;
   /** Forces the compiler to always output content with an inline wrapper. */
@@ -12,11 +12,11 @@ type MarkdownProviderOptions = {
   /** Whether to use the GitHub Tag Filter for security. */
   tagfilter?: boolean;
 };
-type MarkdownContextValue = {
+export type MarkdownContextValue = {
   components?: HTMLComponents<'permissive', {}>;
   renderMarkdown: (markdown: string | ParsedMarkdown, options?: MarkdownProviderOptions, components?: HTMLComponents<'permissive', {}>, wrapper?: FC<HTMLAttributes<HTMLElement>>) => ReactNode | Promise<ReactNode>;
 };
-type MarkdownProviderProps = PropsWithChildren<MarkdownProviderOptions & {
+export type MarkdownProviderProps = PropsWithChildren<MarkdownProviderOptions & {
   components?: HTMLComponents<'permissive', {}>;
   wrapper?: FC<HTMLAttributes<HTMLElement>>;
   renderMarkdown?: (markdown: string | ParsedMarkdown, options?: MarkdownProviderOptions, components?: HTMLComponents<'permissive', {}>, wrapper?: FC<HTMLAttributes<HTMLElement>>) => ReactNode | Promise<ReactNode>;
@@ -28,7 +28,7 @@ type MarkdownProviderProps = PropsWithChildren<MarkdownProviderOptions & {
  * Prefer `useMarkdownRenderer` for most use cases; use this hook only when
  * you need direct access to the context object itself.
  */
-declare const useMarkdownContext: () => MarkdownContextValue;
+export declare const useMarkdownContext: () => MarkdownContextValue;
 /**
  * Provider for the MarkdownRenderer component.
  *
@@ -53,7 +53,6 @@ declare const useMarkdownContext: () => MarkdownContextValue;
  * </MarkdownProvider>
  * ```
  */
-declare const MarkdownProvider: FC<MarkdownProviderProps>;
+export declare const MarkdownProvider: FC<MarkdownProviderProps>;
 //#endregion
-export { MarkdownProvider, MarkdownProviderOptions, useMarkdownContext };
 //# sourceMappingURL=MarkdownProvider.d.ts.map

package/dist/types/markdown/MarkdownProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarkdownProvider.d.ts","names":[],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"mappings":";;;;KAiBY;;EAEV;;EAEA;;EAEA;;EAEA;;KAGG;EACH,aAAa;EACb,iBACE,mBAAmB,gBACnB,UAAU,yBACV,aAAa,kCACb,UAAU,GAAG,eAAe,kBACzB,YAAY,QAAQ;;KAGtB,wBAAwB,kBAC3B;EACE,aAAa;EACb,UAAU,GAAG,eAAe;EAC5B,kBACE,mBAAmB,gBACnB,UAAU,yBACV,aAAa,kCACb,UAAU,GAAG,eAAe,kBACzB,YAAY,QAAQ;;;;;;;;;cAehB,0BAAkB;;;;;;;;;;;;;;;;;;;;;;;;;cA+ClB,kBAAkB,GAAG"}
+{"version":3,"file":"MarkdownProvider.d.ts","names":[],"sources":["../../../src/markdown/MarkdownProvider.tsx"],"mappings":";;;;YAiBY;;EAEV;;EAEA;;EAEA;;EAEA;;YAGU;EACV,aAAa;EACb,iBACE,mBAAmB,gBACnB,UAAU,yBACV,aAAa,kCACb,UAAU,GAAG,eAAe,kBACzB,YAAY,QAAQ;;YAGf,wBAAwB,kBAClC;EACE,aAAa;EACb,UAAU,GAAG,eAAe;EAC5B,kBACE,mBAAmB,gBACnB,UAAU,yBACV,aAAa,kCACb,UAAU,GAAG,eAAe,kBACzB,YAAY,QAAQ;;;;;;;;;qBAehB,0BAAkB;;;;;;;;;;;;;;;;;;;;;;;;;qBA+ClB,kBAAkB,GAAG"}

package/dist/types/markdown/MarkdownRenderer.d.ts

@@ -22,7 +22,7 @@ import { FC, HTMLAttributes, JSX, ReactNode } from "react";
  * };
  * ```
  */
-type RenderMarkdownProps = MarkdownProviderOptions & {
+export type RenderMarkdownProps = MarkdownProviderOptions & {
   /**
    * Component overrides for HTML tags.
    * Allows you to customize how specific HTML elements are rendered.
@@ -73,7 +73,7 @@ type RenderMarkdownProps = MarkdownProviderOptions & {
  * });
  * ```
  */
-declare const renderMarkdown: (content: string | ParsedMarkdown, { components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter }?: RenderMarkdownProps) => JSX.Element;
+export declare const renderMarkdown: (content: string | ParsedMarkdown, { components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter }?: RenderMarkdownProps) => JSX.Element;
 /**
  * Hook that returns a function to render markdown content.
  *
@@ -119,7 +119,7 @@ declare const renderMarkdown: (content: string | ParsedMarkdown, { components, w
  * }
  * ```
  */
-declare const useMarkdownRenderer: ({ components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter }?: RenderMarkdownProps) => (content: string | ParsedMarkdown) => string | number | bigint | boolean | JSX.Element | Iterable<ReactNode> | Promise<ReactNode>;
+export declare const useMarkdownRenderer: ({ components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter }?: RenderMarkdownProps) => (content: string | ParsedMarkdown) => string | number | bigint | boolean | JSX.Element | Iterable<ReactNode> | Promise<ReactNode>;
 /**
  * Props for the MarkdownRenderer component.
  *
@@ -135,7 +135,7 @@ declare const useMarkdownRenderer: ({ components, wrapper, forceBlock, forceInli
  * };
  * ```
  */
-type MarkdownRendererProps = RenderMarkdownProps & {
+export type MarkdownRendererProps = RenderMarkdownProps & {
   /**
    * The markdown content to render as a string.
    *
@@ -237,7 +237,6 @@ type MarkdownRendererProps = RenderMarkdownProps & {
  * }
  * ```
  */
-declare const MarkdownRenderer: FC<MarkdownRendererProps>;
+export declare const MarkdownRenderer: FC<MarkdownRendererProps>;
 //#endregion
-export { MarkdownRenderer, MarkdownRendererProps, RenderMarkdownProps, renderMarkdown, useMarkdownRenderer };
 //# sourceMappingURL=MarkdownRenderer.d.ts.map

package/dist/types/markdown/MarkdownRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarkdownRenderer.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRenderer.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;KAiCY,sBAAsB;;;;;;;;;;;;;;EAchC,aAAa;;;;;;;;;;EAUb,UAAU,GAAG,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4BjB,iBAAc,kBACP,kBAAc,YAAA,SAAA,YAAA,aAAA,qBAAA,cAQ7B,wBACF,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4DM,wBAAmB,YAAA,SAAA,YAAA,aAAA,qBAAA,cAO7B,yBAAmB,kBAGM,wDAAc,IAAA,UAAA,SAAA,aAAA,QAAA;;;;;;;;;;;;;;;;KAyC9B,wBAAwB;;;;;;;;;;;EAWlC,mBAAmB;;;;;;;;;;;;;;;;;;;;;EAqBnB,kBACE,mBAAmB,gBACnB;IACE,aAAa;IACb,UAAU;IACV;IACA;IACA;IACA;QAEC,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAgEd,kBAAkB,GAAG"}
+{"version":3,"file":"MarkdownRenderer.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRenderer.tsx"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;YAiCY,sBAAsB;;;;;;;;;;;;;;EAchC,aAAa;;;;;;;;;;EAUb,UAAU,GAAG,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4BjB,iBAAc,kBACP,kBAAc,YAAA,SAAA,YAAA,aAAA,qBAAA,cAQ7B,wBACF,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4DM,wBAAmB,YAAA,SAAA,YAAA,aAAA,qBAAA,cAO7B,yBAAmB,kBAGM,wDAAc,IAAA,UAAA,SAAA,aAAA,QAAA;;;;;;;;;;;;;;;;YAyC9B,wBAAwB;;;;;;;;;;;EAWlC,mBAAmB;;;;;;;;;;;;;;;;;;;;;EAqBnB,kBACE,mBAAmB,gBACnB;IACE,aAAa;IACb,UAAU;IACV;IACA;IACA;IACA;QAEC,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAgEd,kBAAkB,GAAG"}

package/dist/types/markdown/MarkdownRendererPlugin.d.ts

@@ -12,7 +12,6 @@ type MarkdownRendererPluginProps = {
   options?: MarkdownProviderOptions;
   components?: HTMLComponents<'permissive', {}>;
 };
-declare const MarkdownRendererPlugin: FC<MarkdownRendererPluginProps>;
+export declare const MarkdownRendererPlugin: FC<MarkdownRendererPluginProps>;
 //#endregion
-export { MarkdownRendererPlugin };
 //# sourceMappingURL=MarkdownRendererPlugin.d.ts.map

package/dist/types/markdown/MarkdownRendererPlugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MarkdownRendererPlugin.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRendererPlugin.tsx"],"mappings":";;;;;;KAYK;EACH;EACA,SAAS;EACT,SAAS;EACT;EACA,UAAU;EACV,aAAa;;cAGF,wBAAwB,GAAG"}
+{"version":3,"file":"MarkdownRendererPlugin.d.ts","names":[],"sources":["../../../src/markdown/MarkdownRendererPlugin.tsx"],"mappings":";;;;;;KAYK;EACH;EACA,SAAS;EACT,SAAS;EACT;EACA,UAAU;EACV,aAAa;;qBAGF,wBAAwB,GAAG"}

package/dist/types/markdown/processor.d.ts

@@ -6,7 +6,7 @@ type HTMLTags = keyof JSX.IntrinsicElements;
 /**
  * Refined MarkdownRendererOptions type.
  */
-type MarkdownRendererOptions = Partial<{
+export type MarkdownRendererOptions = Partial<{
   /**
    * Ultimate control over the output of all rendered JSX.
    */
@@ -90,7 +90,7 @@ type MarkdownRendererOptions = Partial<{
  * const element = compileMarkdown(ast, { forceBlock: true });
  * ```
  */
-declare const parseMarkdown: (markdown?: string, options?: MarkdownRendererOptions) => ParsedMarkdown;
+export declare const parseMarkdown: (markdown?: string, options?: MarkdownRendererOptions) => ParsedMarkdown;
 /**
  * **Steps 1 + 2 — parse and render in one shot.**
  * Accepts a raw markdown string or a pre-parsed `ParsedMarkdown` AST and
@@ -106,7 +106,7 @@ declare const parseMarkdown: (markdown?: string, options?: MarkdownRendererOptio
  * const element = compileMarkdown('# Hello **world**', { forceBlock: true });
  * ```
  */
-declare const compileMarkdown: (input?: string | ParsedMarkdown, options?: MarkdownRendererOptions) => JSX.Element;
+export declare const compileMarkdown: (input?: string | ParsedMarkdown, options?: MarkdownRendererOptions) => JSX.Element;
 //#endregion
-export { MarkdownRendererOptions, type ParsedMarkdown, compileMarkdown, parseMarkdown };
+export type { ParsedMarkdown };
 //# sourceMappingURL=processor.d.ts.map

package/dist/types/markdown/processor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"processor.d.ts","names":[],"sources":["../../../src/markdown/processor.tsx"],"mappings":";;;;KAyBK,iBAAiB,IAAI;;;;KAKd,0BAA0B;;;;EAIpC,gBACE,KAAK,kBAAkB,mBACvB,OAAO,IAAI,wBACR,UAAU,gBACV;;;;;EAML;;;;;EAMA;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA;KACG;;;;;EAMH,YAAY;;;;EAKZ,YAAY;;;;EAKZ,YAAY,eAAe,KAAK,UAAU;;;;EAK1C,UAAU;;;;EAKV;;;;EAKA;;;;EAKA;;;;;;;;;;;;;;;;;;;;cAsCW,gBAAa,mBACR,UACP,4BACR;;;;;;;;;;;;;;;;cAuDU,kBAAe,iBACV,gBAAc,UACrB,4BACR,IAAI"}
+{"version":3,"file":"processor.d.ts","names":[],"sources":["../../../src/markdown/processor.tsx"],"mappings":";;;;KAyBK,iBAAiB,IAAI;;;;YAKd,0BAA0B;;;;EAIpC,gBACE,KAAK,kBAAkB,mBACvB,OAAO,IAAI,wBACR,UAAU,gBACV;;;;;EAML;;;;;EAMA;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA;KACG;;;;;EAMH,YAAY;;;;EAKZ,YAAY;;;;EAKZ,YAAY,eAAe,KAAK,UAAU;;;;EAK1C,UAAU;;;;EAKV;;;;EAKA;;;;EAKA;;;;;;;;;;;;;;;;;;;;qBAsCW,gBAAa,mBACR,UACP,4BACR;;;;;;;;;;;;;;;;qBAuDU,kBAAe,iBACV,gBAAc,UACrB,4BACR,IAAI"}

package/dist/types/markdown/runtime.d.ts

@@ -5,14 +5,13 @@ import { MarkdownRuntime } from "@intlayer/core/markdown";
  * React-specific runtime for the markdown processor.
  * Implements the MarkdownRuntime interface using React's primitives.
  */
-declare const reactRuntime: MarkdownRuntime;
+export declare const reactRuntime: MarkdownRuntime;
 /**
  * Creates a React runtime with custom createElement for advanced use cases.
  * Useful for wrapping elements or adding middleware.
  */
-declare const createReactRuntime: (options?: {
+export declare const createReactRuntime: (options?: {
   onCreateElement?: (type: string | any, props: Record<string, any> | null, children: any[]) => ReactNode;
 }) => MarkdownRuntime;
 //#endregion
-export { createReactRuntime, reactRuntime };
 //# sourceMappingURL=runtime.d.ts.map

package/dist/types/markdown/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","names":[],"sources":["../../../src/markdown/runtime.ts"],"mappings":";;;;;;;cAaa,cAAc;;;;;cA6Dd,qBAAkB;EAE3B,mBACE,oBACA,OAAO,4BACP,oBACG;MAEN"}
+{"version":3,"file":"runtime.d.ts","names":[],"sources":["../../../src/markdown/runtime.ts"],"mappings":";;;;;;;qBAaa,cAAc;;;;;qBA6Dd,qBAAkB;EAE3B,mBACE,oBACA,OAAO,4BACP,oBACG;MAEN"}