@intlayer/use-intl 9.4.3 → 9.5.0

package/README.md

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

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

@@ -10,12 +10,12 @@ import { IntlProvider as IntlProvider$1 } from "use-intl";
  * `getMessageFallback` are accepted for API compatibility but have no effect —
  * Intlayer uses its own compiled dictionaries.
  */
-declare const IntlProvider: typeof IntlProvider$1;
+export declare const IntlProvider: typeof IntlProvider$1;
 /**
  * Props accepted by {@link IntlProvider}. `messages` is deprecated — Intlayer
  * loads content from compiled dictionaries automatically.
  */
-type IntlProviderProps = Omit<ComponentProps<typeof IntlProvider$1>, 'messages' | 'locale'> & {
+export type IntlProviderProps = Omit<ComponentProps<typeof IntlProvider$1>, 'messages' | 'locale'> & {
   /**
    * @deprecated has no use case with intlayer. Messages are loaded
    * automatically under the hood for bundle optimization reason.
@@ -25,5 +25,4 @@ type IntlProviderProps = Omit<ComponentProps<typeof IntlProvider$1>, 'messages'
   locale: LocalesValues;
 };
 //#endregion
-export { IntlProvider, IntlProviderProps };
 //# sourceMappingURL=IntlProvider.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IntlProvider.d.ts","names":[],"sources":["../../../src/client/IntlProvider.tsx"],"mappings":";;;;;;;;;;;;cAkBa,qBAAqB;;;;;KAiCtB,oBAAoB,KAC9B,sBAAsB;;;;;EAOtB;;EAEA,QAAQ"}
+{"version":3,"file":"IntlProvider.d.ts","names":[],"sources":["../../../src/client/IntlProvider.tsx"],"mappings":";;;;;;;;;;;;qBAkBa,qBAAqB;;;;;YAiCtB,oBAAoB,KAC9B,sBAAsB;;;;;EAOtB;;EAEA,QAAQ"}

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

@@ -4,12 +4,12 @@ import { useFormatter as useFormatter$1, useMessages as useMessages$1, useNow as
  * Drop-in for use-intl's `useNow`.
  * Returns the current `Date`. The `updateInterval` option is ignored.
  */
-declare const useNow: typeof useNow$1;
+export declare const useNow: typeof useNow$1;
 /**
  * Drop-in for use-intl's `useTimeZone`.
  * Returns the system time zone resolved from `Intl.DateTimeFormat`.
  */
-declare const useTimeZone: typeof useTimeZone$1;
+export declare const useTimeZone: typeof useTimeZone$1;
 /**
  * Drop-in for use-intl's `useMessages`.
  *
@@ -17,14 +17,13 @@ declare const useTimeZone: typeof useTimeZone$1;
  * Messages are loaded automatically under the hood.
  * @returns An empty object.
  */
-declare const useMessages: typeof useMessages$1;
+export declare const useMessages: typeof useMessages$1;
 /**
  * Drop-in for use-intl's `useFormatter`.
  * Returns locale-aware formatters backed by the native `Intl.*` APIs:
  * `dateTime`, `number`, `dateTimeRange`, `relativeTime`, `list`, and
  * `displayName`.
  */
-declare const useFormatter: typeof useFormatter$1;
+export declare const useFormatter: typeof useFormatter$1;
 //#endregion
-export { useFormatter, useMessages, useNow, useTimeZone };
 //# sourceMappingURL=helpers.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","names":[],"sources":["../../../src/client/helpers.ts"],"mappings":";;;;;;cAkBa,eAAe;;;;;cAMf,oBAAoB;;;;;;;;cAUpB,oBAAoB;;;;;;;cAiBpB,qBAAqB"}
+{"version":3,"file":"helpers.d.ts","names":[],"sources":["../../../src/client/helpers.ts"],"mappings":";;;;;;qBAkBa,eAAe;;;;;qBAMf,oBAAoB;;;;;;;;qBAUpB,oBAAoB;;;;;;;qBAiBpB,qBAAqB"}

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

@@ -9,7 +9,7 @@ import { useTranslations } from "./useTranslations.js";
  * @internal Private use-intl export, kept so aliased `_useExtracted` imports
  * resolve. Not part of the supported public surface.
  */
-declare const _useExtracted: () => Record<string, never>;
+export declare const _useExtracted: () => Record<string, never>;
 //#endregion
-export { IntlProvider, type IntlProviderProps, _useExtracted, useDictionary, useDictionaryDynamic, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };
+export { IntlProvider, type IntlProviderProps, useDictionary, useDictionaryDynamic, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };
 //# sourceMappingURL=index.d.ts.map

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

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

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

@@ -5,7 +5,6 @@ import { useLocale as useLocale$1 } from "use-intl";
  *
  * Returns the active locale string from Intlayer's client context.
  */
-declare const useLocale: typeof useLocale$1;
+export declare const useLocale: typeof useLocale$1;
 //#endregion
-export { 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":";;;;;;;cAUa,kBAAkB"}
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/client/useLocale.ts"],"mappings":";;;;;;;qBAUa,kBAAkB"}

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

@@ -38,7 +38,6 @@ type UseTranslations = {
  * t.rich('terms', { link: (chunks) => <a href="/terms">{chunks}</a> });
  * ```
  */
-declare const useTranslations: UseTranslations;
+export declare const useTranslations: UseTranslations;
 //#endregion
-export { useTranslations };
 //# sourceMappingURL=useTranslations.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useTranslations.d.ts","names":[],"sources":["../../../src/client/useTranslations.ts"],"mappings":";;;;;;;;;;;;;KAyBK;GACF,UAAU,gBAAgB,WAAW,IAAI,kBAAkB;GAC3D,iCACC,WAAW,IACV,8BAA8B;MAC7B;;;;;;;;;;;;;;;;;;;;;;;;cAyBO,iBAOP"}
+{"version":3,"file":"useTranslations.d.ts","names":[],"sources":["../../../src/client/useTranslations.ts"],"mappings":";;;;;;;;;;;;;KAyBK;GACF,UAAU,gBAAgB,WAAW,IAAI,kBAAkB;GAC3D,iCACC,WAAW,IACV,8BAA8B;MAC7B;;;;;;;;;;;;;;;;;;;;;;;;qBAyBO,iBAOP"}

package/dist/types/core/createFormatter.d.ts

@@ -14,7 +14,6 @@ import { createFormatter as createFormatter$1 } from "use-intl";
  * format.number(1234.5, { style: 'currency', currency: 'USD' });
  * ```
  */
-declare const createFormatter: typeof createFormatter$1;
+export declare const createFormatter: typeof createFormatter$1;
 //#endregion
-export { createFormatter };
 //# sourceMappingURL=createFormatter.d.ts.map

package/dist/types/core/createFormatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createFormatter.d.ts","names":[],"sources":["../../../src/core/createFormatter.ts"],"mappings":";;;;;;;;;;;;;;;;cAiBa,wBAAwB"}
+{"version":3,"file":"createFormatter.d.ts","names":[],"sources":["../../../src/core/createFormatter.ts"],"mappings":";;;;;;;;;;;;;;;;qBAiBa,wBAAwB"}

package/dist/types/core/createTranslator.d.ts

@@ -8,7 +8,7 @@ import { DictionaryKeys, LocalesValues } from "@intlayer/types/module_augmentati
  * `timeZone`, `onError`, and `getMessageFallback` have no effect — Intlayer
  * resolves content from its own compiled dictionaries.
  */
-type CreateTranslatorConfig<N extends DictionaryKeys> = {
+export type CreateTranslatorConfig<N extends DictionaryKeys> = {
   /** The locale dictionaries are resolved for. */
   locale: LocalesValues;
   /** A bare dictionary key, or a nested `'dictionary.scope'` namespace. */
@@ -52,7 +52,6 @@ type CreateTranslator = {
  * t('items', { count: 3 }); // ICU plural
  * ```
  */
-declare const createTranslator: CreateTranslator;
+export declare const createTranslator: CreateTranslator;
 //#endregion
-export { CreateTranslatorConfig, createTranslator };
 //# sourceMappingURL=createTranslator.d.ts.map

package/dist/types/core/createTranslator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createTranslator.d.ts","names":[],"sources":["../../../src/core/createTranslator.ts"],"mappings":";;;;;;;;;;KAqBY,uBAAuB,UAAU;;EAE3C,QAAQ;;EAER,YAAY;;;;;EAKZ;IACE;;;;;;;;;;;KAYC;GACF,UAAU,gBACT,QAAQ,uBAAuB;IAAO,WAAW;MAChD,kBAAkB;GACpB,iCACC,QAAQ,uBAAuB;IAAoB,WAAW;MAC7D,8BAA8B;GAChC,QAAQ,uBAAuB,kBAAkB;;;;;;;;;;;;;;;;cAiBvC,kBAaP"}
+{"version":3,"file":"createTranslator.d.ts","names":[],"sources":["../../../src/core/createTranslator.ts"],"mappings":";;;;;;;;;;YAqBY,uBAAuB,UAAU;;EAE3C,QAAQ;;EAER,YAAY;;;;;EAKZ;IACE;;;;;;;;;;;KAYC;GACF,UAAU,gBACT,QAAQ,uBAAuB;IAAO,WAAW;MAChD,kBAAkB;GACpB,iCACC,QAAQ,uBAAuB;IAAoB,WAAW;MAC7D,8BAA8B;GAChC,QAAQ,uBAAuB,kBAAkB;;;;;;;;;;;;;;;;qBAiBvC,kBAaP"}

package/dist/types/core/errors.d.ts

@@ -6,7 +6,7 @@
  * aliased to this package at build time, so importing its runtime value would
  * be circular.
  */
-declare enum IntlErrorCode {
+export declare enum IntlErrorCode {
   MISSING_MESSAGE = "MISSING_MESSAGE",
   MISSING_FORMAT = "MISSING_FORMAT",
   ENVIRONMENT_FALLBACK = "ENVIRONMENT_FALLBACK",
@@ -21,11 +21,10 @@ declare enum IntlErrorCode {
  * Carries the {@link IntlErrorCode} and the original message, matching
  * use-intl's error shape so consumer `onError` handlers keep working.
  */
-declare class IntlError extends Error {
+export declare class IntlError extends Error {
   readonly code: IntlErrorCode;
   readonly originalMessage: string | undefined;
   constructor(code: IntlErrorCode, originalMessage?: string);
 }
 //#endregion
-export { IntlError, IntlErrorCode };
 //# sourceMappingURL=errors.d.ts.map

package/dist/types/core/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","names":[],"sources":["../../../src/core/errors.ts"],"mappings":";;;;;;;;aAOY;EACV;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;cASW,kBAAkB;WACb,MAAM;WACN;EAEhB,YAAY,MAAM,eAAe"}
+{"version":3,"file":"errors.d.ts","names":[],"sources":["../../../src/core/errors.ts"],"mappings":";;;;;;;;oBAOY;EACV;EACA;EACA;EACA;EACA;EACA;EACA;;;;;;;;qBASW,kBAAkB;WACb,MAAM;WACN;EAEhB,YAAY,MAAM,eAAe"}

package/dist/types/core/hasLocale.d.ts

@@ -11,7 +11,6 @@ import { hasLocale as hasLocale$1 } from "use-intl";
  * if (hasLocale(['en', 'fr'], requested)) { … }
  * ```
  */
-declare const hasLocale: typeof hasLocale$1;
+export declare const hasLocale: typeof hasLocale$1;
 //#endregion
-export { hasLocale };
 //# sourceMappingURL=hasLocale.d.ts.map

package/dist/types/core/hasLocale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hasLocale.d.ts","names":[],"sources":["../../../src/core/hasLocale.ts"],"mappings":";;;;;;;;;;;;;cAca,kBAAkB"}
+{"version":3,"file":"hasLocale.d.ts","names":[],"sources":["../../../src/core/hasLocale.ts"],"mappings":";;;;;;;;;;;;;qBAca,kBAAkB"}

package/dist/types/core/initializeConfig.d.ts

@@ -7,7 +7,6 @@ import { initializeConfig as initializeConfig$1 } from "use-intl";
  * `formats` are not consumed at runtime (content comes from compiled
  * dictionaries) but the shape is preserved so callers keep type-checking.
  */
-declare const initializeConfig: typeof initializeConfig$1;
+export declare const initializeConfig: typeof initializeConfig$1;
 //#endregion
-export { initializeConfig };
 //# sourceMappingURL=initializeConfig.d.ts.map

package/dist/types/core/initializeConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initializeConfig.d.ts","names":[],"sources":["../../../src/core/initializeConfig.ts"],"mappings":";;;;;;;;;cASa,yBAAyB"}
+{"version":3,"file":"initializeConfig.d.ts","names":[],"sources":["../../../src/core/initializeConfig.ts"],"mappings":";;;;;;;;;qBASa,yBAAyB"}

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

@@ -15,7 +15,7 @@ import { intlayer } from "vite-intlayer";
  * });
  * ```
  */
-declare const useIntlVitePlugin: (options?: Parameters<typeof intlayer>[0]) => PluginOption[];
+export declare const useIntlVitePlugin: (options?: Parameters<typeof intlayer>[0]) => PluginOption[];
 //#endregion
-export { useIntlVitePlugin as default, useIntlVitePlugin };
+export { useIntlVitePlugin as default };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/plugin/index.ts"],"mappings":";;;;;;;;;;;;;;;;;cAuBa,oBAAiB,UAClB,kBAAkB,iBAC3B"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/plugin/index.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAuBa,oBAAiB,UAClB,kBAAkB,iBAC3B"}

package/dist/types/shared/intlFormatter.d.ts

@@ -1,7 +1,7 @@
 import { createFormatter } from "use-intl";
 //#region src/shared/intlFormatter.d.ts
 /** The formatter object shape exposed by use-intl. */
-type Formatter = ReturnType<typeof createFormatter>;
+export type Formatter = ReturnType<typeof createFormatter>;
 /**
  * Builds a use-intl compatible formatter backed by the native `Intl.*` APIs
  * for the given locale.
@@ -12,7 +12,6 @@ type Formatter = ReturnType<typeof createFormatter>;
  * @returns A formatter exposing `dateTime`, `number`, `dateTimeRange`,
  *   `relativeTime`, `list`, and `displayName`.
  */
-declare const buildIntlFormatter: (locale: string) => Formatter;
+export declare const buildIntlFormatter: (locale: string) => Formatter;
 //#endregion
-export { Formatter, buildIntlFormatter };
 //# sourceMappingURL=intlFormatter.d.ts.map

package/dist/types/shared/intlFormatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intlFormatter.d.ts","names":[],"sources":["../../../src/shared/intlFormatter.ts"],"mappings":";;;KAGY,YAAY,kBAAkB;;;;;;;;;;;cA0B7B,qBAAkB,mBAAqB"}
+{"version":3,"file":"intlFormatter.d.ts","names":[],"sources":["../../../src/shared/intlFormatter.ts"],"mappings":";;;YAGY,YAAY,kBAAkB;;;;;;;;;;;qBA0B7B,qBAAkB,mBAAqB"}

package/dist/types/shared/namespaceTranslator.d.ts

@@ -3,9 +3,9 @@ import { ReactNode } from "react";
 import { MessageValues, navigatePath } from "@intlayer/core/messageFormat";
 //#region src/shared/namespaceTranslator.d.ts
 /** Chunk renderer used by `t.rich()` — maps tag children to a React node. */
-type RichChunkRenderer = (chunks: ReactNode) => ReactNode;
+export type RichChunkRenderer = (chunks: ReactNode) => ReactNode;
 /** Chunk renderer used by `t.markup()` — maps tag children to a string. */
-type MarkupChunkRenderer = (chunks: string) => string;
+export type MarkupChunkRenderer = (chunks: string) => string;
 /**
  * The untyped runtime translator shared by `useTranslations` (React hook) and
  * `createTranslator` (non-React core).
@@ -22,7 +22,7 @@ type MarkupChunkRenderer = (chunks: string) => string;
  * @param namespace - Optional dictionary key, optionally with a nested scope.
  * @returns A translate function augmented with `has`, `raw`, `rich`, `markup`.
  */
-declare const createNamespaceTranslator: (locale: LocalesValues, namespace?: string) => ((key: string, values?: MessageValues) => string) & {
+export declare const createNamespaceTranslator: (locale: LocalesValues, namespace?: string) => ((key: string, values?: MessageValues) => string) & {
   /** Returns `true` if the given key exists in the namespace. */
   has: (key: string) => boolean;
   /** Returns the raw unprocessed content for the given key. */
@@ -50,7 +50,7 @@ declare const createNamespaceTranslator: (locale: LocalesValues, namespace?: str
  *   (`useTranslations('about.counter')` → content of `about`, prefix `counter`).
  * @returns A translate function augmented with `has`, `raw`, `rich`, `markup`.
  */
-declare const createDictionaryTranslator: (locale: LocalesValues, content: unknown, namespacePrefix?: string) => ((key: string, values?: MessageValues) => string) & {
+export declare const createDictionaryTranslator: (locale: LocalesValues, content: unknown, namespacePrefix?: string) => ((key: string, values?: MessageValues) => string) & {
   /** Returns `true` if the given key exists in the namespace. */
   has: (key: string) => boolean;
   /** Returns the raw unprocessed content for the given key. */
@@ -66,7 +66,7 @@ declare const createDictionaryTranslator: (locale: LocalesValues, content: unkno
    */
   markup: (key: string, values?: Record<string, unknown>) => string;
 };
-type CompatTranslator = ReturnType<typeof createNamespaceTranslator>;
+export type CompatTranslator = ReturnType<typeof createNamespaceTranslator>;
 //#endregion
-export { CompatTranslator, MarkupChunkRenderer, RichChunkRenderer, createDictionaryTranslator, createNamespaceTranslator, navigatePath };
+export { navigatePath };
 //# sourceMappingURL=namespaceTranslator.d.ts.map

package/dist/types/shared/namespaceTranslator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"namespaceTranslator.d.ts","names":[],"sources":["../../../src/shared/namespaceTranslator.tsx"],"mappings":";;;;;KAkBY,qBAAqB,QAAQ,cAAc;;KAG3C,uBAAuB;;;;;;;;;;;;;;;;;cA0EtB,4BAAyB,QAC5B,eAAa,yBACH,aAgHY,SAAW;;EAK5B,MAAA;;EAGA,MAAA;;;;;EAMC,OAAA,aAAM,SAAW,4BAA0B;;;;;EAWzC,SAAA,aAAM,SAAW;;;;;;;;;;;;;;cA/DtB,6BAA0B,QAC7B,eAAa,kBACL,+BACQ,aAmCM,SAAW;;EAK5B,MAAA;;EAGA,MAAA;;;;;EAMC,OAAA,aAAM,SAAW,4BAA0B;;;;;EAWzC,SAAA,aAAM,SAAW;;KASvB,mBAAmB,kBAAkB"}
+{"version":3,"file":"namespaceTranslator.d.ts","names":[],"sources":["../../../src/shared/namespaceTranslator.tsx"],"mappings":";;;;;YAkBY,qBAAqB,QAAQ,cAAc;;YAG3C,uBAAuB;;;;;;;;;;;;;;;;;qBA0EtB,4BAAyB,QAC5B,eAAa,yBACH,aAgHY,SAAW;;EAK5B,MAAA;;EAGA,MAAA;;;;;EAMC,OAAA,aAAM,SAAW,4BAA0B;;;;;EAWzC,SAAA,aAAM,SAAW;;;;;;;;;;;;;;qBA/DtB,6BAA0B,QAC7B,eAAa,kBACL,+BACQ,aAmCM,SAAW;;EAK5B,MAAA;;EAGA,MAAA;;;;;EAMC,OAAA,aAAM,SAAW,4BAA0B;;;;;EAWzC,SAAA,aAAM,SAAW;;YASvB,mBAAmB,kBAAkB"}

package/dist/types/shared/translateFunctionTypes.d.ts

@@ -8,18 +8,18 @@ import { ValidDotPathsFor } from "@intlayer/core/transpiler";
  * The interpreter-resolved content type at dot-path `P` of dictionary `N` —
  * the same type strength as the base `useIntlayer` hook.
  */
-type ContentAtPath<N extends DictionaryKeys, P> = GetNestingResult<N, P>;
+export type ContentAtPath<N extends DictionaryKeys, P> = GetNestingResult<N, P>;
 /**
  * The value returned by `t()` for key `P` of dictionary `N`: string literals
  * declared in the dictionary keep their literal type (matching the strength of
  * `useIntlayer`), every other node resolves to `string` at runtime.
  */
-type TranslatedValue<N extends DictionaryKeys, P> = ContentAtPath<N, P> extends string ? ContentAtPath<N, P> : string;
+export type TranslatedValue<N extends DictionaryKeys, P> = ContentAtPath<N, P> extends string ? ContentAtPath<N, P> : string;
 /**
  * The dot-paths of dictionary `D` relative to the nested namespace scope
  * `Prefix` (`useTranslations('about.counter')` → paths under `about.counter`).
  */
-type ScopedDotPaths<D extends DictionaryKeys, Prefix extends string> = ValidDotPathsFor<D> extends (infer AllPaths) ? AllPaths extends `${Prefix}.${infer RelativePath}` ? RelativePath : never : never;
+export type ScopedDotPaths<D extends DictionaryKeys, Prefix extends string> = ValidDotPathsFor<D> extends (infer AllPaths) ? AllPaths extends `${Prefix}.${infer RelativePath}` ? RelativePath : never : never;
 /**
  * The translation function returned for a bare dictionary key namespace.
  *
@@ -30,7 +30,7 @@ type ScopedDotPaths<D extends DictionaryKeys, Prefix extends string> = ValidDotP
  * - `rich(key, values)` — resolves `<tag>chunks</tag>` markup to React nodes.
  * - `markup(key, values)` — resolves `<tag>chunks</tag>` markup to a string.
  */
-type TranslateFunction<N extends DictionaryKeys> = {
+export type TranslateFunction<N extends DictionaryKeys> = {
   /** Translate a key to a string, with optional ICU interpolation params. */
   <P extends ValidDotPathsFor<N>>(key: P, params?: Record<string, unknown>): TranslatedValue<N, P>;
   /** Returns `true` if the given key exists in the namespace. */
@@ -47,7 +47,7 @@ type TranslateFunction<N extends DictionaryKeys> = {
  * namespace: keys are relative dot-paths under the scope, and return types are
  * resolved against the absolute path in the dictionary.
  */
-type ScopedTranslateFunction<D extends DictionaryKeys, Prefix extends string> = {
+export type ScopedTranslateFunction<D extends DictionaryKeys, Prefix extends string> = {
   /** Translate a scoped key to a string, with optional ICU interpolation params. */
   <P extends ScopedDotPaths<D, Prefix>>(key: P, params?: Record<string, unknown>): TranslatedValue<D, `${Prefix}.${P}`>;
   /** Returns `true` if the given key exists in the scoped namespace. */
@@ -65,9 +65,9 @@ type ScopedTranslateFunction<D extends DictionaryKeys, Prefix extends string> =
  * `'dictionary.scope'` namespace is split at the first dot and typed
  * relative to the scope, anything else falls back to loose typing.
  */
-type TranslateFunctionForNamespace<N extends string> = N extends DictionaryKeys ? TranslateFunction<N> : N extends `${infer D extends DictionaryKeys & string}.${infer Prefix}` ? ScopedTranslateFunction<D, Prefix> : LooseTranslateFunction;
+export type TranslateFunctionForNamespace<N extends string> = N extends DictionaryKeys ? TranslateFunction<N> : N extends `${infer D extends DictionaryKeys & string}.${infer Prefix}` ? ScopedTranslateFunction<D, Prefix> : LooseTranslateFunction;
 /** Loosely-typed function returned for untyped namespaces (root scope). */
-type LooseTranslateFunction = {
+export type LooseTranslateFunction = {
   (key: string, params?: Record<string, unknown>): string;
   has(key: string): boolean;
   raw(key: string): unknown;
@@ -75,5 +75,4 @@ type LooseTranslateFunction = {
   markup(key: string, values?: Record<string, MarkupChunkRenderer | string | number>): string;
 };
 //#endregion
-export { ContentAtPath, LooseTranslateFunction, ScopedDotPaths, ScopedTranslateFunction, TranslateFunction, TranslateFunctionForNamespace, TranslatedValue };
 //# sourceMappingURL=translateFunctionTypes.d.ts.map

package/dist/types/shared/translateFunctionTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"translateFunctionTypes.d.ts","names":[],"sources":["../../../src/shared/translateFunctionTypes.ts"],"mappings":";;;;;;;;;;KAaY,cAAc,UAAU,gBAAgB,KAAK,iBAAiB,GAAG;;;;;;KAOjE,gBAAgB,UAAU,gBAAgB,KACpD,cAAc,GAAG,oBAAoB,cAAc,GAAG;;;;;KAM5C,eAAe,UAAU,gBAAgB,yBACnD,iBAAiB,kBAAiB,YAC9B,oBAAoB,gBAAgB,iBAClC;;;;;;;;;;;KAcI,kBAAkB,UAAU;;GAErC,UAAU,iBAAiB,IAC1B,KAAK,GACL,SAAS,0BACR,gBAAgB,GAAG;;EAEtB,IAAI,UAAU,iBAAiB,IAAI,KAAK;;EAExC,IAAI,UAAU,iBAAiB,IAAI,KAAK,IAAI,cAAc,GAAG;;EAE7D,KAAK,UAAU,iBAAiB,IAC9B,KAAK,GACL,SAAS,eAAe,oBAAoB,aAC3C;;EAEH,OAAO,UAAU,iBAAiB,IAChC,KAAK,GACL,SAAS,eAAe;;;;;;;KAShB,wBACV,UAAU,gBACV;;GAGC,UAAU,eAAe,GAAG,SAC3B,KAAK,GACL,SAAS,0BACR,gBAAgB,MAAM,UAAU;;EAEnC,IAAI,UAAU,eAAe,GAAG,SAAS,KAAK;;EAE9C,IAAI,UAAU,eAAe,GAAG,SAC9B,KAAK,IACJ,cAAc,MAAM,UAAU;;EAEjC,KAAK,UAAU,eAAe,GAAG,SAC/B,KAAK,GACL,SAAS,eAAe,oBAAoB,aAC3C;;EAEH,OAAO,UAAU,eAAe,GAAG,SACjC,KAAK,GACL,SAAS,eAAe;;;;;;;;KAUhB,8BAA8B,oBACxC,UAAU,iBACN,kBAAkB,KAClB,mBAAmB,UAAU,iCAAiC,WAC5D,wBAAwB,GAAG,UAC3B;;KAGI;GACT,aAAa,SAAS;EACvB,IAAI;EACJ,IAAI;EACJ,KACE,aACA,SAAS,eAAe,oBAAoB,aAC3C;EACH,OACE,aACA,SAAS,eAAe"}
+{"version":3,"file":"translateFunctionTypes.d.ts","names":[],"sources":["../../../src/shared/translateFunctionTypes.ts"],"mappings":";;;;;;;;;;YAaY,cAAc,UAAU,gBAAgB,KAAK,iBAAiB,GAAG;;;;;;YAOjE,gBAAgB,UAAU,gBAAgB,KACpD,cAAc,GAAG,oBAAoB,cAAc,GAAG;;;;;YAM5C,eAAe,UAAU,gBAAgB,yBACnD,iBAAiB,kBAAiB,YAC9B,oBAAoB,gBAAgB,iBAClC;;;;;;;;;;;YAcI,kBAAkB,UAAU;;GAErC,UAAU,iBAAiB,IAC1B,KAAK,GACL,SAAS,0BACR,gBAAgB,GAAG;;EAEtB,IAAI,UAAU,iBAAiB,IAAI,KAAK;;EAExC,IAAI,UAAU,iBAAiB,IAAI,KAAK,IAAI,cAAc,GAAG;;EAE7D,KAAK,UAAU,iBAAiB,IAC9B,KAAK,GACL,SAAS,eAAe,oBAAoB,aAC3C;;EAEH,OAAO,UAAU,iBAAiB,IAChC,KAAK,GACL,SAAS,eAAe;;;;;;;YAShB,wBACV,UAAU,gBACV;;GAGC,UAAU,eAAe,GAAG,SAC3B,KAAK,GACL,SAAS,0BACR,gBAAgB,MAAM,UAAU;;EAEnC,IAAI,UAAU,eAAe,GAAG,SAAS,KAAK;;EAE9C,IAAI,UAAU,eAAe,GAAG,SAC9B,KAAK,IACJ,cAAc,MAAM,UAAU;;EAEjC,KAAK,UAAU,eAAe,GAAG,SAC/B,KAAK,GACL,SAAS,eAAe,oBAAoB,aAC3C;;EAEH,OAAO,UAAU,eAAe,GAAG,SACjC,KAAK,GACL,SAAS,eAAe;;;;;;;;YAUhB,8BAA8B,oBACxC,UAAU,iBACN,kBAAkB,KAClB,mBAAmB,UAAU,iCAAiC,WAC5D,wBAAwB,GAAG,UAC3B;;YAGI;GACT,aAAa,SAAS;EACvB,IAAI;EACJ,IAAI;EACJ,KACE,aACA,SAAS,eAAe,oBAAoB,aAC3C;EACH,OACE,aACA,SAAS,eAAe"}

package/dist/types/useDictionary.d.ts

@@ -26,7 +26,6 @@ type UseDictionary = {
  * import _abc from '.intlayer/dictionaries/about.json' with { type: 'json' };
  * const t = useDictionary(_abc);
  */
-declare const useDictionary: UseDictionary;
+export declare const useDictionary: UseDictionary;
 //#endregion
-export { useDictionary };
 //# sourceMappingURL=useDictionary.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../src/useDictionary.ts"],"mappings":";;;;;;;;;KAuBK;GACF,UAAU,YACT,YAAY,IACX,kBAAkB,WAAW;GAC/B,UAAU,YAAY,uBACrB,YAAY,GACZ,iBAAiB,SAChB,wBAAwB,WAAW,gBAAgB;;;;;;;;;;;;;;;;;cAkB3C,eAYP"}
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../src/useDictionary.ts"],"mappings":";;;;;;;;;KAuBK;GACF,UAAU,YACT,YAAY,IACX,kBAAkB,WAAW;GAC/B,UAAU,YAAY,uBACrB,YAAY,GACZ,iBAAiB,SAChB,wBAAwB,WAAW,gBAAgB;;;;;;;;;;;;;;;;;qBAkB3C,eAYP"}

package/dist/types/useDictionaryDynamic.d.ts

@@ -17,7 +17,6 @@ type UseDictionaryDynamic = {
  * Counterpart to {@link useDictionary} for dictionaries imported lazily per
  * locale. Used internally by the build-time optimization.
  */
-declare const useDictionaryDynamic: UseDictionaryDynamic;
+export declare const useDictionaryDynamic: UseDictionaryDynamic;
 //#endregion
-export { useDictionaryDynamic };
 //# sourceMappingURL=useDictionaryDynamic.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../src/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;KAwBK;GACF,UAAU,YAAY,UAAU,gBAC/B,mBAAmB,0BAA0B,QAAQ,KACrD,KAAK,IACJ,kBAAkB;GACpB,UAAU,YAAY,UAAU,gBAAgB,uBAC/C,mBAAmB,0BAA0B,QAAQ,KACrD,KAAK,GACL,iBAAiB,SAChB,wBAAwB,GAAG;;;;;;;;cASnB,sBAgBP"}
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../src/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;KAwBK;GACF,UAAU,YAAY,UAAU,gBAC/B,mBAAmB,0BAA0B,QAAQ,KACrD,KAAK,IACJ,kBAAkB;GACpB,UAAU,YAAY,UAAU,gBAAgB,uBAC/C,mBAAmB,0BAA0B,QAAQ,KACrD,KAAK,GACL,iBAAiB,SAChB,wBAAwB,GAAG;;;;;;;;qBASnB,sBAgBP"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/use-intl",
-  "version": "9.4.3",
+  "version": "9.5.0",
   "private": false,
   "description": "use-intl API adapter for intlayer — useTranslations, useLocale, useFormatter, IntlProvider, createTranslator backed by react-intlayer",
   "keywords": [
@@ -89,26 +89,26 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/config": "9.4.3",
-    "@intlayer/core": "9.4.3",
-    "@intlayer/dictionaries-entry": "9.4.3",
-    "@intlayer/engine": "9.4.3",
-    "@intlayer/types": "9.4.3",
-    "react-intlayer": "9.4.3",
-    "vite-intlayer": "9.4.3"
+    "@intlayer/config": "9.5.0",
+    "@intlayer/core": "9.5.0",
+    "@intlayer/dictionaries-entry": "9.5.0",
+    "@intlayer/engine": "9.5.0",
+    "@intlayer/types": "9.5.0",
+    "react-intlayer": "9.5.0",
+    "vite-intlayer": "9.5.0"
   },
   "devDependencies": {
-    "@types/node": "26.4.1",
+    "@types/node": "26.5.0",
     "@types/react": "19.2.18",
     "@utils/ts-config": "1.0.4",
     "@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",
-    "use-intl": "4.13.2",
+    "use-intl": "4.14.2",
     "vite": "8.2.2",
-    "vitest": "4.1.11"
+    "vitest": "5.0.0"
   },
   "peerDependencies": {
     "react": ">=16.0.0",