react-intlayer 9.4.3 → 9.5.0

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":";;;;KAmBK,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;;;;;;;;;;;;;;;;;;;;qBAgCW,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":";;;;;;;qBA+Ba,cAAc;;;;;qBA8Ed,qBAAkB;EAE3B,mBACE,oBACA,OAAO,4BACP,oBACG;MAEN"}

package/dist/types/plugins.d.ts

@@ -9,38 +9,38 @@ import { NodeType } from "@intlayer/types/nodeType";
 /** ---------------------------------------------
  *  INTLAYER NODE PLUGIN
  *  --------------------------------------------- */
-type IntlayerNodeCond<T> = T extends number | string ? IntlayerNode<T> : never;
+export type IntlayerNodeCond<T> = T extends number | string ? IntlayerNode<T> : never;
 /** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
-declare const intlayerNodePlugins: Plugins;
+export declare const intlayerNodePlugins: Plugins;
 /** ---------------------------------------------
  *  REACT NODE PLUGIN
  *  --------------------------------------------- */
-type ReactNodeCond<T> = T extends {
+export type ReactNodeCond<T> = T extends {
   props: any;
   key: any;
 } ? ReactNode : never;
 /** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
-declare const reactNodePlugins: Plugins;
+export declare const reactNodePlugins: Plugins;
 /** ---------------------------------------------
  *  INSERTION PLUGIN
  *  --------------------------------------------- */
-type InsertionCond<T> = T extends {
+export type InsertionCond<T> = T extends {
   nodeType: NodeType | string;
   [NodeTypes.INSERTION]: infer I;
   fields: readonly string[];
 } ? <V extends { [K in T['fields'][number]]: ReactNode; }>(values: V) => I extends string ? V[keyof V] extends string | number ? IntlayerNode<string> : IntlayerNode<ReactNode> : DeepTransformContent<I> : never;
 /** Insertion plugin for React. Handles component/node insertion. */
-declare const insertionPlugin: Plugins;
+export declare const insertionPlugin: Plugins;
 /**
  * MARKDOWN PLUGIN
  */
-type MarkdownStringCond<T> = T extends string ? IntlayerNode<string, {
+export type MarkdownStringCond<T> = T extends string ? IntlayerNode<string, {
   metadata: DeepTransformContent<string>;
   use: (components: HTMLComponents<'permissive', {}>) => ReactNode;
 }> : never;
 /** Markdown string plugin. Replaces string node with a component that render the markdown. */
-declare const markdownStringPlugin: Plugins;
-type MarkdownCond<T> = T extends {
+export declare const markdownStringPlugin: Plugins;
+export type MarkdownCond<T> = T extends {
   nodeType: NodeType | string;
   [NodeTypes.MARKDOWN]: infer M;
   tags?: infer U;
@@ -49,7 +49,7 @@ type MarkdownCond<T> = T extends {
   use: (components?: HTMLComponents<'permissive', U>) => ReactNode;
   metadata: DeepTransformContent<V>;
 }> : never;
-declare const markdownPlugin: Plugins;
+export declare const markdownPlugin: Plugins;
 /** ---------------------------------------------
  *  HTML PLUGIN
  *  --------------------------------------------- */
@@ -61,7 +61,7 @@ declare const markdownPlugin: Plugins;
  * This ensures type safety:
  * - `html('<div>Hello <CustomComponent /></div>').use({ CustomComponent: ... })` - optional but typed
  */
-type HTMLPluginCond<T> = T extends {
+export type HTMLPluginCond<T> = T extends {
   nodeType: NodeType | string;
   [NodeTypes.HTML]: infer I;
   tags?: infer U;
@@ -69,11 +69,11 @@ type HTMLPluginCond<T> = T extends {
   use: (components?: HTMLComponents<'permissive', U>) => ReactNode;
 }> : never;
 /** HTML plugin. Replaces node with a function that takes components => ReactNode. */
-declare const htmlPlugin: Plugins;
+export declare const htmlPlugin: Plugins;
 /** ---------------------------------------------
  *  PLUGINS RESULT
  *  --------------------------------------------- */
-type IInterpreterPluginReact<T, _S, _L extends LocalesValues> = {
+export type IInterpreterPluginReact<T, _S, _L extends LocalesValues> = {
   reactNode: ReactNodeCond<T>;
   reactIntlayerNode: IntlayerNodeCond<T>;
   reactInsertion: InsertionCond<T>;
@@ -85,19 +85,18 @@ type IInterpreterPluginReact<T, _S, _L extends LocalesValues> = {
  *
  * Otherwise the the `react-intlayer` plugins will override the types of `intlayer` functions.
  */
-type IInterpreterPluginState = Omit<IInterpreterPluginState$1, 'insertion'> & {
+export type IInterpreterPluginState = Omit<IInterpreterPluginState$1, 'insertion'> & {
   reactNode: true;
   reactIntlayerNode: true;
   reactMarkdown: true;
   reactHtml: true;
   reactInsertion: true;
 };
-type DeepTransformContent<T, L extends LocalesValues = DeclaredLocales> = DeepTransformContent$1<T, IInterpreterPluginState, L>;
+export type DeepTransformContent<T, L extends LocalesValues = DeclaredLocales> = DeepTransformContent$1<T, IInterpreterPluginState, L>;
 /**
  * Get the plugins array for React content transformation.
  * This function is used by both getIntlayer and getDictionary to ensure consistent plugin configuration.
  */
-declare const getPlugins: (locale?: LocalesValues, fallback?: boolean) => Plugins[];
+export declare const getPlugins: (locale?: LocalesValues, fallback?: boolean) => Plugins[];
 //#endregion
-export { DeepTransformContent, HTMLPluginCond, IInterpreterPluginReact, IInterpreterPluginState, InsertionCond, IntlayerNodeCond, MarkdownCond, MarkdownStringCond, ReactNodeCond, getPlugins, htmlPlugin, insertionPlugin, intlayerNodePlugins, markdownPlugin, markdownStringPlugin, reactNodePlugins };
 //# sourceMappingURL=plugins.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"plugins.d.ts","names":[],"sources":["../../src/plugins.tsx"],"mappings":";;;;;;;;;;;KAoEY,iBAAiB,KAAK,4BAC9B,aAAa;;cAIJ,qBAAqB;;;;KAyCtB,cAAc,KAAK;EAC7B;EACA;IAEE;;cAIS,kBAAkB;;;;KA8CnB,cAAc,KAAK;EAC7B,UAAU;GACT,UAAU,kBAAkB;EAC7B;KAEG,aAAa,KAAK,sBAAsB,cACvC,QAAQ,MACL,mBACD,QAAQ,6BACN,uBACA,aAAa,aACf,qBAAqB;;cA4BhB,iBAAiB;;;;KA4GlB,mBAAmB,KAAK,mBAChC;EAGI,UAAU;EACV,MAAM,YAAY,qCAAqC;;;cAiBlD,sBAAsB;KAqFvB,aAAa,KAAK;EAC5B,UAAU;GACT,UAAU,iBAAiB;EAC5B,aAAa;EACb,iBAAiB;IAEf,aACE;EAEE,MAAM,aAAa,6BAA6B,OAAO;EACvD,UAAU,qBAAqB;;cAK1B,gBAAgB;;;;;;;;;;;;KAsCjB,eAAe,KAAK;EAC9B,UAAU;GACT,UAAU,aAAa;EACxB,aAAa;IAEX,aACE;EAEE,MAAM,aAAa,6BAA6B,OAAO;;;cAclD,YAAY;;;;KA6Db,wBAAwB,GAAG,IAAI,WAAW;EACpD,WAAW,cAAc;EACzB,mBAAmB,iBAAiB;EACpC,gBAAgB,cAAc;EAC9B,eAAe,aAAa;EAC5B,WAAW,eAAe;;;;;;;KAQhB,0BAA0B,KACpC;EAGA;EACA;EACA;EACA;EACA;;KAGU,qBACV,GACA,UAAU,gBAAgB,mBACxB,uBAAyB,GAAG,yBAAyB;;;;;cAQ5C,aAAU,SACZ,eAAa,uBAErB"}
+{"version":3,"file":"plugins.d.ts","names":[],"sources":["../../src/plugins.tsx"],"mappings":";;;;;;;;;;;YAoEY,iBAAiB,KAAK,4BAC9B,aAAa;;qBAIJ,qBAAqB;;;;YAyCtB,cAAc,KAAK;EAC7B;EACA;IAEE;;qBAIS,kBAAkB;;;;YA8CnB,cAAc,KAAK;EAC7B,UAAU;GACT,UAAU,kBAAkB;EAC7B;KAEG,aAAa,KAAK,sBAAsB,cACvC,QAAQ,MACL,mBACD,QAAQ,6BACN,uBACA,aAAa,aACf,qBAAqB;;qBA4BhB,iBAAiB;;;;YA4GlB,mBAAmB,KAAK,mBAChC;EAGI,UAAU;EACV,MAAM,YAAY,qCAAqC;;;qBAiBlD,sBAAsB;YAqFvB,aAAa,KAAK;EAC5B,UAAU;GACT,UAAU,iBAAiB;EAC5B,aAAa;EACb,iBAAiB;IAEf,aACE;EAEE,MAAM,aAAa,6BAA6B,OAAO;EACvD,UAAU,qBAAqB;;qBAK1B,gBAAgB;;;;;;;;;;;;YAsCjB,eAAe,KAAK;EAC9B,UAAU;GACT,UAAU,aAAa;EACxB,aAAa;IAEX,aACE;EAEE,MAAM,aAAa,6BAA6B,OAAO;;;qBAclD,YAAY;;;;YA6Db,wBAAwB,GAAG,IAAI,WAAW;EACpD,WAAW,cAAc;EACzB,mBAAmB,iBAAiB;EACpC,gBAAgB,cAAc;EAC9B,eAAe,aAAa;EAC5B,WAAW,eAAe;;;;;;;YAQhB,0BAA0B,KACpC;EAGA;EACA;EACA;EACA;EACA;;YAGU,qBACV,GACA,UAAU,gBAAgB,mBACxB,uBAAyB,GAAG,yBAAyB;;;;;qBAQ5C,aAAU,SACZ,eAAa,uBAErB"}

package/dist/types/reactElement/renderReactElement.d.ts

@@ -1,6 +1,5 @@
 import { ReactElement } from "react";
 //#region src/reactElement/renderReactElement.d.ts
-declare const renderReactElement: (element: ReactElement<any>) => any;
+export declare const renderReactElement: (element: ReactElement<any>) => any;
 //#endregion
-export { renderReactElement };
 //# sourceMappingURL=renderReactElement.d.ts.map

package/dist/types/reactElement/renderReactElement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderReactElement.d.ts","names":[],"sources":["../../../src/reactElement/renderReactElement.ts"],"mappings":";;cAGa,qBAAkB,SAAa"}
+{"version":3,"file":"renderReactElement.d.ts","names":[],"sources":["../../../src/reactElement/renderReactElement.ts"],"mappings":";;qBAGa,qBAAkB,SAAa"}

package/dist/types/server/IntlayerServerProvider.d.ts

@@ -5,22 +5,22 @@ import { FC, PropsWithChildren } from "react";
 /**
  * Context that store the current locale on the server side
  */
-declare const IntlayerServerContext: ServerContext<LocalesValues>;
+export declare const IntlayerServerContext: ServerContext<LocalesValues>;
 /**
  * Context that stores the ambient variant on the server side.
  *
  * Kept separate from {@link IntlayerServerContext} so the locale context keeps
  * its plain `LocalesValues` shape for the packages already reading it.
  */
-declare const IntlayerServerVariantContext: ServerContext<ProviderVariant>;
+export declare const IntlayerServerVariantContext: ServerContext<ProviderVariant>;
 /**
  * Hook that provides the current locale
  */
-declare const useIntlayer: () => LocalesValues;
+export declare const useIntlayer: () => LocalesValues;
 /**
  * Get the current locale
  */
-declare const locale: LocalesValues;
+export declare const locale: LocalesValues;
 /**
  * Seeds the request-scoped server context locale imperatively — the equivalent
  * of mounting {@link IntlayerServerProvider} without wrapping the tree.
@@ -36,14 +36,14 @@ declare const locale: LocalesValues;
  * };
  * ```
  */
-declare const setLocale: (locale: LocalesValues) => void;
+export declare const setLocale: (locale: LocalesValues) => void;
 /**
  * Seeds the request-scoped ambient variant imperatively — the equivalent of
  * the `variant` prop of {@link IntlayerServerProvider} without wrapping the
  * tree. See that prop for the accepted shapes.
  */
-declare const setVariant: (variant: ProviderVariant) => void;
-type IntlayerServerProviderProps = PropsWithChildren & {
+export declare const setVariant: (variant: ProviderVariant) => void;
+export type IntlayerServerProviderProps = PropsWithChildren & {
   locale?: LocalesValues;
   /**
    * Ambient variant applied to every dictionary read below this provider — for
@@ -58,7 +58,6 @@ type IntlayerServerProviderProps = PropsWithChildren & {
 /**
  * Provider that store the current locale on the server side
  */
-declare const IntlayerServerProvider: FC<IntlayerServerProviderProps>;
+export declare const IntlayerServerProvider: FC<IntlayerServerProviderProps>;
 //#endregion
-export { IntlayerServerContext, IntlayerServerProvider, IntlayerServerProviderProps, IntlayerServerVariantContext, locale, setLocale, setVariant, useIntlayer };
 //# sourceMappingURL=IntlayerServerProvider.d.ts.map

package/dist/types/server/IntlayerServerProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IntlayerServerProvider.d.ts","names":[],"sources":["../../../src/server/IntlayerServerProvider.tsx"],"mappings":";;;;;;;cAca,uBAAqB,cAAA;;;;;;;cASrB,8BAA4B,cAAA;;;;cAM5B,mBAAW;;;;cAKX,QAAM;;;;;;;;;;;;;;;;cAiBN,YAAS,QAAY;;;;;;cASrB,aAAU,SAAa;KAIxB,8BAA8B;EACxC,SAAS;;;;;;;;;EAST,UAAU;;;;;cAMC,wBAAwB,GAAG"}
+{"version":3,"file":"IntlayerServerProvider.d.ts","names":[],"sources":["../../../src/server/IntlayerServerProvider.tsx"],"mappings":";;;;;;;qBAca,uBAAqB,cAAA;;;;;;;qBASrB,8BAA4B,cAAA;;;;qBAM5B,mBAAW;;;;qBAKX,QAAM;;;;;;;;;;;;;;;;qBAiBN,YAAS,QAAY;;;;;;qBASrB,aAAU,SAAa;YAIxB,8BAA8B;EACxC,SAAS;;;;;;;;;EAST,UAAU;;;;;qBAMC,wBAAwB,GAAG"}

package/dist/types/server/format/useCompact.d.ts

@@ -10,7 +10,6 @@ import { compact } from "@intlayer/core/formatters";
  * formatCompact(1500); // "1.5K"
  * ```
  */
-declare const useCompact: () => (...args: Parameters<typeof compact>) => string;
+export declare const useCompact: () => (...args: Parameters<typeof compact>) => string;
 //#endregion
-export { useCompact };
 //# sourceMappingURL=useCompact.d.ts.map

package/dist/types/server/format/useCompact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../../src/server/format/useCompact.ts"],"mappings":";;;;;;;;;;;;cAea,sBAAU,MAGJ,kBAAkB"}
+{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../../src/server/format/useCompact.ts"],"mappings":";;;;;;;;;;;;qBAea,sBAAU,MAGJ,kBAAkB"}

package/dist/types/server/format/useCurrency.d.ts

@@ -21,7 +21,6 @@ import { currency } from "@intlayer/core/formatters";
  * // "¥9,876,543"
  * ```
  */
-declare const useCurrency: () => (...args: Parameters<typeof currency>) => string;
+export declare const useCurrency: () => (...args: Parameters<typeof currency>) => string;
 //#endregion
-export { useCurrency };
 //# sourceMappingURL=useCurrency.d.ts.map

package/dist/types/server/format/useCurrency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../../src/server/format/useCurrency.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cA0Ba,uBAAW,MAGL,kBAAkB"}
+{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../../src/server/format/useCurrency.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;qBA0Ba,uBAAW,MAGL,kBAAkB"}

package/dist/types/server/format/useDate.d.ts

@@ -26,7 +26,6 @@ import { date } from "@intlayer/core/formatters";
  *
  * @see createDate
  */
-declare const useDate: () => (...args: Parameters<typeof date>) => string;
+export declare const useDate: () => (...args: Parameters<typeof date>) => string;
 //#endregion
-export { useDate };
 //# sourceMappingURL=useDate.d.ts.map

package/dist/types/server/format/useDate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDate.d.ts","names":[],"sources":["../../../../src/server/format/useDate.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+Ba,mBAAO,MAGD,kBAAkB"}
+{"version":3,"file":"useDate.d.ts","names":[],"sources":["../../../../src/server/format/useDate.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+Ba,mBAAO,MAGD,kBAAkB"}

package/dist/types/server/format/useIntl.d.ts

@@ -29,7 +29,6 @@ import { WrappedIntl } from "@intlayer/core/formatters";
  * const date2 = new intl.DateTimeFormat('fr-FR').format(new Date());
  * ```
  */
-declare const useIntl: (locale?: LocalesValues) => WrappedIntl;
+export declare const useIntl: (locale?: LocalesValues) => WrappedIntl;
 //#endregion
-export { useIntl };
 //# sourceMappingURL=useIntl.d.ts.map

package/dist/types/server/format/useIntl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useIntl.d.ts","names":[],"sources":["../../../../src/server/format/useIntl.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCa,UAAO,SAAa,kBAAgB"}
+{"version":3,"file":"useIntl.d.ts","names":[],"sources":["../../../../src/server/format/useIntl.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkCa,UAAO,SAAa,kBAAgB"}

package/dist/types/server/format/useList.d.ts

@@ -18,7 +18,6 @@ import { list } from "@intlayer/core/formatters";
  * // "1, 2 und 3"
  * ```
  */
-declare const useList: () => (...args: Parameters<typeof list>) => string;
+export declare const useList: () => (...args: Parameters<typeof list>) => string;
 //#endregion
-export { useList };
 //# sourceMappingURL=useList.d.ts.map

package/dist/types/server/format/useList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../../src/server/format/useList.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAuBa,mBAAO,MAGD,kBAAkB"}
+{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../../src/server/format/useList.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBAuBa,mBAAO,MAGD,kBAAkB"}

package/dist/types/server/format/useNumber.d.ts

@@ -22,7 +22,6 @@ import { number } from "@intlayer/core/formatters";
  * @returns {(value: string | number, options?: import("../createNumber").NumberProps) => string}
  * A number formatting function bound to the active locale.
  */
-declare const useNumber: () => (...args: Parameters<typeof number>) => string;
+export declare const useNumber: () => (...args: Parameters<typeof number>) => string;
 //#endregion
-export { useNumber };
 //# sourceMappingURL=useNumber.d.ts.map

package/dist/types/server/format/useNumber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useNumber.d.ts","names":[],"sources":["../../../../src/server/format/useNumber.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;cA2Ba,qBAAS,MAGH,kBAAkB"}
+{"version":3,"file":"useNumber.d.ts","names":[],"sources":["../../../../src/server/format/useNumber.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;qBA2Ba,qBAAS,MAGH,kBAAkB"}

package/dist/types/server/format/usePercentage.d.ts

@@ -18,7 +18,6 @@ import { percentage } from "@intlayer/core/formatters";
  * @returns {(value: string | number, options?: Omit<PercentageOptions, "value">) => string}
  * A function that formats numbers or numeric strings into localized percentages.
  */
-declare const usePercentage: () => (...args: Parameters<typeof percentage>) => string;
+export declare const usePercentage: () => (...args: Parameters<typeof percentage>) => string;
 //#endregion
-export { usePercentage };
 //# sourceMappingURL=usePercentage.d.ts.map

package/dist/types/server/format/usePercentage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../../src/server/format/usePercentage.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAuBa,yBAAa,MAGP,kBAAkB"}
+{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../../src/server/format/usePercentage.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBAuBa,yBAAa,MAGP,kBAAkB"}