react-intlayer 9.4.2 → 9.4.4

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"}

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

@@ -18,7 +18,6 @@ import { relativeTime } from "@intlayer/core/formatters";
  * @returns {ReturnType<typeof createRelativeTime>} A relative time formatting function
  *          bound to the current client locale.
  */
-declare const useRelativeTime: () => (...args: Parameters<typeof relativeTime>) => string;
+export declare const useRelativeTime: () => (...args: Parameters<typeof relativeTime>) => string;
 //#endregion
-export { useRelativeTime };
 //# sourceMappingURL=useRelativeTime.d.ts.map

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

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

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

@@ -17,7 +17,6 @@ import { units } from "@intlayer/core/formatters";
  *
  * @returns {Function} A unit formatting function that accepts a value and optional formatting options.
  */
-declare const useUnit: () => (...args: Parameters<typeof units>) => string;
+export declare const useUnit: () => (...args: Parameters<typeof units>) => string;
 //#endregion
-export { useUnit };
 //# sourceMappingURL=useUnit.d.ts.map

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

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

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

@@ -1,6 +1,6 @@
 import { FC, PropsWithChildren, ReactNode } from "react";
 //#region src/server/serverContext.d.ts
-declare const createServerContext: <T>(defaultValue?: T) => ServerContext<T>;
+export declare const createServerContext: <T>(defaultValue?: T) => ServerContext<T>;
 /**
  * Fetches a value present in a given server context.
  * Attempts to closely mimic the `useContext` API.
@@ -8,8 +8,8 @@ declare const createServerContext: <T>(defaultValue?: T) => ServerContext<T>;
  * @example
  * getServerContext(IntlayerServer);
  */
-declare const getServerContext: <T>({ _storage, _defaultValue }: ServerContext<T>) => T;
-type ServerContext<T> = FC<PropsWithChildren<{
+export declare const getServerContext: <T>({ _storage, _defaultValue }: ServerContext<T>) => T;
+export type ServerContext<T> = FC<PropsWithChildren<{
   value?: T;
 }>> & {
   Provider: FC<PropsWithChildren<{
@@ -24,5 +24,4 @@ type ServerContext<T> = FC<PropsWithChildren<{
   _defaultValue: T | undefined;
 };
 //#endregion
-export { ServerContext, createServerContext, getServerContext };
 //# sourceMappingURL=serverContext.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"serverContext.d.ts","names":[],"sources":["../../../src/server/serverContext.tsx"],"mappings":";;cAiBa,sBAAuB,GAAC,eAAkB,MAAI,cAAc;;;;;;;;cAqC5D,mBAAoB,KAAC,UAAA,iBAG/B,cAAc,OAAE;KAOP,cAAc,KAAK,GAAG;EAAoB,QAAQ;;EAC5D,UAAU,GAAG;IAAoB,QAAQ;;EACzC,UAAU,GACR;IAAoB,WAAW,SAAS,kBAAkB;;EAE5D;IAAkB,OAAO;;EACzB,eAAe"}
+{"version":3,"file":"serverContext.d.ts","names":[],"sources":["../../../src/server/serverContext.tsx"],"mappings":";;qBAiBa,sBAAuB,GAAC,eAAkB,MAAI,cAAc;;;;;;;;qBAqC5D,mBAAoB,KAAC,UAAA,iBAG/B,cAAc,OAAE;YAOP,cAAc,KAAK,GAAG;EAAoB,QAAQ;;EAC5D,UAAU,GAAG;IAAoB,QAAQ;;EACzC,UAAU,GACR;IAAoB,WAAW,SAAS,kBAAkB;;EAE5D;IAAkB,OAAO;;EACzB,eAAe"}

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

@@ -21,7 +21,6 @@ import { DeclaredLocales, LocalesValues, StrictModeLocaleMap } from "@intlayer/t
  * - 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 t: <Content = string, L extends LocalesValues = DeclaredLocales>(multilangContent: StrictModeLocaleMap<Content>, locale?: L) => Content;
+export declare const t: <Content = string, L extends LocalesValues = DeclaredLocales>(multilangContent: StrictModeLocaleMap<Content>, locale?: L) => Content;
 //#endregion
-export { t };
 //# sourceMappingURL=t.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"t.d.ts","names":[],"sources":["../../../src/server/t.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cA8Ba,IAAK,kBAAkB,UAAU,gBAAgB,iBAAe,kBACzD,oBAAoB,UAAQ,SACrC,MAAC"}
+{"version":3,"file":"t.d.ts","names":[],"sources":["../../../src/server/t.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;qBA8Ba,IAAK,kBAAkB,UAAU,gBAAgB,iBAAe,kBACzD,oBAAoB,UAAQ,SACrC,MAAC"}

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

@@ -9,7 +9,6 @@ import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup } from
  * If the locale is not provided (directly or through the selector), it will
  * use the locale from the server context
  */
-declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A, fallbackLocale?: DeclaredLocales) => import("@intlayer/core/interpreter").DeepTransformContent<import("@intlayer/types").ResolveQualifiedDictionaryContent<T, A>, IInterpreterPluginState, import("@intlayer/types").ExtractSelectorLocale<A>>;
+export declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A, fallbackLocale?: DeclaredLocales) => import("@intlayer/core/interpreter").DeepTransformContent<import("@intlayer/types").ResolveQualifiedDictionaryContent<T, A>, IInterpreterPluginState, import("@intlayer/types").ExtractSelectorLocale<A>>;
 //#endregion
-export { useDictionary };
 //# sourceMappingURL=useDictionary.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/server/useDictionary.ts"],"mappings":";;;;;;;;;;;cAyBa,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,GAAC,iBACH,yDAAe,+CAAA,kCAAA,GAAA,IAAA,mDAAA,sBAAA"}
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/server/useDictionary.ts"],"mappings":";;;;;;;;;;;qBAyBa,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,GAAC,iBACH,yDAAe,+CAAA,kCAAA,GAAA,IAAA,mDAAA,sBAAA"}

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

@@ -7,7 +7,6 @@ import { Dictionary } from "@intlayer/types/dictionary";
  *
  * If the locale is not provided, it will use the locale from the server context
  */
-declare const useDictionaryAsync: <const T extends Dictionary, const L extends LocalesValues = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, locale?: L, fallbackLocale?: DeclaredLocales) => Promise<import("@intlayer/core/interpreter").DeepTransformContent<import("@intlayer/types").ResolveQualifiedDictionaryContent<T, L>, IInterpreterPluginState, import("@intlayer/types").ExtractSelectorLocale<L>>>;
+export declare const useDictionaryAsync: <const T extends Dictionary, const L extends LocalesValues = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, locale?: L, fallbackLocale?: DeclaredLocales) => Promise<import("@intlayer/core/interpreter").DeepTransformContent<import("@intlayer/types").ResolveQualifiedDictionaryContent<T, L>, IInterpreterPluginState, import("@intlayer/types").ExtractSelectorLocale<L>>>;
 //#endregion
-export { useDictionaryAsync };
 //# sourceMappingURL=useDictionaryAsync.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryAsync.d.ts","names":[],"sources":["../../../src/server/useDictionaryAsync.ts"],"mappings":";;;;;;;;;cAgBa,2BACL,UAAU,kBACV,UAAU,gBAAgB,iBAAe,mBAE5B,0BAA0B,QAAQ,KAAG,SAC/C,GAAC,iBACO,oBAAe,6CAAA,+CAAA,kCAAA,GAAA,IAAA,mDAAA,sBAAA"}
+{"version":3,"file":"useDictionaryAsync.d.ts","names":[],"sources":["../../../src/server/useDictionaryAsync.ts"],"mappings":";;;;;;;;;qBAgBa,2BACL,UAAU,kBACV,UAAU,gBAAgB,iBAAe,mBAE5B,0BAA0B,QAAQ,KAAG,SAC/C,GAAC,iBACO,oBAAe,6CAAA,+CAAA,kCAAA,GAAA,IAAA,mDAAA,sBAAA"}

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

@@ -13,7 +13,6 @@ import { QualifiedDynamicLoaderMap } from "@intlayer/core/dictionaryManipulator"
  * If the locale is not provided (directly or through the selector), the server
  * context locale is used.
  */
-declare const useDictionaryDynamic: <const T extends Dictionary, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>> | QualifiedDynamicLoaderMap, key: string, localeOrSelector?: A, fallbackLocale?: DeclaredLocales) => any;
+export declare const useDictionaryDynamic: <const T extends Dictionary, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>> | QualifiedDynamicLoaderMap, key: string, localeOrSelector?: A, fallbackLocale?: DeclaredLocales) => any;
 //#endregion
-export { useDictionaryDynamic };
 //# sourceMappingURL=useDictionaryDynamic.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/server/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;;;;cAwCa,6BACL,UAAU,kBACV,UAAU,gBAAgB,qBAAqB,iBAAe,mBAGhE,0BAA0B,QAAQ,MAClC,2BAAyB,aAClB,mBACQ,GAAC,iBACH"}
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/server/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;;;;qBAwCa,6BACL,UAAU,kBACV,UAAU,gBAAgB,qBAAqB,iBAAe,mBAGhE,0BAA0B,QAAQ,MAClC,2BAAyB,aAClB,mBACQ,GAAC,iBACH"}

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

@@ -18,7 +18,6 @@ import { GetSubPath } from "@intlayer/types/dictionary";
  * const nestedContent = t('section.subtitle'); // Returns 'IndexPage.section.subtitle'
  * ```
  */
-declare const useI18n: <T extends DictionaryKeys>(namespace: T, locale?: LocalesValues) => <P extends ValidDotPathsFor<T>>(path: P) => GetSubPath<DeepTransformContent<DictionaryRegistryContent<T>>, P>;
+export declare const useI18n: <T extends DictionaryKeys>(namespace: T, locale?: LocalesValues) => <P extends ValidDotPathsFor<T>>(path: P) => GetSubPath<DeepTransformContent<DictionaryRegistryContent<T>>, P>;
 //#endregion
-export { useI18n };
 //# sourceMappingURL=useI18n.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useI18n.d.ts","names":[],"sources":["../../../src/server/useI18n.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cA2Ba,UAAW,UAAU,gBAAc,WACnC,GAAC,SACH,mBAUE,UAAU,iBAAiB,IAAE,MAChC,MACL,WAAW,qBAAqB,0BAA0B,KAAK"}
+{"version":3,"file":"useI18n.d.ts","names":[],"sources":["../../../src/server/useI18n.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBA2Ba,UAAW,UAAU,gBAAc,WACnC,GAAC,SACH,mBAUE,UAAU,iBAAiB,IAAE,MAChC,MACL,WAAW,qBAAqB,0BAA0B,KAAK"}

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

@@ -9,7 +9,6 @@ import { DeclaredLocales, DictionaryKeys, DictionarySelectorForKey, LocalesValue
  *
  * If the locale is not provided, it will use the locale from the server context
  */
-declare const useIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A, fallbackLocale?: DeclaredLocales) => import("@intlayer/core/interpreter").DeepTransformContent<import("@intlayer/types").DictionaryRegistryResult<T, A>, IInterpreterPluginState, import("@intlayer/types").ExtractSelectorLocale<A>>;
+export declare const useIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A, fallbackLocale?: DeclaredLocales) => import("@intlayer/core/interpreter").DeepTransformContent<import("@intlayer/types").DictionaryRegistryResult<T, A>, IInterpreterPluginState, import("@intlayer/types").ExtractSelectorLocale<A>>;
 //#endregion
-export { useIntlayer };
 //# sourceMappingURL=useIntlayer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/server/useIntlayer.ts"],"mappings":";;;;;;;;;;;cAuBa,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,GAAC,iBACH,yDAAe,+CAAA,yBAAA,GAAA,IAAA,mDAAA,sBAAA"}
+{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/server/useIntlayer.ts"],"mappings":";;;;;;;;;;;qBAuBa,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,GAAC,iBACH,yDAAe,+CAAA,yBAAA,GAAA,IAAA,mDAAA,sBAAA"}

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

@@ -1,5 +1,4 @@
 //#region src/server/useLoadDynamic.d.ts
-declare const useLoadDynamic: <T>(_key: string, promise: Promise<T>) => T;
+export declare const useLoadDynamic: <T>(_key: string, promise: Promise<T>) => T;
 //#endregion
-export { useLoadDynamic };
 //# sourceMappingURL=useLoadDynamic.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useLoadDynamic.d.ts","names":[],"sources":["../../../src/server/useLoadDynamic.ts"],"mappings":";cAEa,iBAAkB,GAAC,cAAc,SAAW,QAAQ,OAAK"}
+{"version":3,"file":"useLoadDynamic.d.ts","names":[],"sources":["../../../src/server/useLoadDynamic.ts"],"mappings":";qBAEa,iBAAkB,GAAC,cAAc,SAAW,QAAQ,OAAK"}

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

@@ -1,6 +1,6 @@
 import { DeclaredLocales } from "@intlayer/types/module_augmentation";
 //#region src/server/useLocale.d.ts
-type UseLocaleResult = {
+export type UseLocaleResult = {
   locale: DeclaredLocales;
   defaultLocale: DeclaredLocales;
   availableLocales: DeclaredLocales[];
@@ -10,7 +10,6 @@ type UseLocaleResult = {
  *
  * If the locale is not provided, it will use the locale from the server context
  */
-declare const useLocale: () => UseLocaleResult;
+export declare const useLocale: () => UseLocaleResult;
 //#endregion
-export { UseLocaleResult, useLocale };
 //# sourceMappingURL=useLocale.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/server/useLocale.ts"],"mappings":";;KAKY;EACV,QAAQ;EACR,eAAe;EACf,kBAAkB;;;;;;;cAQP,iBAAgB"}
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/server/useLocale.ts"],"mappings":";;YAKY;EACV,QAAQ;EACR,eAAe;EACf,kBAAkB;;;;;;;qBAQP,iBAAgB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-intlayer",
-  "version": "9.4.2",
+  "version": "9.4.4",
   "private": false,
   "description": "Easily internationalize i18n your React applications with type-safe multilingual content management.",
   "keywords": [
@@ -132,12 +132,12 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "9.4.2",
-    "@intlayer/config": "9.4.2",
-    "@intlayer/core": "9.4.2",
-    "@intlayer/dictionaries-entry": "9.4.2",
-    "@intlayer/editor": "9.4.2",
-    "@intlayer/types": "9.4.2"
+    "@intlayer/api": "9.4.4",
+    "@intlayer/config": "9.4.4",
+    "@intlayer/core": "9.4.4",
+    "@intlayer/dictionaries-entry": "9.4.4",
+    "@intlayer/editor": "9.4.4",
+    "@intlayer/types": "9.4.4"
   },
   "devDependencies": {
     "@craco/types": "7.1.0",
@@ -149,16 +149,16 @@
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",
     "rimraf": "6.1.3",
-    "tsdown": "0.22.14",
+    "tsdown": "0.23.0",
     "typescript": "7.0.2",
-    "vitest": "4.1.11"
+    "vitest": "5.0.0"
   },
   "peerDependencies": {
     "react": ">=16.0.0",
     "react-dom": ">=16.0.0"
   },
   "optionalDependencies": {
-    "@intlayer/analytics": "9.4.2"
+    "@intlayer/analytics": "9.4.4"
   },
   "engines": {
     "node": ">=14.18"