@intlayer/next-intl 9.0.0-canary.2 → 9.0.0-canary.21

package/dist/types/index.d.ts

@@ -1,9 +1,6 @@
 import { NextIntlClientProvider, NextIntlClientProviderProps } from "./client/NextIntlClientProvider.js";
-import { IntlProvider, useExtracted, useFormatter, useMessages, useNow, useTimeZone } from "./client/helpers.js";
-import { useDictionary } from "./useDictionary.js";
-import { useDictionaryDynamic } from "./useDictionaryDynamic.js";
 import { useLocale } from "./client/useLocale.js";
-import { useTranslations } from "./client/useTranslations.js";
-import { hasLocale } from "./hasLocale.js";
+import { IntlProvider, useDictionary, useDictionaryDynamic, useExtracted, useFormatter, useMessages, useNow, useTimeZone, useTranslations } from "./client/index.js";
 import { Routing, defineRouting } from "./routing.js";
-export { IntlProvider, NextIntlClientProvider, NextIntlClientProviderProps, type Routing, defineRouting, hasLocale, useDictionary, useDictionaryDynamic, useExtracted, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };
+import { IntlError, IntlErrorCode, createFormatter, createTranslator, hasLocale, initializeConfig } from "@intlayer/use-intl";
+export { IntlError, IntlErrorCode, IntlProvider, NextIntlClientProvider, type NextIntlClientProviderProps, type Routing, createFormatter, createTranslator, defineRouting, hasLocale, initializeConfig, useDictionary, useDictionaryDynamic, useExtracted, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };

package/dist/types/middleware.d.ts

@@ -1,5 +1,4 @@
 import _createMiddleware from "next-intl/middleware";
-
 //#region src/middleware.d.ts
 /**
  * Drop-in replacement for next-intl's `createMiddleware`.

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

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","names":[],"sources":["../../src/middleware.ts"],"mappings":";;;;;AAmBA;;;;;;;;;;;;;cAAa,gBAAA,SAAyB,iBAAA"}
+{"version":3,"file":"middleware.d.ts","names":[],"sources":["../../src/middleware.ts"],"mappings":";;;;;;;;;;;;;;;;;cAmBa,yBAAyB"}

package/dist/types/navigation/Link.d.ts

@@ -1,9 +1,6 @@
 import { NextIntlHref } from "./localizeHref.js";
-import * as _$react from "react";
 import { ComponentPropsWithoutRef } from "react";
-import * as _$next_link0 from "next/link";
 import NextLink from "next/link";
-
 //#region src/navigation/Link.d.ts
 /**
  * Props for the compat `Link`: identical to `next/link` except `href` accepts a
@@ -18,12 +15,12 @@ type LinkProps = Omit<ComponentPropsWithoutRef<typeof NextLink>, 'href' | 'local
  * `href` with the active locale (or the `locale` prop) before delegating to
  * `next/link`.
  */
-declare const Link: _$react.ForwardRefExoticComponent<Omit<Omit<Omit<_$react.AnchorHTMLAttributes<HTMLAnchorElement>, keyof _$next_link0.LinkProps<any>> & _$next_link0.LinkProps<any> & {
+declare const Link: import("react").ForwardRefExoticComponent<Omit<Omit<Omit<import("react").AnchorHTMLAttributes<HTMLAnchorElement>, keyof import("next/link").LinkProps<any>> & import("next/link").LinkProps<any> & {
   children?: React.ReactNode | undefined;
-} & _$react.RefAttributes<HTMLAnchorElement>, "ref">, "href" | "locale"> & {
+} & import("react").RefAttributes<HTMLAnchorElement>, "ref">, "href" | "locale"> & {
   href: NextIntlHref;
   locale?: string;
-} & _$react.RefAttributes<HTMLAnchorElement>>;
+} & import("react").RefAttributes<HTMLAnchorElement>>;
 //#endregion
 export { Link, LinkProps };
 //# sourceMappingURL=Link.d.ts.map

package/dist/types/navigation/Link.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Link.d.ts","names":[],"sources":["../../../src/navigation/Link.tsx"],"mappings":";;;;;;;;;;;KAWY,SAAA,GAAY,IAAA,CACtB,wBAAA,QAAgC,QAAA;EAGhC,IAAA,EAAM,YAAA;EACN,MAAA;AAAA;;;;;;cAQW,IAAA,UAAI,yBAAA,CAAA,IAAA,CAAA,IAAA,CAAA,IAAA,CAAA,OAAA,CAAA,oBAAA,CAAA,iBAAA,SAAA,YAAA,CAAA,SAAA,SAAA,YAAA,CAAA,SAAA;;;QATT,YAAA"}
+{"version":3,"file":"Link.d.ts","names":[],"sources":["../../../src/navigation/Link.tsx"],"mappings":";;;;;;;;KAWY,YAAY,KACtB,gCAAgC;EAGhC,MAAM;EACN;;;;;;;cAQW,sBAAI,0BAAA,KAAA,KAAA,qBAAA,qBAAA,8CAAA,sCAAA;;;EATT,MAAA;EACG;oBAiBV,cAAA"}

package/dist/types/navigation/createNavigation.d.ts

@@ -1,5 +1,4 @@
 import { createNavigation as createNavigation$1 } from "next-intl/navigation";
-
 //#region src/navigation/createNavigation.d.ts
 /**
  * Drop-in replacement for next-intl's `createNavigation`.

package/dist/types/navigation/createNavigation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createNavigation.d.ts","names":[],"sources":["../../../src/navigation/createNavigation.ts"],"mappings":";;;;;AA6BA;;;;;;;;;;;;cAAa,gBAAA,SAAyB,kBAAA"}
+{"version":3,"file":"createNavigation.d.ts","names":[],"sources":["../../../src/navigation/createNavigation.ts"],"mappings":";;;;;;;;;;;;;;;;cA6Ba,yBAAyB"}

package/dist/types/navigation/hooks.d.ts

@@ -1,6 +1,4 @@
 import { NextIntlHref } from "./localizeHref.js";
-import * as _$next_dist_shared_lib_app_router_context_shared_runtime0 from "next/dist/shared/lib/app-router-context.shared-runtime";
-
 //#region src/navigation/hooks.d.ts
 /**
  * Options accepted by the locale-aware router methods: the standard Next.js
@@ -20,13 +18,13 @@ declare const usePathname: () => string;
  * (honouring an optional `locale` option) before navigating.
  */
 declare const useRouter: () => {
-  push: (href: NextIntlHref, options?: NavigateOptions) => void;
-  replace: (href: NextIntlHref, options?: NavigateOptions) => void;
-  prefetch: (href: NextIntlHref, options?: NavigateOptions) => void;
   back(): void;
   forward(): void;
   refresh(): void;
-  experimental_gesturePush?(href: string, options?: _$next_dist_shared_lib_app_router_context_shared_runtime0.NavigateOptions): void;
+  experimental_gesturePush?(href: string, options?: import("next/dist/shared/lib/app-router-context.shared-runtime").NavigateOptions): void;
+  push: (href: NextIntlHref, options?: NavigateOptions) => void;
+  replace: (href: NextIntlHref, options?: NavigateOptions) => void;
+  prefetch: (href: NextIntlHref, options?: NavigateOptions) => void;
 };
 //#endregion
 export { usePathname, useRouter };

package/dist/types/navigation/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","names":[],"sources":["../../../src/navigation/hooks.ts"],"mappings":";;;;;;;AAOiE;KAM5D,eAAA;EAAoB,MAAA;AAAA,IAAoB,MAAA;;AAM7C;;;cAAa,WAAA;;AAeb;;;;cAAa,SAAA;eASI,YAAA,EAAY,OAAA,GAAY,eAAA;kBAKrB,YAAA,EAAY,OAAA,GAAY,eAAA;mBAKvB,YAAA,EAAY,OAAA,GAAY,eAAA;;;;oDAAe,yDAAA,CAAA,eAAA;AAAA"}
+{"version":3,"file":"hooks.d.ts","names":[],"sources":["../../../src/navigation/hooks.ts"],"mappings":";;;;;;KAaK;EAAoB;IAAoB;;;;;cAMhC;;;;;;cAeA;;;;;EASI,OAAA,MAAA,cAAY,UAAY;EAKrB,UAAA,MAAA,cAAY,UAAY;EAKvB,WAAA,MAAA,cAAY,UAAY"}

package/dist/types/navigation/localizeHref.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localizeHref.d.ts","names":[],"sources":["../../../src/navigation/localizeHref.ts"],"mappings":";;AAQA;;;;KAAY,YAAA;EAGN,QAAA;EACA,KAAA,GAAQ,MAAA;EACR,MAAA,GAAS,MAAA;AAAA;;;AAWf;;;;;;cAAa,YAAA,GAAgB,IAAA,EAAM,YAAA,EAAc,MAAA"}
+{"version":3,"file":"localizeHref.d.ts","names":[],"sources":["../../../src/navigation/localizeHref.ts"],"mappings":";;;;;;KAQY;EAGN;EACA,QAAQ;EACR,SAAS;;;;;;;;;;cAWF,eAAY,MAAU,cAAY"}

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

@@ -1,5 +1,4 @@
 import { NextConfig } from "next";
-
 //#region src/plugin/index.d.ts
 /**
  * A Next.js plugin for next-intl compat that wraps next-intlayer's plugin

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/plugin/index.ts"],"mappings":";;;;;AA0HA;;;cAAa,oBAAA,GAAwB,SAAA,eACrB,UAAA,GAAY,UAAA,KAAkB,OAAA,CAAQ,UAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/plugin/index.ts"],"mappings":";;;;;;;cAiHa,uBAAoB,wBAAsB,aAC3B,eAAkB,QAAQ"}

package/dist/types/routing.d.ts

@@ -1,5 +1,4 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-
 //#region src/routing.d.ts
 type Routing = {
   locales: LocalesValues[];

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

@@ -1 +1 @@
-{"version":3,"file":"routing.d.ts","names":[],"sources":["../../src/routing.ts"],"mappings":";;;KAGY,OAAA;EACV,OAAA,EAAS,aAAA;EACT,aAAA,EAAe,aAAA;EACf,YAAA;EACA,SAAA,GAAY,MAAA,kBAAwB,MAAA;AAAA;;;;;;;;;;;;;;;;cAkBzB,aAAA,GAAgB,MAAA,GAAS,OAAA,CAAQ,OAAA,MAAa,OAAA"}
+{"version":3,"file":"routing.d.ts","names":[],"sources":["../../src/routing.ts"],"mappings":";;KAGY;EACV,SAAS;EACT,eAAe;EACf;EACA,YAAY,wBAAwB;;;;;;;;;;;;;;;;;cAkBzB,gBAAgB,SAAS,QAAQ,aAAa"}

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

@@ -1,8 +1,16 @@
 import { getLocale as getLocale$1 } from "next-intl/server";
-
 //#region src/server/getLocale.d.ts
 /**
  * Drop-in for next-intl's `getLocale()` server function.
+ *
+ * Resolution order mirrors next-intl's per-request model:
+ *
+ * 1. The locale forwarded through `setRequestLocale(locale)` (the `[locale]`
+ *    route segment) — the source of truth for URL-driven routing. This is what
+ *    keeps server-rendered content and the locale switcher in sync with the URL
+ *    instead of a stale cookie.
+ * 2. Otherwise Intlayer's own resolution (cookie / header / Accept-Language),
+ *    for apps that drive the locale from storage rather than the route.
  */
 declare const getLocale: typeof getLocale$1;
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"getLocale.d.ts","names":[],"sources":["../../../src/server/getLocale.ts"],"mappings":";;;;;AAMA;cAAa,SAAA,SAAkB,WAAA"}
+{"version":3,"file":"getLocale.d.ts","names":[],"sources":["../../../src/server/getLocale.ts"],"mappings":";;;;;;;;;;;;;;cAgBa,kBAAkB"}

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

@@ -1,5 +1,4 @@
 import { getMessages as getMessages$1 } from "next-intl/server";
-
 //#region src/server/getMessages.d.ts
 /**
  * Drop-in replacement for next-intl's `getMessages()` server function.

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

@@ -1 +1 @@
-{"version":3,"file":"getMessages.d.ts","names":[],"sources":["../../../src/server/getMessages.ts"],"mappings":";;;;;AAoBA;;;;;;;;;;;;;cAAa,WAAA,SAAoB,aAAA"}
+{"version":3,"file":"getMessages.d.ts","names":[],"sources":["../../../src/server/getMessages.ts"],"mappings":";;;;;;;;;;;;;;;;;cAoBa,oBAAoB"}

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

@@ -0,0 +1,18 @@
+import { getRequestConfig as getRequestConfig$1 } from "next-intl/server";
+//#region src/server/getRequestConfig.d.ts
+/**
+ * Drop-in for next-intl's `getRequestConfig`.
+ *
+ * In next-intl this registers the per-request config (locale + messages) read
+ * by its own plugin. With intlayer the locale is resolved from routing /
+ * storage and messages come from compiled dictionaries, so the returned config
+ * is never consumed — this is an identity passthrough kept so existing
+ * `i18n/request.ts` files keep resolving and type-checking.
+ *
+ * @deprecated getRequestConfig has no use case with intlayer. The locale and
+ * messages are resolved automatically; the file can be removed.
+ */
+declare const getRequestConfig: typeof getRequestConfig$1;
+//#endregion
+export { getRequestConfig as default, getRequestConfig };
+//# sourceMappingURL=getRequestConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getRequestConfig.d.ts","names":[],"sources":["../../../src/server/getRequestConfig.ts"],"mappings":";;;;;;;;;;;;;;cAiBa,yBAAyB"}

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

@@ -1,40 +1,15 @@
-import { MarkupChunkRenderer, RichChunkRenderer } from "../createTranslator.js";
 import { DictionaryKeys, LocalesValues } from "@intlayer/types/module_augmentation";
-import { ReactNode } from "react";
-import { ValidDotPathsFor } from "@intlayer/core/transpiler";
-
+import { LooseTranslateFunction, TranslateFunction, TranslateFunctionForNamespace } from "@intlayer/use-intl";
 //#region src/server/getTranslations.d.ts
 /**
  * Options accepted by the options-object overload of {@link getTranslations}.
  */
 type GetTranslationsOptions<N extends DictionaryKeys> = {
-  /** The dictionary namespace to scope translations to. */namespace?: N; /** Override the locale instead of reading it from the current request. */
+  /** The dictionary namespace to scope translations to. */
+  namespace?: N;
+  /** Override the locale instead of reading it from the current request. */
   locale?: LocalesValues;
 };
-/**
- * The translation function returned by {@link getTranslations}.
- *
- * Beyond the plain call signature, the function exposes:
- * - `has(key)` — returns `true` when the key exists in the namespace.
- * - `raw(key)` — returns the unprocessed message value.
- * - `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> = {
-  /** Translate a key to a string, with optional ICU interpolation params. */<P extends ValidDotPathsFor<N>>(key: P, params?: Record<string, unknown>): string; /** Returns `true` if the given key exists in the namespace. */
-  has<P extends ValidDotPathsFor<N>>(key: P): boolean; /** Returns the raw unprocessed message for the given key. */
-  raw<P extends ValidDotPathsFor<N>>(key: P): unknown; /** Resolves rich-text markup, mapping tags through React renderers. */
-  rich<P extends ValidDotPathsFor<N>>(key: P, values?: Record<string, RichChunkRenderer | ReactNode>): ReactNode; /** Resolves rich-text markup, mapping tags through string renderers. */
-  markup<P extends ValidDotPathsFor<N>>(key: P, values?: Record<string, MarkupChunkRenderer | string | number>): string;
-};
-/** Loosely-typed function returned for nested `'dict.scope'` namespaces. */
-type LooseTranslateFunction = {
-  (key: string, params?: Record<string, unknown>): string;
-  has(key: string): boolean;
-  raw(key: string): unknown;
-  rich(key: string, values?: Record<string, RichChunkRenderer | ReactNode>): ReactNode;
-  markup(key: string, values?: Record<string, MarkupChunkRenderer | string | number>): string;
-};
 /**
  * Overload set for {@link getTranslations}:
  *
@@ -42,14 +17,18 @@ type LooseTranslateFunction = {
  * 2. An options object `{ namespace?, locale? }` → typed when namespace is
  *    a known `DictionaryKeys` value.
  * 3. A nested namespace `'dictionary.sub.scope'` → `t()` accepts relative
- *    `string` paths, matching next-intl's scoped-namespace behaviour.
+ *    dot-paths under the scope, typed against the dictionary, matching
+ *    next-intl's scoped-namespace behaviour.
  * 4. No namespace → root scope; the first segment of each key designates
  *    the dictionary (`t('about.title')`).
+ *
+ * The translate function shape (`t`, `t.rich`, `t.markup`, `t.raw`, `t.has`)
+ * is shared with `@intlayer/use-intl`.
  */
 type GetTranslations = {
   <N extends DictionaryKeys>(namespace: N): Promise<TranslateFunction<N>>;
   <N extends DictionaryKeys>(options: GetTranslationsOptions<N>): Promise<TranslateFunction<N>>;
-  (namespace: `${string}.${string}`): Promise<LooseTranslateFunction>;
+  <N extends `${string}.${string}`>(namespace: N): Promise<TranslateFunctionForNamespace<N>>;
   (): Promise<LooseTranslateFunction>;
 };
 /**
@@ -60,8 +39,9 @@ type GetTranslations = {
  * arguments (`{value, number}`). Rich text is available through `t.rich()`
  * and `t.markup()`.
  *
- * Also accepts an options object `{ namespace, locale }` to match next-intl's
- * full server API surface.
+ * Resolves the active locale from the current request (or the `locale` option)
+ * and delegates to `@intlayer/use-intl`'s `createTranslator`, the same runtime
+ * that backs the client `useTranslations`.
  *
  * @example
  * ```ts

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

@@ -1 +1 @@
-{"version":3,"file":"getTranslations.d.ts","names":[],"sources":["../../../src/server/getTranslations.ts"],"mappings":";;;;;;;;AAU6B;KAMxB,sBAAA,WAAiC,cAAA;EAAX,yDAEzB,SAAA,GAAY,CAAA,EAAA;EAEZ,MAAA,GAAS,aAAA;AAAA;;;;;;;;;;KAYN,iBAAA,WAA4B,cAAA;EAAX,sFAET,gBAAA,CAAiB,CAAA,GAC1B,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,4BAJoB;EAO/B,GAAA,WAAc,gBAAA,CAAiB,CAAA,GAAI,GAAA,EAAK,CAAA,YAL7B;EAOX,GAAA,WAAc,gBAAA,CAAiB,CAAA,GAAI,GAAA,EAAK,CAAA,YAL7B;EAOX,IAAA,WAAe,gBAAA,CAAiB,CAAA,GAC9B,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,SAAe,iBAAA,GAAoB,SAAA,IAC3C,SAAA,EAPW;EASd,MAAA,WAAiB,gBAAA,CAAiB,CAAA,GAChC,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,SAAe,mBAAA;AAAA;;KAKvB,sBAAA;EAAA,CACF,GAAA,UAAa,MAAA,GAAS,MAAA;EACvB,GAAA,CAAI,GAAA;EACJ,GAAA,CAAI,GAAA;EACJ,IAAA,CACE,GAAA,UACA,MAAA,GAAS,MAAA,SAAe,iBAAA,GAAoB,SAAA,IAC3C,SAAA;EACH,MAAA,CACE,GAAA,UACA,MAAA,GAAS,MAAA,SAAe,mBAAA;AAAA;;;;;;;;;;;;KAevB,eAAA;EAAA,WACQ,cAAA,EAAgB,SAAA,EAAW,CAAA,GAAI,OAAA,CAAQ,iBAAA,CAAkB,CAAA;EAAA,WACzD,cAAA,EACT,OAAA,EAAS,sBAAA,CAAuB,CAAA,IAC/B,OAAA,CAAQ,iBAAA,CAAkB,CAAA;EAAA,CAC5B,SAAA,0BAAmC,OAAA,CAAQ,sBAAA;EAAA,IACxC,OAAA,CAAQ,sBAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BD,eAAA,EAAiB,eAAA"}
+{"version":3,"file":"getTranslations.d.ts","names":[],"sources":["../../../src/server/getTranslations.ts"],"mappings":";;;;;;KAeK,uBAAuB,UAAU;;EAEpC,YAAY;;EAEZ,SAAS;;;;;;;;;;;;;;;;;KAkBN;GACF,UAAU,gBAAgB,WAAW,IAAI,QAAQ,kBAAkB;GACnE,UAAU,gBACT,SAAS,uBAAuB,KAC/B,QAAQ,kBAAkB;GAC5B,iCACC,WAAW,IACV,QAAQ,8BAA8B;MACrC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BD,iBAAiB"}

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

@@ -1,9 +1,9 @@
 import { getFormatter as getFormatter$1, getNow as getNow$1, getTimeZone as getTimeZone$1 } from "next-intl/server";
-
 //#region src/server/helpers.d.ts
 /**
  * Drop-in for next-intl's server `getFormatter()`.
- * Returns locale-aware formatters backed by the native `Intl.*` APIs.
+ * Returns locale-aware formatters backed by the native `Intl.*` APIs,
+ * built by `@intlayer/use-intl`'s `createFormatter`.
  */
 declare const getFormatter: typeof getFormatter$1;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","names":[],"sources":["../../../src/server/helpers.ts"],"mappings":";;;;;AAYA;;cAAa,YAAA,SAAqB,cAAA;;;AAWlC;;cAAa,MAAA,SAAe,QAAA;;;AAO5B;;cAAa,WAAA,SAAoB,aAAA"}
+{"version":3,"file":"helpers.d.ts","names":[],"sources":["../../../src/server/helpers.ts"],"mappings":";;;;;;;cAaa,qBAAqB;;;;;cAWrB,eAAe;;;;;cAOf,oBAAoB"}

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

@@ -2,7 +2,9 @@ import { getDictionary } from "../getDictionary.js";
 import { getDictionaryDynamic } from "../getDictionaryDynamic.js";
 import { getLocale } from "./getLocale.js";
 import { getMessages } from "./getMessages.js";
+import getRequestConfig from "./getRequestConfig.js";
 import { getTranslations } from "./getTranslations.js";
 import { getFormatter, getNow, getTimeZone } from "./helpers.js";
 import { setLocale } from "./setLocale.js";
-export { getDictionary, getDictionaryDynamic, getFormatter, getLocale, getMessages, getNow, getTimeZone, getTranslations, setLocale };
+import { setRequestLocale } from "./setRequestLocale.js";
+export { getDictionary, getDictionaryDynamic, getFormatter, getLocale, getMessages, getNow, getRequestConfig, getTimeZone, getTranslations, setLocale, setRequestLocale };

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

@@ -0,0 +1,16 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+//#region src/server/requestLocaleCache.d.ts
+/**
+ * Read the locale stored for the current request, or `undefined` when
+ * `setRequestLocale` has not been called.
+ */
+declare const getCachedRequestLocale: () => LocalesValues | undefined;
+/**
+ * Store the locale for the current request. Called by `setRequestLocale`.
+ *
+ * @param locale - The locale resolved from the `[locale]` route segment.
+ */
+declare const setCachedRequestLocale: (locale: LocalesValues) => void;
+//#endregion
+export { getCachedRequestLocale, setCachedRequestLocale };
+//# sourceMappingURL=requestLocaleCache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"requestLocaleCache.d.ts","names":[],"sources":["../../../src/server/requestLocaleCache.ts"],"mappings":";;;;;;cAuBa,8BAA6B;;;;;;cAQ7B,yBAAsB,QAAY"}

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

@@ -1 +1 @@
-{"version":3,"file":"setLocale.d.ts","names":[],"sources":["../../../src/server/setLocale.ts"],"mappings":";;AAoBA;;;;;;;;;;;;;;;cAAa,SAAA,GAAmB,MAAA,aAAiB,OAAA"}
+{"version":3,"file":"setLocale.d.ts","names":[],"sources":["../../../src/server/setLocale.ts"],"mappings":";;;;;;;;;;;;;;;;;cAoBa,YAAS,mBAA2B"}

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

@@ -0,0 +1,28 @@
+import { setRequestLocale as setRequestLocale$1 } from "next-intl/server";
+//#region src/server/setRequestLocale.d.ts
+/**
+ * Drop-in for next-intl's `setRequestLocale`.
+ *
+ * In next-intl this stores the locale (typically the `[locale]` route segment)
+ * in a request-scoped cache so the rest of the request can render in that
+ * locale and opt into static rendering. The compat keeps the same contract:
+ * the locale is stored per-request and read back by `getLocale()` (and, through
+ * it, `getTranslations` / `getDictionary` / metadata). This is what makes the
+ * per-request locale — and therefore the locale switcher — work without relying
+ * on a cookie.
+ *
+ * @param locale - The locale resolved from the `[locale]` route segment.
+ *
+ * @example
+ * ```ts
+ * export default async function LocaleLayout({ params }) {
+ *   const { locale } = await params;
+ *   setRequestLocale(locale);
+ *   // …
+ * }
+ * ```
+ */
+declare const setRequestLocale: typeof setRequestLocale$1;
+//#endregion
+export { setRequestLocale };
+//# sourceMappingURL=setRequestLocale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setRequestLocale.d.ts","names":[],"sources":["../../../src/server/setRequestLocale.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;cA0Ba,yBAAyB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/next-intl",
-  "version": "9.0.0-canary.2",
+  "version": "9.0.0-canary.21",
   "private": false,
   "description": "next-intl API adapter for intlayer — useTranslations, useLocale, getTranslations, getLocale, NextIntlClientProvider backed by next-intlayer",
   "keywords": [
@@ -110,25 +110,26 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/chokidar": "9.0.0-canary.2",
-    "@intlayer/config": "9.0.0-canary.2",
-    "@intlayer/core": "9.0.0-canary.2",
-    "@intlayer/dictionaries-entry": "9.0.0-canary.2",
-    "@intlayer/types": "9.0.0-canary.2",
-    "next-intlayer": "9.0.0-canary.2",
-    "react-intlayer": "9.0.0-canary.2"
+    "@intlayer/config": "9.0.0-canary.21",
+    "@intlayer/core": "9.0.0-canary.21",
+    "@intlayer/dictionaries-entry": "9.0.0-canary.21",
+    "@intlayer/engine": "9.0.0-canary.21",
+    "@intlayer/types": "9.0.0-canary.21",
+    "@intlayer/use-intl": "9.0.0-canary.21",
+    "next-intlayer": "9.0.0-canary.21",
+    "react-intlayer": "9.0.0-canary.21"
   },
   "devDependencies": {
-    "@types/node": "25.9.3",
+    "@types/node": "26.1.1",
     "@types/react": "19.2.17",
     "@utils/ts-config": "1.0.4",
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",
-    "next-intl": "4.13.0",
+    "next-intl": "4.13.2",
     "rimraf": "6.1.3",
-    "tsdown": "0.21.10",
-    "typescript": "6.0.3",
-    "vitest": "4.1.9"
+    "tsdown": "0.22.12",
+    "typescript": "7.0.2",
+    "vitest": "4.1.10"
   },
   "peerDependencies": {
     "next": ">=14.0.0",

package/dist/cjs/client/helpers.cjs

@@ -1,66 +0,0 @@
-'use client';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-const require_createFormatter = require('../createFormatter.cjs');
-let _intlayer_config_built = require("@intlayer/config/built");
-let next_intlayer = require("next-intlayer");
-let react_jsx_runtime = require("react/jsx-runtime");
-let _intlayer_config_colors = require("@intlayer/config/colors");
-let _intlayer_config_logger = require("@intlayer/config/logger");
-
-//#region src/client/helpers.tsx
-/**
-* Drop-in for next-intl's `useNow`.
-* Returns the current `Date`. The `updateInterval` option is ignored.
-*/
-const useNow = () => /* @__PURE__ */ new Date();
-/**
-* Drop-in for next-intl's `useTimeZone`.
-* Returns the system time zone resolved from `Intl.DateTimeFormat`.
-*/
-const useTimeZone = () => Intl.DateTimeFormat().resolvedOptions().timeZone;
-/**
-* Drop-in for next-intl's `useMessages`.
-*
-* @deprecated useMessages has no use case with intlayer.
-* Messages are loaded automatically under the hood.
-* @returns An empty object.
-*/
-const useMessages = () => {
-	if (process.env.NODE_ENV === "development") (0, _intlayer_config_logger.getAppLogger)({ log: _intlayer_config_built.log })(`${(0, _intlayer_config_logger.colorize)("useMessages", _intlayer_config_colors.CYAN)} has no use case with intlayer. Messages are loaded automatically under the hood for bundle optimization reason`);
-	return {};
-};
-/**
-* Drop-in for next-intl's `useFormatter`.
-* Returns locale-aware formatters backed by the native `Intl.*` APIs:
-* `dateTime`, `number`, `dateTimeRange`, `relativeTime`, `list`, and
-* `displayName`.
-*/
-const useFormatter = () => {
-	const { locale } = (0, next_intlayer.useLocale)();
-	return require_createFormatter.createFormatter(locale ?? "en");
-};
-/**
-* Drop-in for next-intl's `IntlProvider`.
-* Renders children as-is — Intlayer provides its own context via
-* `IntlayerClientProvider`.
-*
-* @deprecated IntlProvider has no use case with intlayer.
-* Use `IntlayerClientProvider` or `NextIntlClientProvider` instead.
-*/
-const IntlProvider = ({ children }) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children });
-/**
-* @internal Not part of the public next-intl API surface; provided for
-* internal compatibility shims only.
-*/
-const useExtracted = (..._args) => ({});
-
-//#endregion
-exports.IntlProvider = IntlProvider;
-exports.useExtracted = useExtracted;
-exports.useFormatter = useFormatter;
-exports.useMessages = useMessages;
-exports.useNow = useNow;
-exports.useTimeZone = useTimeZone;
-//# sourceMappingURL=helpers.cjs.map

package/dist/cjs/client/helpers.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"helpers.cjs","names":["CYAN","createFormatter"],"sources":["../../../src/client/helpers.tsx"],"sourcesContent":["'use client';\n\nimport { log } from '@intlayer/config/built';\nimport { CYAN } from '@intlayer/config/colors';\nimport { colorize, getAppLogger } from '@intlayer/config/logger';\nimport type {\n  IntlProvider as _IntlProvider,\n  useFormatter as _useFormatter,\n  useMessages as _useMessages,\n  useNow as _useNow,\n  useTimeZone as _useTimeZone,\n} from 'next-intl';\nimport { useLocale } from 'next-intlayer';\nimport type * as React from 'react';\nimport { createFormatter } from '../createFormatter';\n\n/**\n * Drop-in for next-intl's `useNow`.\n * Returns the current `Date`. The `updateInterval` option is ignored.\n */\nexport const useNow: typeof _useNow = () => new Date();\n\n/**\n * Drop-in for next-intl's `useTimeZone`.\n * Returns the system time zone resolved from `Intl.DateTimeFormat`.\n */\nexport const useTimeZone: typeof _useTimeZone = () =>\n  Intl.DateTimeFormat().resolvedOptions().timeZone;\n\n/**\n * Drop-in for next-intl's `useMessages`.\n *\n * @deprecated useMessages has no use case with intlayer.\n * Messages are loaded automatically under the hood.\n * @returns An empty object.\n */\nexport const useMessages: typeof _useMessages = () => {\n  if (process.env.NODE_ENV === 'development') {\n    const appLogger = getAppLogger({ log });\n    appLogger(\n      `${colorize('useMessages', CYAN)} has no use case with intlayer. Messages are loaded automatically under the hood for bundle optimization reason`\n    );\n  }\n\n  return {} as ReturnType<typeof _useMessages>;\n};\n\n/**\n * Drop-in for next-intl's `useFormatter`.\n * Returns locale-aware formatters backed by the native `Intl.*` APIs:\n * `dateTime`, `number`, `dateTimeRange`, `relativeTime`, `list`, and\n * `displayName`.\n */\nexport const useFormatter: typeof _useFormatter = () => {\n  const { locale } = useLocale();\n  return createFormatter((locale as string) ?? 'en');\n};\n\ninterface ProviderProps {\n  children?: React.ReactNode;\n  [key: string]: unknown;\n}\n\n/**\n * Drop-in for next-intl's `IntlProvider`.\n * Renders children as-is — Intlayer provides its own context via\n * `IntlayerClientProvider`.\n *\n * @deprecated IntlProvider has no use case with intlayer.\n * Use `IntlayerClientProvider` or `NextIntlClientProvider` instead.\n */\nexport const IntlProvider: typeof _IntlProvider = ({\n  children,\n}: ProviderProps) => <>{children}</>;\n\n/**\n * @internal Not part of the public next-intl API surface; provided for\n * internal compatibility shims only.\n */\nexport const useExtracted = (..._args: unknown[]) => ({});\n"],"mappings":";;;;;;;;;;;;;;;;AAoBA,MAAa,+BAA+B,IAAI,MAAM;;;;;AAMtD,MAAa,oBACX,KAAK,gBAAgB,CAAC,iBAAiB,CAAC;;;;;;;;AAS1C,MAAa,oBAAyC;AACpD,KAAI,QAAQ,IAAI,aAAa,cAE3B,2CAD+B,EAAE,iCAAK,CAC7B,CACP,yCAAY,eAAeA,6BAAK,CAAC,iHAClC;AAGH,QAAO,EAAE;;;;;;;;AASX,MAAa,qBAA2C;CACtD,MAAM,EAAE,yCAAsB;AAC9B,QAAOC,wCAAiB,UAAqB,KAAK;;;;;;;;;;AAgBpD,MAAa,gBAAsC,EACjD,eACmB,yEAAG,UAAY;;;;;AAMpC,MAAa,gBAAgB,GAAG,WAAsB,EAAE"}

package/dist/cjs/client/useTranslations.cjs

@@ -1,39 +0,0 @@
-'use client';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
-const require_createTranslator = require('../createTranslator.cjs');
-let next_intlayer = require("next-intlayer");
-let react = require("react");
-
-//#region src/client/useTranslations.ts
-/**
-* Drop-in for next-intl's `useTranslations`.
-*
-* Messages support ICU MessageFormat syntax: simple arguments (`{name}`),
-* plural (`{count, plural, one {…} other {…}}`, `#`), select, and formatted
-* arguments (`{value, number}`). Rich text is available through `t.rich()`
-* and `t.markup()`.
-*
-* @example
-* ```tsx
-* const t = useTranslations('about');
-* t('counter.label'); // ✓ typed
-* t('items', { count: 3 }); // ICU plural
-*
-* // Scoped to a nested object (next-intl idiom)
-* const t = useTranslations('about.counter');
-* t('label'); // resolves about → counter.label
-*
-* // Rich text
-* t.rich('terms', { link: (chunks) => <a href="/terms">{chunks}</a> });
-* ```
-*/
-const useTranslations = ((namespace) => {
-	const { locale: currentLocale } = (0, react.useContext)(next_intlayer.IntlayerClientContext) ?? {};
-	return (0, react.useMemo)(() => require_createTranslator.createTranslator(currentLocale, namespace), [currentLocale, namespace]);
-});
-
-//#endregion
-exports.useTranslations = useTranslations;
-//# sourceMappingURL=useTranslations.cjs.map

package/dist/cjs/client/useTranslations.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"useTranslations.cjs","names":["IntlayerClientContext","createTranslator"],"sources":["../../../src/client/useTranslations.ts"],"sourcesContent":["'use client';\n\nimport type { ValidDotPathsFor } from '@intlayer/core/transpiler';\nimport type {\n  DictionaryKeys,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { IntlayerClientContext } from 'next-intlayer';\nimport { type ReactNode, useContext, useMemo } from 'react';\nimport {\n  createTranslator,\n  type MarkupChunkRenderer,\n  type RichChunkRenderer,\n} from '../createTranslator';\n\n/**\n * The translation function returned by {@link useTranslations}.\n *\n * When the namespace is a bare dictionary key, `key` is validated against the\n * dictionary's dot-paths. When the namespace is a nested scope\n * (`'about.counter'`), `key` is a relative `string` path.\n *\n * Beyond the call signature, the function exposes:\n * - `has(key)` — returns `true` when the key exists in the namespace.\n * - `raw(key)` — returns the unprocessed content value.\n * - `rich(key, values)` — resolves `<tag>chunks</tag>` markup to React nodes.\n * - `markup(key, values)` — resolves `<tag>chunks</tag>` markup to a string.\n */\ntype TranslateFunction<N extends DictionaryKeys> = {\n  /** Translate a key to a string, with optional ICU interpolation params. */\n  <P extends ValidDotPathsFor<N>>(\n    key: P,\n    params?: Record<string, unknown>\n  ): string;\n  /** Returns `true` if the given key exists in the namespace. */\n  has<P extends ValidDotPathsFor<N>>(key: P): boolean;\n  /** Returns the raw unprocessed content for the given key. */\n  raw<P extends ValidDotPathsFor<N>>(key: P): unknown;\n  /** Resolves rich-text markup, mapping tags through React renderers. */\n  rich<P extends ValidDotPathsFor<N>>(\n    key: P,\n    values?: Record<string, RichChunkRenderer | ReactNode>\n  ): ReactNode;\n  /** Resolves rich-text markup, mapping tags through string renderers. */\n  markup<P extends ValidDotPathsFor<N>>(\n    key: P,\n    values?: Record<string, MarkupChunkRenderer | string | number>\n  ): string;\n};\n\n/** Loosely-typed function returned for nested `'dict.scope'` namespaces. */\ntype LooseTranslateFunction = {\n  (key: string, params?: Record<string, unknown>): string;\n  has(key: string): boolean;\n  raw(key: string): unknown;\n  rich(\n    key: string,\n    values?: Record<string, RichChunkRenderer | ReactNode>\n  ): ReactNode;\n  markup(\n    key: string,\n    values?: Record<string, MarkupChunkRenderer | string | number>\n  ): string;\n};\n\n/**\n * Overload set for {@link useTranslations}:\n *\n * 1. A bare dictionary key → fully-typed `t()` (autocompleted dot-paths).\n * 2. A nested namespace `'dictionary.sub.scope'` → `t()` accepts relative\n *    `string` paths, matching next-intl's scoped-namespace behaviour.\n * 3. No namespace → root scope; the first segment of each key designates\n *    the dictionary (`t('about.title')`).\n */\ntype UseTranslations = {\n  <N extends DictionaryKeys>(namespace: N): TranslateFunction<N>;\n  (namespace: `${string}.${string}`): LooseTranslateFunction;\n  (): LooseTranslateFunction;\n};\n\n/**\n * Drop-in for next-intl's `useTranslations`.\n *\n * Messages support ICU MessageFormat syntax: simple arguments (`{name}`),\n * plural (`{count, plural, one {…} other {…}}`, `#`), select, and formatted\n * arguments (`{value, number}`). Rich text is available through `t.rich()`\n * and `t.markup()`.\n *\n * @example\n * ```tsx\n * const t = useTranslations('about');\n * t('counter.label'); // ✓ typed\n * t('items', { count: 3 }); // ICU plural\n *\n * // Scoped to a nested object (next-intl idiom)\n * const t = useTranslations('about.counter');\n * t('label'); // resolves about → counter.label\n *\n * // Rich text\n * t.rich('terms', { link: (chunks) => <a href=\"/terms\">{chunks}</a> });\n * ```\n */\nexport const useTranslations = ((namespace?: string) => {\n  const { locale: currentLocale } = useContext(IntlayerClientContext) ?? {};\n\n  return useMemo(\n    () => createTranslator(currentLocale as LocalesValues, namespace),\n    [currentLocale, namespace]\n  );\n}) as UseTranslations;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsGA,MAAa,oBAAoB,cAAuB;CACtD,MAAM,EAAE,QAAQ,wCAA6BA,oCAAsB,IAAI,EAAE;AAEzE,iCACQC,0CAAiB,eAAgC,UAAU,EACjE,CAAC,eAAe,UAAU,CAC3B"}

package/dist/cjs/createFormatter.cjs

@@ -1,59 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-//#region src/createFormatter.ts
-/** Time units orderable by their duration in seconds. */
-const RELATIVE_TIME_UNITS = [
-	["year", 31536e3],
-	["month", 2628e3],
-	["week", 604800],
-	["day", 86400],
-	["hour", 3600],
-	["minute", 60],
-	["second", 1]
-];
-const toDate = (value) => value instanceof Date ? value : new Date(value);
-/**
-* Builds a next-intl compatible formatter backed by the native `Intl.*`
-* APIs for the given locale.
-*
-* Shared by `useFormatter` (client) and `getFormatter` (server).
-*/
-const createFormatter = (locale) => ({
-	dateTime: (value, options) => new Intl.DateTimeFormat(locale, options).format(value),
-	number: (value, options) => new Intl.NumberFormat(locale, options).format(value),
-	/** Formats a date range with `Intl.DateTimeFormat#formatRange`. */
-	dateTimeRange: (start, end, options) => new Intl.DateTimeFormat(locale, options).formatRange(toDate(start), toDate(end)),
-	/**
-	* Formats a date relative to now (or a reference date), automatically
-	* selecting the largest fitting unit.
-	*/
-	relativeTime: (date, nowOrOptions) => {
-		const options = nowOrOptions instanceof Date || typeof nowOrOptions === "number" ? { now: nowOrOptions } : nowOrOptions ?? {};
-		const nowDate = options.now !== void 0 ? toDate(options.now) : /* @__PURE__ */ new Date();
-		const diffInSeconds = (toDate(date).getTime() - nowDate.getTime()) / 1e3;
-		let unit = options.unit;
-		if (!unit) {
-			const absoluteDiff = Math.abs(diffInSeconds);
-			unit = RELATIVE_TIME_UNITS.find(([, unitSeconds]) => absoluteDiff >= unitSeconds)?.[0] ?? "second";
-		}
-		const unitSeconds = RELATIVE_TIME_UNITS.find(([unitName]) => unitName === unit)?.[1] ?? 1;
-		return new Intl.RelativeTimeFormat(locale, {
-			numeric: "auto",
-			style: options.style
-		}).format(Math.round(diffInSeconds / unitSeconds), unit);
-	},
-	/** Formats a list with `Intl.ListFormat`. */
-	list: (value, options) => new Intl.ListFormat(locale, options).format(value),
-	displayName: (value, optionsOrFormat, extraOptions) => {
-		const resolvedOptions = typeof optionsOrFormat === "string" ? extraOptions : optionsOrFormat;
-		try {
-			return new Intl.DisplayNames([locale], resolvedOptions ?? { type: "language" }).of(value) ?? value;
-		} catch {
-			return value;
-		}
-	}
-});
-
-//#endregion
-exports.createFormatter = createFormatter;
-//# sourceMappingURL=createFormatter.cjs.map

package/dist/cjs/createFormatter.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"createFormatter.cjs","names":[],"sources":["../../src/createFormatter.ts"],"sourcesContent":["import type { useFormatter as _useFormatter } from 'next-intl';\n\n/** The formatter object shape exposed by next-intl. */\nexport type Formatter = ReturnType<typeof _useFormatter>;\n\n/** Time units orderable by their duration in seconds. */\nconst RELATIVE_TIME_UNITS: [Intl.RelativeTimeFormatUnit, number][] = [\n  ['year', 31536000],\n  ['month', 2628000],\n  ['week', 604800],\n  ['day', 86400],\n  ['hour', 3600],\n  ['minute', 60],\n  ['second', 1],\n];\n\nconst toDate = (value: Date | number | string): Date =>\n  value instanceof Date ? value : new Date(value);\n\n/**\n * Builds a next-intl compatible formatter backed by the native `Intl.*`\n * APIs for the given locale.\n *\n * Shared by `useFormatter` (client) and `getFormatter` (server).\n */\nexport const createFormatter = (locale: string): Formatter =>\n  ({\n    dateTime: (value: Date | number, options?: Intl.DateTimeFormatOptions) =>\n      new Intl.DateTimeFormat(locale, options).format(value),\n\n    number: (value: number | bigint, options?: Intl.NumberFormatOptions) =>\n      new Intl.NumberFormat(locale, options).format(value),\n\n    /** Formats a date range with `Intl.DateTimeFormat#formatRange`. */\n    dateTimeRange: (\n      start: Date | number,\n      end: Date | number,\n      options?: Intl.DateTimeFormatOptions\n    ) =>\n      new Intl.DateTimeFormat(locale, options).formatRange(\n        toDate(start),\n        toDate(end)\n      ),\n\n    /**\n     * Formats a date relative to now (or a reference date), automatically\n     * selecting the largest fitting unit.\n     */\n    relativeTime: (\n      date: Date | number | string,\n      nowOrOptions?:\n        | Date\n        | number\n        | {\n            now?: Date | number;\n            unit?: Intl.RelativeTimeFormatUnit;\n            style?: Intl.RelativeTimeFormatStyle;\n            numberingSystem?: string;\n          }\n    ) => {\n      const options =\n        nowOrOptions instanceof Date || typeof nowOrOptions === 'number'\n          ? { now: nowOrOptions }\n          : (nowOrOptions ?? {});\n\n      const nowDate =\n        options.now !== undefined ? toDate(options.now) : new Date();\n      const diffInSeconds = (toDate(date).getTime() - nowDate.getTime()) / 1000;\n\n      let unit = options.unit;\n      if (!unit) {\n        const absoluteDiff = Math.abs(diffInSeconds);\n        unit =\n          RELATIVE_TIME_UNITS.find(\n            ([, unitSeconds]) => absoluteDiff >= unitSeconds\n          )?.[0] ?? 'second';\n      }\n\n      const unitSeconds =\n        RELATIVE_TIME_UNITS.find(([unitName]) => unitName === unit)?.[1] ?? 1;\n\n      return new Intl.RelativeTimeFormat(locale, {\n        numeric: 'auto',\n        style: options.style,\n      }).format(Math.round(diffInSeconds / unitSeconds), unit);\n    },\n\n    /** Formats a list with `Intl.ListFormat`. */\n    list: (value: Iterable<string>, options?: Intl.ListFormatOptions): string =>\n      new Intl.ListFormat(locale, options).format(value),\n\n    displayName: (\n      value: string,\n      optionsOrFormat?: Intl.DisplayNamesOptions | string,\n      extraOptions?: Intl.DisplayNamesOptions\n    ): string => {\n      const resolvedOptions =\n        typeof optionsOrFormat === 'string' ? extraOptions : optionsOrFormat;\n      try {\n        return (\n          new Intl.DisplayNames(\n            [locale],\n            resolvedOptions ?? { type: 'language' }\n          ).of(value) ?? value\n        );\n      } catch {\n        return value;\n      }\n    },\n  }) as unknown as Formatter;\n"],"mappings":";;;;AAMA,MAAM,sBAA+D;CACnE,CAAC,QAAQ,QAAS;CAClB,CAAC,SAAS,OAAQ;CAClB,CAAC,QAAQ,OAAO;CAChB,CAAC,OAAO,MAAM;CACd,CAAC,QAAQ,KAAK;CACd,CAAC,UAAU,GAAG;CACd,CAAC,UAAU,EAAE;CACd;AAED,MAAM,UAAU,UACd,iBAAiB,OAAO,QAAQ,IAAI,KAAK,MAAM;;;;;;;AAQjD,MAAa,mBAAmB,YAC7B;CACC,WAAW,OAAsB,YAC/B,IAAI,KAAK,eAAe,QAAQ,QAAQ,CAAC,OAAO,MAAM;CAExD,SAAS,OAAwB,YAC/B,IAAI,KAAK,aAAa,QAAQ,QAAQ,CAAC,OAAO,MAAM;;CAGtD,gBACE,OACA,KACA,YAEA,IAAI,KAAK,eAAe,QAAQ,QAAQ,CAAC,YACvC,OAAO,MAAM,EACb,OAAO,IAAI,CACZ;;;;;CAMH,eACE,MACA,iBASG;EACH,MAAM,UACJ,wBAAwB,QAAQ,OAAO,iBAAiB,WACpD,EAAE,KAAK,cAAc,GACpB,gBAAgB,EAAE;EAEzB,MAAM,UACJ,QAAQ,QAAQ,SAAY,OAAO,QAAQ,IAAI,mBAAG,IAAI,MAAM;EAC9D,MAAM,iBAAiB,OAAO,KAAK,CAAC,SAAS,GAAG,QAAQ,SAAS,IAAI;EAErE,IAAI,OAAO,QAAQ;AACnB,MAAI,CAAC,MAAM;GACT,MAAM,eAAe,KAAK,IAAI,cAAc;AAC5C,UACE,oBAAoB,MACjB,GAAG,iBAAiB,gBAAgB,YACtC,GAAG,MAAM;;EAGd,MAAM,cACJ,oBAAoB,MAAM,CAAC,cAAc,aAAa,KAAK,GAAG,MAAM;AAEtE,SAAO,IAAI,KAAK,mBAAmB,QAAQ;GACzC,SAAS;GACT,OAAO,QAAQ;GAChB,CAAC,CAAC,OAAO,KAAK,MAAM,gBAAgB,YAAY,EAAE,KAAK;;;CAI1D,OAAO,OAAyB,YAC9B,IAAI,KAAK,WAAW,QAAQ,QAAQ,CAAC,OAAO,MAAM;CAEpD,cACE,OACA,iBACA,iBACW;EACX,MAAM,kBACJ,OAAO,oBAAoB,WAAW,eAAe;AACvD,MAAI;AACF,UACE,IAAI,KAAK,aACP,CAAC,OAAO,EACR,mBAAmB,EAAE,MAAM,YAAY,CACxC,CAAC,GAAG,MAAM,IAAI;UAEX;AACN,UAAO;;;CAGZ"}