nuxt-i18n-micro 3.30.2 → 4.0.0

package/dist/runtime/plugins/01.plugin.d.ts

@@ -1,26 +1,73 @@
 import type { PathStrategy } from '@i18n-micro/path-strategy';
-import type { CleanTranslation, DefineI18nRouteConfig, I18nRouteParams, Locale, MissingHandler, ModuleOptionsExtend, Params, Translations, TranslationKey } from '@i18n-micro/types';
+import type { CleanTranslation, DefineI18nRouteConfig, I18nRouteParams, Locale, MissingHandler, ResolvedI18nConfig, Params, PluralFunc, Translations, TranslationKey } from '@i18n-micro/types';
 import type { RouteLocationNamedRaw, RouteLocationNormalizedLoaded, RouteLocationRaw, RouteLocationResolved, RouteLocationResolvedGeneric } from 'vue-router';
+import { type NuxtI18nPluginProvide } from '../utils/i18n-api.js';
 import { type TranslationFn } from '../utils/nuxt-i18n.js';
 export type { TranslationFn };
 declare const _default: import("nuxt/app").Plugin<{
-    getI18nConfig: () => ModuleOptionsExtend;
+    i18n: {
+        helper: {
+            mergeTranslation(locale: string, routeName: string, newTranslations: Translations): Promise<void>;
+        };
+        getI18nConfig: () => ResolvedI18nConfig;
+        __micro: boolean;
+        i18nStrategy: PathStrategy;
+        getLocale: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric) => string;
+        getLocaleName: () => string | null;
+        defaultLocale: () => string;
+        getLocales: () => Locale[];
+        getRouteName: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric, _locale?: string) => string;
+        t: (key: TranslationKey, params?: Params, defaultValue?: string | null, routeContext?: unknown) => CleanTranslation;
+        ts: (key: TranslationKey, params?: Params, defaultValue?: string, routeContext?: unknown) => string;
+        _t: (route: RouteLocationNormalizedLoaded) => TranslationFn<CleanTranslation>;
+        _ts: (route: RouteLocationNormalizedLoaded) => TranslationFn<string>;
+        tc: (key: TranslationKey, count: number | Params, defaultValue?: string) => string;
+        pluralFunc: PluralFunc;
+        pluralLocale: () => string;
+        tn: {
+            (value: number, options?: Intl.NumberFormatOptions): string;
+            (value: number, key: string, overrides?: Intl.NumberFormatOptions): string;
+            (value: number, key: string, locale: string, overrides?: Intl.NumberFormatOptions): string;
+        };
+        td: {
+            (value: Date | number | string, options?: Intl.DateTimeFormatOptions): string;
+            (value: Date | number | string, key: string, overrides?: Intl.DateTimeFormatOptions): string;
+            (value: Date | number | string, key: string, locale: string, overrides?: Intl.DateTimeFormatOptions): string;
+        };
+        tdr: (value: Date | number | string, options?: Intl.RelativeTimeFormatOptions) => string;
+        has: (key: TranslationKey, routeContext?: unknown) => boolean;
+        resolveTranslations: (routeContext?: unknown) => Translations;
+        setTranslation: (key: TranslationKey, value: unknown) => void;
+        mergeTranslations: (newTranslations: Translations) => void;
+        switchLocaleRoute: (toLocale: string) => string | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric;
+        clearCache: () => void;
+        switchLocalePath: (toLocale: string) => string;
+        switchLocale: (toLocale: string) => Promise<boolean>;
+        switchRoute: (route: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, toLocale?: string) => Promise<unknown>;
+        localeRoute(to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string): RouteLocationResolved;
+        localePath(to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string): string;
+        loadPageTranslations: (locale: string, routeName: string, translations: Translations) => Promise<void>;
+        setMissingHandler: (handler: MissingHandler | null) => void;
+    };
+    defineI18nRoute: ReturnType<({ getLocale, mergeTranslations }: Pick<NuxtI18nPluginProvide, "getLocale" | "mergeTranslations">) => ({ locales }: DefineI18nRouteConfig) => Promise<void>>;
     helper: {
-        mergeTranslation(locale: string, routeName: string, newTranslations: Translations, _force?: boolean): Promise<void>;
+        mergeTranslation(locale: string, routeName: string, newTranslations: Translations): Promise<void>;
     };
-    i18n: unknown;
+    getI18nConfig: () => ResolvedI18nConfig;
     __micro: boolean;
     i18nStrategy: PathStrategy;
     getLocale: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric) => string;
     getLocaleName: () => string | null;
-    defaultLocale: () => string | undefined;
+    defaultLocale: () => string;
     getLocales: () => Locale[];
-    getRouteName: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric, locale?: string) => string;
+    getRouteName: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric, _locale?: string) => string;
     t: (key: TranslationKey, params?: Params, defaultValue?: string | null, routeContext?: unknown) => CleanTranslation;
-    ts: (key: TranslationKey, params?: Params, defaultValue?: string, route?: RouteLocationNormalizedLoaded) => string;
+    ts: (key: TranslationKey, params?: Params, defaultValue?: string, routeContext?: unknown) => string;
     _t: (route: RouteLocationNormalizedLoaded) => TranslationFn<CleanTranslation>;
     _ts: (route: RouteLocationNormalizedLoaded) => TranslationFn<string>;
     tc: (key: TranslationKey, count: number | Params, defaultValue?: string) => string;
+    pluralFunc: PluralFunc;
+    pluralLocale: () => string;
     tn: {
         (value: number, options?: Intl.NumberFormatOptions): string;
         (value: number, key: string, overrides?: Intl.NumberFormatOptions): string;
@@ -36,34 +83,79 @@ declare const _default: import("nuxt/app").Plugin<{
     resolveTranslations: (routeContext?: unknown) => Translations;
     setTranslation: (key: TranslationKey, value: unknown) => void;
     mergeTranslations: (newTranslations: Translations) => void;
-    switchLocaleRoute: (toLocale: string) => RouteLocationRaw;
+    switchLocaleRoute: (toLocale: string) => string | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric;
     clearCache: () => void;
     switchLocalePath: (toLocale: string) => string;
-    switchLocale: (toLocale: string) => Promise<unknown>;
-    switchRoute: (route: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, toLocale?: string) => unknown;
+    switchLocale: (toLocale: string) => Promise<boolean>;
+    switchRoute: (route: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, toLocale?: string) => Promise<unknown>;
     localeRoute(to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string): RouteLocationResolved;
     localePath(to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string): string;
-    setI18nRouteParams: (value: I18nRouteParams) => I18nRouteParams;
     loadPageTranslations: (locale: string, routeName: string, translations: Translations) => Promise<void>;
     setMissingHandler: (handler: MissingHandler | null) => void;
 }> & import("nuxt/app").ObjectPlugin<{
-    getI18nConfig: () => ModuleOptionsExtend;
+    i18n: {
+        helper: {
+            mergeTranslation(locale: string, routeName: string, newTranslations: Translations): Promise<void>;
+        };
+        getI18nConfig: () => ResolvedI18nConfig;
+        __micro: boolean;
+        i18nStrategy: PathStrategy;
+        getLocale: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric) => string;
+        getLocaleName: () => string | null;
+        defaultLocale: () => string;
+        getLocales: () => Locale[];
+        getRouteName: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric, _locale?: string) => string;
+        t: (key: TranslationKey, params?: Params, defaultValue?: string | null, routeContext?: unknown) => CleanTranslation;
+        ts: (key: TranslationKey, params?: Params, defaultValue?: string, routeContext?: unknown) => string;
+        _t: (route: RouteLocationNormalizedLoaded) => TranslationFn<CleanTranslation>;
+        _ts: (route: RouteLocationNormalizedLoaded) => TranslationFn<string>;
+        tc: (key: TranslationKey, count: number | Params, defaultValue?: string) => string;
+        pluralFunc: PluralFunc;
+        pluralLocale: () => string;
+        tn: {
+            (value: number, options?: Intl.NumberFormatOptions): string;
+            (value: number, key: string, overrides?: Intl.NumberFormatOptions): string;
+            (value: number, key: string, locale: string, overrides?: Intl.NumberFormatOptions): string;
+        };
+        td: {
+            (value: Date | number | string, options?: Intl.DateTimeFormatOptions): string;
+            (value: Date | number | string, key: string, overrides?: Intl.DateTimeFormatOptions): string;
+            (value: Date | number | string, key: string, locale: string, overrides?: Intl.DateTimeFormatOptions): string;
+        };
+        tdr: (value: Date | number | string, options?: Intl.RelativeTimeFormatOptions) => string;
+        has: (key: TranslationKey, routeContext?: unknown) => boolean;
+        resolveTranslations: (routeContext?: unknown) => Translations;
+        setTranslation: (key: TranslationKey, value: unknown) => void;
+        mergeTranslations: (newTranslations: Translations) => void;
+        switchLocaleRoute: (toLocale: string) => string | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric;
+        clearCache: () => void;
+        switchLocalePath: (toLocale: string) => string;
+        switchLocale: (toLocale: string) => Promise<boolean>;
+        switchRoute: (route: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, toLocale?: string) => Promise<unknown>;
+        localeRoute(to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string): RouteLocationResolved;
+        localePath(to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string): string;
+        loadPageTranslations: (locale: string, routeName: string, translations: Translations) => Promise<void>;
+        setMissingHandler: (handler: MissingHandler | null) => void;
+    };
+    defineI18nRoute: ReturnType<({ getLocale, mergeTranslations }: Pick<NuxtI18nPluginProvide, "getLocale" | "mergeTranslations">) => ({ locales }: DefineI18nRouteConfig) => Promise<void>>;
     helper: {
-        mergeTranslation(locale: string, routeName: string, newTranslations: Translations, _force?: boolean): Promise<void>;
+        mergeTranslation(locale: string, routeName: string, newTranslations: Translations): Promise<void>;
     };
-    i18n: unknown;
+    getI18nConfig: () => ResolvedI18nConfig;
     __micro: boolean;
     i18nStrategy: PathStrategy;
     getLocale: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric) => string;
     getLocaleName: () => string | null;
-    defaultLocale: () => string | undefined;
+    defaultLocale: () => string;
     getLocales: () => Locale[];
-    getRouteName: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric, locale?: string) => string;
+    getRouteName: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric, _locale?: string) => string;
     t: (key: TranslationKey, params?: Params, defaultValue?: string | null, routeContext?: unknown) => CleanTranslation;
-    ts: (key: TranslationKey, params?: Params, defaultValue?: string, route?: RouteLocationNormalizedLoaded) => string;
+    ts: (key: TranslationKey, params?: Params, defaultValue?: string, routeContext?: unknown) => string;
     _t: (route: RouteLocationNormalizedLoaded) => TranslationFn<CleanTranslation>;
     _ts: (route: RouteLocationNormalizedLoaded) => TranslationFn<string>;
     tc: (key: TranslationKey, count: number | Params, defaultValue?: string) => string;
+    pluralFunc: PluralFunc;
+    pluralLocale: () => string;
     tn: {
         (value: number, options?: Intl.NumberFormatOptions): string;
         (value: number, key: string, overrides?: Intl.NumberFormatOptions): string;
@@ -79,14 +171,13 @@ declare const _default: import("nuxt/app").Plugin<{
     resolveTranslations: (routeContext?: unknown) => Translations;
     setTranslation: (key: TranslationKey, value: unknown) => void;
     mergeTranslations: (newTranslations: Translations) => void;
-    switchLocaleRoute: (toLocale: string) => RouteLocationRaw;
+    switchLocaleRoute: (toLocale: string) => string | import("vue-router").RouteLocationAsRelativeGeneric | import("vue-router").RouteLocationAsPathGeneric;
     clearCache: () => void;
     switchLocalePath: (toLocale: string) => string;
-    switchLocale: (toLocale: string) => Promise<unknown>;
-    switchRoute: (route: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, toLocale?: string) => unknown;
+    switchLocale: (toLocale: string) => Promise<boolean>;
+    switchRoute: (route: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, toLocale?: string) => Promise<unknown>;
     localeRoute(to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string): RouteLocationResolved;
     localePath(to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string): string;
-    setI18nRouteParams: (value: I18nRouteParams) => I18nRouteParams;
     loadPageTranslations: (locale: string, routeName: string, translations: Translations) => Promise<void>;
     setMissingHandler: (handler: MissingHandler | null) => void;
 }>;
@@ -95,7 +186,7 @@ export interface PluginsInjections {
     /** The active routing strategy, resolving locales to and from paths. */
     $i18nStrategy: PathStrategy;
     /** The resolved module configuration, as the runtime sees it. */
-    $getI18nConfig: () => ModuleOptionsExtend;
+    $getI18nConfig: () => ResolvedI18nConfig;
     /** Code of the active locale. Pass a route to read the locale that route belongs to. */
     $getLocale: (route?: RouteLocationNormalizedLoaded | RouteLocationResolvedGeneric) => string;
     /** The active locale's `displayName` from the config, or `null` when it has none. */
@@ -117,8 +208,8 @@ export interface PluginsInjections {
      */
     $_t: (route: RouteLocationNormalizedLoaded) => TranslationFn<CleanTranslation>;
     /**
-     * Like `$t`, but always returns a string: an object or array value is stringified rather than
-     * returned as-is.
+     * Like `$t`, but always returns a string: the value goes through `toString()`, so a nested
+     * object becomes `'[object Object]'`. Point the key at a leaf.
      */
     $ts: TranslationFn<string>;
     /** Bind `$ts` to a specific route. See `$_t`. */
@@ -128,6 +219,10 @@ export interface PluginsInjections {
      * `count`.
      */
     $tc: (key: TranslationKey, params: number | Params, defaultValue?: string) => string;
+    /** The plural rule `$tc` uses: `<i18n-t>` asks for it to pick a form from the raw translation. */
+    $pluralFunc: PluralFunc;
+    /** The tag `$tc` plurals by: the locale's `iso` when it has one, else its code. */
+    $pluralLocale: () => string;
     /**
      * Format a number with `Intl.NumberFormat` in the active locale. A key selects a named format
      * from the config.
@@ -150,7 +245,8 @@ export interface PluginsInjections {
     $tdr: (value: Date | number | string, options?: Intl.RelativeTimeFormatOptions) => string;
     /**
      * Whether a key resolves in the active locale. Use it to branch on optional copy instead of
-     * rendering a raw key.
+     * rendering a raw key. Like `$t`, it also sees the leaving page's keys during a same-locale
+     * page transition.
      */
     $has: (key: string) => boolean;
     /**
@@ -165,17 +261,39 @@ export interface PluginsInjections {
     $setTranslation: (key: string, value: unknown) => void;
     /** Merge translations into the active locale at runtime, overriding what is loaded. */
     $mergeTranslations: (newTranslations: Translations) => void;
-    /** The route object for the current page in another locale, without navigating. */
+    /**
+     * The route object for the current page in another locale, without navigating, or a URL string
+     * for a locale on its own `baseUrl`. Under `trailingSlash` the object has `path` and `fullPath`,
+     * following the rule, with the `query` and `hash` as they are, and `router.push` or a link keep them.
+     */
     $switchLocaleRoute: (locale: string) => RouteLocationRaw;
     /** The path of the current page in another locale, without navigating. */
     $switchLocalePath: (locale: string) => string;
-    /** Navigate to the current page in another locale. */
-    $switchLocale: (locale: string) => void;
-    /** Navigate to another route, keeping the active locale or switching to `toLocale`. */
-    $switchRoute: (route: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, toLocale?: string) => void;
-    /** Resolve a route in the given locale, or the active one. */
+    /**
+     * Navigate to the current page in another locale. Under `no_prefix` and hash mode it loads the
+     * locale's translations before navigating; under `no_prefix` the route is replaced in place (no
+     * new history entry). An unknown locale is ignored.
+     * The call is async: `await` it to run code after the navigation. It resolves `true` when the
+     * locale's dictionary is active, `false` when it is not: the chunk failed to load (the current
+     * dictionary stays; call it again to retry) or a newer switch won.
+     */
+    $switchLocale: (locale: string) => Promise<boolean>;
+    /**
+     * Navigate to another route, keeping the active locale or switching to `toLocale`. Async like
+     * `$switchLocale`.
+     */
+    $switchRoute: (route: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, toLocale?: string) => Promise<void>;
+    /**
+     * Resolve a route in the given locale, or the active one. A plain object, safe to keep in state. When a param needs
+     * escaping it has `path`, `fullPath`, `query` and `hash` but no `name` or `params`: the path is what gives the router
+     * the encoded URL. For a locale on another domain `path` and `fullPath` are absolute, which the router cannot take:
+     * such a link goes through `<i18n-link>`, or `$localePath`.
+     */
     $localeRoute: (to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string) => RouteLocationResolved;
-    /** Resolve a path in the given locale, or the active one. */
+    /**
+     * Resolve a path in the given locale, or the active one. A string with an `http(s):`, `mailto:`
+     * or `tel:` scheme comes back as is: do not pass user input as a link target unchecked.
+     */
     $localePath: (to: RouteLocationNamedRaw | RouteLocationResolvedGeneric | string, locale?: string) => string;
     /**
      * Set per-locale params for the current route, so a dynamic segment can differ per language.
@@ -186,6 +304,12 @@ export interface PluginsInjections {
     $loadPageTranslations: (locale: string, routeName: string, translations: Translations) => Promise<void>;
     /** Install a callback invoked for every unresolved key. Pass `null` to remove it. */
     $setMissingHandler: (handler: MissingHandler | null) => void;
+    /**
+     * Drop every cached translation chunk and reload the current page's dictionary. The page
+     * keeps showing its current translations until the fresh ones arrive. Dev HMR calls it on
+     * every translation file change.
+     */
+    $clearCache: () => void;
 }
 /**
  * Helpers reachable through `useNuxtApp()` but deliberately absent from `useI18n()`.
@@ -200,6 +324,4 @@ export interface NuxtAppOnlyInjections {
      * Merges into the active locale and re-applies when the locale changes.
      */
     $defineI18nRoute: (routeDefinition: DefineI18nRouteConfig) => Promise<void>;
-    /** Drop every cached chunk, on the client and in the active dictionary. */
-    $clearCache: () => void;
 }

package/dist/runtime/plugins/01.plugin.js

@@ -1,160 +1,206 @@
-import { isNoPrefixStrategy } from "@i18n-micro/core";
-import { resolveI18nConfigWithRuntimeOverrides } from "@i18n-micro/utils/runtime-config";
-import { useState } from "#app";
+import { escapeHtml, isNoPrefixStrategy, localeIsoMap } from "@i18n-micro/core";
+import { detectLocaleFromAcceptLanguage } from "@i18n-micro/utils/accept-language";
+import { PREMERGED_ROOT_PAGE } from "@i18n-micro/utils/merge-source";
+import { hasProtocol } from "ufo";
+import { shallowRef } from "vue";
+import { useState } from "#app/composables/state";
 import { plural } from "#build/i18n.plural.mjs";
-import { createI18nStrategy, getI18nConfig } from "#build/i18n.strategy.mjs";
-import { createError, defineNuxtPlugin, navigateTo, useRouter, useRuntimeConfig } from "#imports";
-import { useI18nHead } from "../composables/useI18nHead.js";
+import { createI18nStrategy, domains } from "#build/i18n.strategy.mjs";
+import { createError, defineNuxtPlugin, injectHead, navigateTo, useHead, useRouter, useRuntimeConfig } from "#imports";
+import { usePageHead } from "../utils/page-head.js";
 import { useI18nLocale } from "../composables/useI18nLocale.js";
-import { createNuxtI18nPluginApi, NuxtI18n, NuxtTranslationLoader } from "../utils/nuxt-i18n.js";
+import { createI18nProvide, createNuxtI18nPluginApi } from "../utils/i18n-api.js";
+import { useResolvedI18nConfig } from "../utils/i18n-config.js";
+import { setupI18nNavigation } from "../utils/i18n-navigation.js";
+import { formatterFor, NuxtI18n, NuxtTranslationLoader } from "../utils/nuxt-i18n.js";
+import { ServerNuxtI18n } from "../utils/nuxt-i18n-server.js";
 import { setI18nDevtoolsBridge } from "../devtools/bridge.js";
+import { DEFAULT_SERVER_CACHE_SIZE } from "../utils/cache-keys.js";
 import { translationStorage } from "../utils/storage.js";
-const isDev = process.env.NODE_ENV !== "production";
-export default defineNuxtPlugin(async (nuxtApp) => {
-  const router = useRouter();
-  const i18nStrategy = createI18nStrategy(router);
-  const runtimeConfig = useRuntimeConfig();
-  const i18nConfig = resolveI18nConfigWithRuntimeOverrides(
-    getI18nConfig(),
-    runtimeConfig.public
-  );
-  translationStorage.configure({
-    maxSize: i18nConfig.cacheMaxSize ?? 0,
-    ttl: i18nConfig.cacheTtl ?? 0
-  });
-  const { locale: localeState, setLocale, getLocale, getEffectiveLocale, resolveInitialLocale, isValidLocale } = useI18nLocale();
-  const i18nRouteParams = useState("i18n-route-params", () => ({}));
-  const { resetPageHead } = useI18nHead();
-  const customMissingHandler = useState("i18n-missing-handler", () => null);
-  const i18n = new NuxtI18n({
+const SWITCHER_LINK = /class="switcher-locale-([^"]+)" href="[^"]*"/g;
+function createI18n(i18nConfig, missingHandler) {
+  return new (import.meta.server ? ServerNuxtI18n : NuxtI18n)({
     plural,
-    missingWarn: i18nConfig.missingWarn ?? true,
-    cacheMaxSize: i18nConfig.cacheMaxSize ?? 0,
-    getCustomMissingHandler: () => customMissingHandler.value,
+    missingWarn: i18nConfig.missingWarn,
+    cacheMaxSize: i18nConfig.cacheMaxSize,
+    getCustomMissingHandler: () => missingHandler.value,
+    formatter: import.meta.server ? formatterFor(i18nConfig) : void 0,
     numberFormats: i18nConfig.numberFormats,
-    datetimeFormats: i18nConfig.datetimeFormats
-  });
-  const getCurrentLocale = (route) => {
-    const r = route ?? router.currentRoute.value;
-    return i18nStrategy.getCurrentLocale(r, getLocale() ?? null);
-  };
-  const getPluginRouteName = (route, locale) => {
-    return i18nStrategy.getPluginRouteName(route, locale);
-  };
-  i18n.setRouteContextResolver((route) => {
-    const resolvedRoute = route ?? router.currentRoute.value;
-    const locale = getCurrentLocale(resolvedRoute);
-    return {
-      locale,
-      routeName: getPluginRouteName(resolvedRoute, locale)
-    };
+    datetimeFormats: i18nConfig.datetimeFormats,
+    timeZone: i18nConfig.timeZone,
+    localeIso: localeIsoMap(i18nConfig.linkLocales ?? i18nConfig.locales)
   });
-  nuxtApp.hook("page:transition:finish", () => {
-    i18n.finishTransition();
-  });
-  const loadOptions = {
-    apiBaseUrl: i18nConfig.apiBaseUrl ?? "_locales",
-    baseURL: runtimeConfig.app.baseURL,
+}
+function createLoadOptions(nuxtApp, i18nConfig) {
+  const { baseURL, cdnURL } = useRuntimeConfig().app;
+  const options = {
+    apiBaseUrl: i18nConfig.apiBaseUrl,
+    // files can move to the CDN with the rest of `public/`. A dictionary only the route answers cannot
+    baseURL: i18nConfig.publicPayloads && cdnURL || baseURL,
     apiBaseClientHost: i18nConfig.apiBaseClientHost,
     dateBuild: i18nConfig.dateBuild,
-    routesLocaleLinks: i18nConfig.routesLocaleLinks
+    routesLocaleLinks: i18nConfig.routesLocaleLinks,
+    rootDelta: i18nConfig.rootDelta
   };
-  const loader = new NuxtTranslationLoader({
-    i18n,
-    loadOptions,
-    isDev
-  });
-  const serverLocale = import.meta.server ? nuxtApp.ssrContext?.event?.context?.i18n?.locale : void 0;
+  if (import.meta.server) options.serverLoad = nuxtApp.ssrContext?.event?.context?.i18n?.load;
+  return options;
+}
+function resolveStartLocale({ nuxtApp, i18nConfig, i18nStrategy, renderLocale, initialRoute, locale, getCurrentLocale }) {
+  const { locale: localeState, getPreferredLocale, resolveInitialLocale, isValidLocale, validLocales } = locale;
+  const noPrefix = isNoPrefixStrategy(i18nConfig.strategy);
+  const shellLocale = () => {
+    const shell = i18nConfig.hashMode && i18nConfig.strategy === "prefix" && !nuxtApp.payload.serverRendered;
+    if (!shell || !i18nConfig.autoDetectLanguage || getPreferredLocale()) return void 0;
+    return detectLocaleFromAcceptLanguage(navigator.languages.join(","), validLocales);
+  };
+  const serverRequestLocale = () => renderLocale ?? nuxtApp.ssrContext?.event?.context?.i18n?.locale;
+  const requestLocale = import.meta.server ? serverRequestLocale() : shellLocale();
+  const preferredLocale = isValidLocale(localeState.value) ? localeState.value : requestLocale ?? getPreferredLocale();
+  const pathLocale = () => noPrefix ? i18nStrategy.getCurrentLocale(initialRoute, preferredLocale) : i18nStrategy.getLocaleFromPath(initialRoute.path);
   const initialLocale = resolveInitialLocale({
-    route: router.currentRoute.value,
-    serverLocale,
+    route: initialRoute,
+    urlLocale: i18nConfig.hashMode ? null : pathLocale(),
+    serverLocale: requestLocale,
+    preference: noPrefix ? preferredLocale ?? i18nConfig.defaultLocale : void 0,
     getLocaleFromRoute: (r) => getCurrentLocale(r)
   });
-  const initialRouteName = getPluginRouteName(router.currentRoute.value, initialLocale);
-  if (import.meta.server && initialRouteName === "index") {
-    const preloaded = nuxtApp.ssrContext?.event?.context?.i18n?.translations;
-    if (preloaded && typeof preloaded === "object" && Object.keys(preloaded).length > 0) {
-      translationStorage.seed(initialLocale, "index", preloaded);
-    }
-  }
-  try {
-    await loader.switchContext(initialLocale, initialRouteName);
-  } catch (e) {
-    if (isDev) console.error("[i18n] Initial load error:", e);
-    throw createError({ statusCode: 404, statusMessage: "Page Not Found" });
+  return initialLocale;
+}
+function rewriteSwitcherLinks(nuxtApp, api, params, resolveHref) {
+  nuxtApp.hooks.hook("app:rendered", ({ renderResult }) => {
+    if (!Object.keys(params.value ?? {}).length || !renderResult?.html?.includes('class="switcher-locale-')) return;
+    const codes = new Set(api.getLocales().map((locale) => locale.code));
+    renderResult.html = renderResult.html.replace(SWITCHER_LINK, (link, code) => {
+      if (!codes.has(code)) return link;
+      const path = api.switchLocalePath(code);
+      return `class="switcher-locale-${code}" href="${escapeHtml(hasProtocol(path) ? path : resolveHref(path))}"`;
+    });
+  });
+}
+function createPageHeadDrop(pageHead) {
+  let headAdopted = import.meta.server;
+  let headToDrop = null;
+  if (import.meta.client) {
+    const stop = injectHead().hooks?.hook("dom:rendered", () => {
+      stop?.();
+      headAdopted = true;
+      if (pageHead.value === headToDrop) pageHead.value = null;
+    });
   }
-  const getRouteName = (route, locale) => {
-    const selectedRoute = route ?? router.currentRoute.value;
-    const selectedLocale = locale ?? getCurrentLocale(selectedRoute);
-    return i18nStrategy.getRouteBaseName(selectedRoute, selectedLocale) ?? "";
+  return () => {
+    if (headAdopted) pageHead.value = null;
+    else headToDrop = pageHead.value;
   };
-  const {
-    helper,
-    switchContext,
-    provide: provideApi
-  } = createNuxtI18nPluginApi({
-    i18n,
-    loader,
-    i18nStrategy,
-    i18nConfig,
-    router,
-    getCurrentLocale,
-    getEffectiveLocale,
-    getPluginRouteName,
-    getRouteName,
-    i18nRouteParams,
-    setLocale,
-    isValidLocale,
-    navigateTo,
-    setMissingHandler: (handler) => {
-      customMissingHandler.value = handler;
-    }
-  });
-  if (import.meta.dev && import.meta.client) {
-    setI18nDevtoolsBridge({
-      i18n,
+}
+export default defineNuxtPlugin({
+  name: "i18n-plugin-loader",
+  async setup(nuxtApp) {
+    const router = useRouter();
+    const i18nConfig = useResolvedI18nConfig(nuxtApp);
+    const i18nStrategy = createI18nStrategy(router, i18nConfig);
+    translationStorage.configure({
+      // the SSR copy is process-wide, so it is bounded like the payload cache
+      maxSize: i18nConfig.cacheMaxSize || (import.meta.server ? DEFAULT_SERVER_CACHE_SIZE : 0),
+      ttl: i18nConfig.cacheTtl
+    });
+    const locale = useI18nLocale();
+    const { locale: localeState, getPreferredLocale, isValidLocale } = locale;
+    const i18nRouteParams = useState("i18n-route-params", () => ({}));
+    const pageHead = usePageHead();
+    const customMissingHandler = shallowRef(null);
+    const i18n = createI18n(i18nConfig, customMissingHandler);
+    const islandLocale = nuxtApp.ssrContext?.islandContext?.props?.locale;
+    const renderLocale = isValidLocale(islandLocale) ? islandLocale : void 0;
+    const getCurrentLocale = (route) => {
+      if (!route && renderLocale) return renderLocale;
+      const r = route ?? router.currentRoute.value;
+      return i18nStrategy.getCurrentLocale(r, getPreferredLocale());
+    };
+    i18n.setRouteContextResolver((route) => {
+      const resolvedRoute = route ?? router.currentRoute.value;
+      const routeLocale = getCurrentLocale(resolvedRoute);
+      return { locale: routeLocale, routeName: i18nStrategy.getPluginRouteName(resolvedRoute, routeLocale) };
+    });
+    const prerender = import.meta.server && import.meta.prerender;
+    const loadOptions = createLoadOptions(nuxtApp, i18nConfig);
+    const onFailedRead = () => {
+      const context = nuxtApp.ssrContext?.event?.context.i18n;
+      if (context && !prerender) context.failedRead = true;
+    };
+    const loader = new NuxtTranslationLoader({ i18n, loadOptions, prerender, onFailedRead });
+    const initialRoute = router.currentRoute.value;
+    const initialLocale = resolveStartLocale({
+      nuxtApp,
       i18nConfig,
-      localeState
+      i18nStrategy,
+      renderLocale,
+      initialRoute,
+      locale,
+      getCurrentLocale
     });
-  }
-  router.beforeEach(async (to, from) => {
-    if (to.name !== from.name) {
-      i18nRouteParams.value = {};
-      resetPageHead();
-    }
-    const shouldSwitchContext = to.path !== from.path || isNoPrefixStrategy(i18nConfig.strategy);
-    if (!shouldSwitchContext) {
-      return;
-    }
+    const initialRouteName = i18nStrategy.getPluginRouteName(initialRoute, initialLocale);
     try {
-      const targetLocale = getEffectiveLocale(to, (r) => getCurrentLocale(r));
-      const targetRouteName = getPluginRouteName(to, targetLocale);
-      let applied = true;
-      if (targetLocale !== i18n.getCurrentLocale() || targetRouteName !== i18n.getCurrentRouteName()) {
-        applied = await switchContext(targetLocale, targetRouteName);
-      } else {
-        loader.invalidatePendingSwitches();
-      }
-      if (applied && targetLocale && isValidLocale(targetLocale) && localeState.value !== targetLocale) {
-        setLocale(targetLocale);
-      }
+      await loader.switchContext(initialLocale, initialRouteName);
     } catch (e) {
-      if (isDev) console.error("[i18n] Navigation error:", e);
+      if (process.env.NODE_ENV !== "production") console.error("[i18n] Initial load error:", e);
+      if (prerender) throw e;
+      throw createError({ statusCode: 404, statusMessage: "Page Not Found" });
     }
-    return;
-  });
-  const provideData = {
-    ...provideApi,
-    helper,
-    i18n: void 0,
-    __micro: true
-  };
-  const $provideData = Object.fromEntries(Object.entries(provideData).map(([key, value]) => [`$${key}`, value]));
-  provideData.i18n = { ...provideData, ...$provideData };
-  return {
-    provide: {
-      ...provideData,
-      getI18nConfig: () => i18nConfig
+    if (import.meta.server && !i18nConfig.noScripts && !nuxtApp.ssrContext?.event?.context?._nitro?.routeRules?.noScripts) {
+      const hint = (key, href) => ({ key, rel: "preload", as: "fetch", crossorigin: "anonymous", href });
+      const link = [hint("i18n-preload", translationStorage.clientUrl(initialLocale, initialRouteName, loadOptions))];
+      if (i18nConfig.rootDelta) link.push(hint("i18n-preload-root", translationStorage.clientUrl(initialLocale, PREMERGED_ROOT_PAGE, loadOptions)));
+      useHead({ link });
     }
-  };
+    const hydrated = shallowRef(false);
+    nuxtApp.hooks.hookOnce("app:suspense:resolve", async () => {
+      hydrated.value = true;
+      if (!import.meta.client || !i18nConfig.hashMode) return;
+      const hashLocale = i18nStrategy.getLocaleFromPath(router.currentRoute.value.path);
+      if (hashLocale && hashLocale !== localeState.value) await api.provide.switchLocale(hashLocale);
+    });
+    const api = createNuxtI18nPluginApi({
+      i18n,
+      loader,
+      i18nStrategy,
+      // $getLocales lists the locales of other domains too: link targets
+      i18nConfig: domains ? { ...i18nConfig, locales: i18nConfig.linkLocales ?? i18nConfig.locales } : i18nConfig,
+      router,
+      locale,
+      getCurrentLocale,
+      i18nRouteParams,
+      navigateTo,
+      setMissingHandler: (handler) => {
+        customMissingHandler.value = handler;
+      },
+      // a ref: a link rendered without the hash gets it back when hydration ends
+      isHydrating: () => !hydrated.value && nuxtApp.isHydrating === true
+    });
+    if (import.meta.server) rewriteSwitcherLinks(nuxtApp, api.provide, i18nRouteParams, (path) => router.resolve(path).href);
+    if (import.meta.dev && import.meta.client) {
+      setI18nDevtoolsBridge({
+        i18n,
+        i18nConfig,
+        localeState
+      });
+    }
+    const dropPageHead = createPageHeadDrop(pageHead);
+    setupI18nNavigation({
+      nuxtApp,
+      router,
+      i18n,
+      loader,
+      i18nConfig,
+      i18nStrategy,
+      locale,
+      api,
+      leavePage: () => {
+        i18nRouteParams.value = {};
+        dropPageHead();
+      }
+    });
+    const { provide, install } = createI18nProvide({ api, i18nConfig, router, i18nRouteParams });
+    install(nuxtApp);
+    return { provide };
+  }
 });