intor 2.3.33 → 2.3.34

package/dist/next/src/routing/outbound/resolve-outbound.js

@@ -0,0 +1,23 @@
+import { decideStrategy } from './decide-strategy.js';
+import { determineTarget } from './determine-target.js';
+
+/**
+ * Resolve an outbound routing attempt into an executable result.
+ */
+function resolveOutbound(config, currentLocale, currentPathname, intent) {
+    // --------------------------------------------------
+    // Determine outbound target
+    // --------------------------------------------------
+    const target = determineTarget(config, currentLocale, currentPathname, intent);
+    // --------------------------------------------------
+    // Decide outbound strategy
+    // --------------------------------------------------
+    const strategy = decideStrategy(config, target);
+    return {
+        locale: target.locale,
+        destination: target.destination,
+        kind: strategy,
+    };
+}
+
+export { resolveOutbound };

package/dist/next/src/server/messages/load-messages.js

@@ -29,12 +29,12 @@ const loadMessages = async ({ config, locale, readers, allowCacheWrite = false,
         logger.warn("No loader options have been configured in the current config.");
         return;
     }
-    const { type, namespaces, concurrency } = loader;
+    const { mode, namespaces, concurrency } = loader;
     const fallbackLocales = config.fallbackLocales[locale] || [];
     logger.info(`Loading messages for locale "${locale}".`);
     logger.trace("Starting to load messages with runtime context.", {
-        loaderType: type,
-        ...(type === "local" ? { rootDir: loader.rootDir } : {}),
+        loaderMode: mode,
+        ...(mode === "local" ? { rootDir: loader.rootDir } : {}),
         locale,
         fallbackLocales: fallbackLocales.join(", "),
         namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : "*",
@@ -43,7 +43,7 @@ const loadMessages = async ({ config, locale, readers, allowCacheWrite = false,
     // Dispatch to loader implementation
     // ---------------------------------------------------------------------------
     let loadedMessages;
-    if (type === "local") {
+    if (mode === "local") {
         loadedMessages = await loadLocalMessages({
             id: config.id,
             locale,
@@ -56,7 +56,7 @@ const loadMessages = async ({ config, locale, readers, allowCacheWrite = false,
             loggerOptions: config.logger,
         });
     }
-    else if (type === "remote") {
+    else if (mode === "remote") {
         loadedMessages = await loadRemoteMessages({
             locale,
             fallbackLocales,

package/dist/react/src/client/react/helpers/use-intor.js

@@ -1,9 +1,4 @@
 import * as React from 'react';
-import '../../../core/error/intor-error.js';
-import 'logry';
-import 'p-limit';
-import { mergeMessages } from '../../../core/messages/merge-messages.js';
-import 'intor-translator';
 import { getClientLocale } from '../../shared/helpers/get-client-locale.js';
 
 function useIntor(config, loader) {
@@ -23,13 +18,13 @@ function useIntor(config, loader) {
     const onLocaleChange = React.useCallback(async (newLocale) => {
         activeLocaleRef.current = newLocale;
         setIsLoading(true);
-        const loaded = await loader(newLocale);
+        const loaded = await loader(config, newLocale);
         // Ignore outdated results when locale changes again.
         if (activeLocaleRef.current !== newLocale)
             return;
-        setMessages(mergeMessages(config.messages, loaded, { config, locale: newLocale }));
+        setMessages(loaded);
         setIsLoading(false);
-    }, [loader, config]);
+    }, [config, loader]);
     // ---------------------------------------------------------------------------
     // Initial load
     // ---------------------------------------------------------------------------

package/dist/react/src/client/react/provider/intor-provider.js

@@ -6,7 +6,7 @@ import { useLocaleEffects } from './effects/use-locale-effects.js';
 import { useMessagesEffects } from './effects/use-messages-effects.js';
 
 const IntorContext = React.createContext(undefined);
-const IntorProvider = ({ value: { config, locale: initialLocale, messages, handlers, plugins, onLocaleChange, isLoading: externalIsLoading, }, children, }) => {
+function IntorProvider({ value: { config, locale: initialLocale, messages, handlers, plugins, onLocaleChange, isLoading: externalIsLoading, }, children, }) {
     // -----------------------------------------------------------------------------
     // Internal state
     // -----------------------------------------------------------------------------
@@ -58,6 +58,6 @@ const IntorProvider = ({ value: { config, locale: initialLocale, messages, handl
     useLocaleEffects(config, locale);
     useMessagesEffects(config, locale, setRuntimeMessages, setInternalIsLoading);
     return (jsx(IntorContext.Provider, { value: { config, locale, setLocale, translator }, children: children }));
-};
+}
 
 export { IntorContext, IntorProvider };

package/dist/react/src/client/shared/messages/create-refetch-messages.js

@@ -18,7 +18,7 @@ const createRefetchMessages = ({ config, onLoadingStart, onLoadingEnd, onMessage
     return async function refetchMessages(newLocale) {
         // No-op when remote loading is not enabled
         const loader = resolveLoaderOptions(config);
-        if (!loader || loader.type !== "remote")
+        if (!loader || loader.mode !== "remote")
             return;
         // Abort previous request
         controller?.abort();

package/dist/react/src/core/utils/resolve-loader-options.js

@@ -18,12 +18,14 @@
  *   for the given runtime.
  */
 const resolveLoaderOptions = (config, runtime) => {
-    // --- runtime: client ---
+    // ------------------------------------------------
+    // runtime: client
+    // ------------------------------------------------
     {
         const client = config.client?.loader;
         if (client) {
             // Client loader is always remote by design
-            return { type: "remote", ...client };
+            return { mode: "remote", ...client };
         }
         return config.server?.loader ?? config.loader;
     }

package/dist/svelte/src/client/shared/messages/create-refetch-messages.js

@@ -18,7 +18,7 @@ const createRefetchMessages = ({ config, onLoadingStart, onLoadingEnd, onMessage
     return async function refetchMessages(newLocale) {
         // No-op when remote loading is not enabled
         const loader = resolveLoaderOptions(config);
-        if (!loader || loader.type !== "remote")
+        if (!loader || loader.mode !== "remote")
             return;
         // Abort previous request
         controller?.abort();

package/dist/svelte/src/core/utils/resolve-loader-options.js

@@ -18,12 +18,14 @@
  *   for the given runtime.
  */
 const resolveLoaderOptions = (config, runtime) => {
-    // --- runtime: client ---
+    // ------------------------------------------------
+    // runtime: client
+    // ------------------------------------------------
     {
         const client = config.client?.loader;
         if (client) {
             // Client loader is always remote by design
-            return { type: "remote", ...client };
+            return { mode: "remote", ...client };
         }
         return config.server?.loader ?? config.loader;
     }

package/dist/svelte-kit/export/svelte-kit/index.js

@@ -1 +1 @@
-export { useNavigation } from '../../src/adapters/svelte-kit/navigation/use-navigation.js';
+export { useNavigation } from '../../src/adapters/svelte-kit/use-navigation.js';

package/dist/svelte-kit/export/svelte-kit/server/index.js

@@ -1,2 +1,2 @@
-export { createIntorHandle } from '../../../src/adapters/svelte-kit/server/create-intor-handle.js';
+export { createIntorHandler } from '../../../src/adapters/svelte-kit/server/create-intor-handler.js';
 export { intor } from '../../../src/adapters/svelte-kit/server/intor.js';

package/dist/svelte-kit/src/adapters/svelte-kit/server/{create-intor-handle.js → create-intor-handler.js}

@@ -17,32 +17,33 @@ import { getLocaleFromAcceptLanguage } from '../../../routing/locale/get-locale-
  *
  * @platform SvelteKit
  */
-function createIntorHandle(config) {
+function createIntorHandler(config) {
     return async ({ event, resolve }) => {
+        const { host, searchParams, pathname: rawPathname } = event.url;
         // Locale from Accept-Language header
         const acceptLanguage = event.request.headers.get("accept-language");
         const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(acceptLanguage, config.supportedLocales);
         // ----------------------------------------------------------
         // Resolve inbound routing decision (pure computation)
         // ----------------------------------------------------------
-        let inbound;
+        let inboundResult;
         if (isSvelteKitSSG(event)) {
-            inbound = {
+            inboundResult = {
                 locale: event.params?.locale,
                 localeSource: "path",
-                pathname: event.url.pathname,
+                pathname: rawPathname,
                 shouldRedirect: false,
             };
         }
         else {
-            inbound = await resolveInbound(config, event.url.pathname, false, {
-                host: event.url.host,
-                query: normalizeQuery(Object.fromEntries(event.url.searchParams.entries())),
+            inboundResult = await resolveInbound(config, rawPathname, {
+                host,
+                query: normalizeQuery(Object.fromEntries(searchParams.entries())),
                 cookie: event.cookies.get(config.cookie.name),
                 detected: localeFromAcceptLanguage || config.defaultLocale,
             });
         }
-        const { locale, localeSource, pathname, shouldRedirect } = inbound;
+        const { locale, localeSource, pathname, shouldRedirect } = inboundResult;
         // ----------------------------------------------------------
         // Redirect if needed
         // ----------------------------------------------------------
@@ -64,4 +65,4 @@ function createIntorHandle(config) {
     };
 }
 
-export { createIntorHandle };
+export { createIntorHandler };

package/dist/svelte-kit/src/adapters/svelte-kit/{navigation/use-navigation.js → use-navigation.js}

@@ -1,11 +1,11 @@
 import { get } from 'svelte/store';
-import { executeNavigation } from '../../../client/shared/navigation/execute-navigation.js';
+import { executeNavigation } from '../../client/shared/navigation/execute-navigation.js';
 import { useIntorContext } from 'intor/svelte';
-import '../../../core/error/intor-error.js';
+import '../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
-import { resolveNavigation } from '../../../routing/navigation/resolve-navigation.js';
+import { resolveOutbound } from '../../routing/outbound/resolve-outbound.js';
 import { goto } from '$app/navigation';
 import { page } from '$app/state';
 
@@ -21,13 +21,13 @@ function useNavigation() {
     const { config, locale: currentLocale, setLocale } = useIntorContext();
     async function goto$1(url, opts) {
         const { locale, ...rest } = opts || {};
-        const navigationResult = resolveNavigation(config, get(currentLocale), page.url.pathname, { destination: url, locale });
-        executeNavigation(navigationResult, {
+        const outboundResult = resolveOutbound(config, get(currentLocale), page.url.pathname, { destination: url, locale });
+        executeNavigation(outboundResult, {
             config,
             currentLocale: get(currentLocale),
             setLocale,
         });
-        return goto(navigationResult.destination, rest);
+        return goto(outboundResult.destination, rest);
     }
     return {
         goto: goto$1,

package/dist/svelte-kit/src/client/shared/navigation/execute-navigation.js

@@ -6,17 +6,17 @@ import { shouldSyncLocale } from '../../../policies/should-sync-locale.js';
 import { setLocaleCookie } from '../utils/locale/set-locale-cookie.js';
 
 /**
- * Executes a resolved navigation result.
+ * Executes a resolved outbound routing result.
  *
- * Applies all imperative side effects required to complete navigation,
- * including locale synchronization, cookie persistence, and full reloads.
+ * Applies all imperative side effects required to realize the outbound decision,
+ * including locale synchronization, cookie persistence, and full page reloads.
  *
- * This function must be called after `resolveNavigation`.
+ * This function must be called after `resolveOutbound`.
  */
-function executeNavigation(navigationResult, context, e) {
+function executeNavigation(outboundResult, context, e) {
     const { config, currentLocale, setLocale } = context;
     const { cookie } = config;
-    const { destination, kind, locale } = navigationResult;
+    const { destination, kind, locale } = outboundResult;
     // ------------------------------------------------------
     // External navigation: let browser handle it
     // ------------------------------------------------------

package/dist/svelte-kit/src/core/utils/resolve-loader-options.js

@@ -18,16 +18,20 @@
  *   for the given runtime.
  */
 const resolveLoaderOptions = (config, runtime) => {
-    // --- runtime: client ---
+    // ------------------------------------------------
+    // runtime: client
+    // ------------------------------------------------
     if (runtime === "client") {
         const client = config.client?.loader;
         if (client) {
             // Client loader is always remote by design
-            return { type: "remote", ...client };
+            return { mode: "remote", ...client };
         }
         return config.server?.loader ?? config.loader;
     }
-    // --- runtime: server ---
+    // ------------------------------------------------
+    // runtime: server
+    // ------------------------------------------------
     return config.server?.loader ?? config.loader;
 };
 

package/dist/svelte-kit/src/policies/shoud-full-reload.js

@@ -9,7 +9,7 @@ import 'intor-translator';
  */
 function shouldFullReload(config) {
     const loader = resolveLoaderOptions(config, "client");
-    return (loader?.type === "local" || config.routing.outbound.forceFullReload === true);
+    return (loader?.mode === "local" || config.routing.outbound.forceFullReload === true);
 }
 
 export { shouldFullReload };

package/dist/svelte-kit/src/routing/inbound/resolve-inbound.js

@@ -13,7 +13,8 @@ import { resolvePathname } from './resolve-pathname/resolve-pathname.js';
  *
  * No side effects. No navigation.
  */
-async function resolveInbound(config, rawPathname, hasRedirected, localeInputs) {
+async function resolveInbound(config, rawPathname, localeInputs, options) {
+    const { queryKey } = config.routing.inbound;
     const { host, query, cookie, detected } = localeInputs;
     // ------------------------------------------------------
     // Resolve locale from inbound inputs
@@ -22,9 +23,7 @@ async function resolveInbound(config, rawPathname, hasRedirected, localeInputs)
     const { locale, localeSource } = resolveLocale(config, {
         path: { locale: pathLocale },
         host: { locale: getLocaleFromHost(host) },
-        query: {
-            locale: getLocaleFromQuery(query, config.routing.inbound.queryKey),
-        },
+        query: { locale: getLocaleFromQuery(query, queryKey) },
         cookie: { locale: cookie },
         detected: { locale: detected },
     });

package/dist/svelte-kit/src/routing/inbound/resolve-locale/resolve-locale.js

@@ -7,9 +7,9 @@ import 'intor-translator';
 /**
  * Resolve the active locale from inbound routing configuration.
  *
- * Iterates through configured locale sources and returns the first
- * normalized, supported locale. Falls back to the detected locale
- * or the default locale if none match.
+ * Iterates through configured locale sources and returns the first normalized, supported locale.
+ *
+ * Falls back to the detected locale or the default locale if none match.
  */
 function resolveLocale(config, context) {
     const { localeSources } = config.routing.inbound;
@@ -24,9 +24,10 @@ function resolveLocale(config, context) {
         };
     }
     // Fallback: detected is always available
+    const fallback = normalizeLocale(context.detected.locale, config.supportedLocales) ||
+        config.defaultLocale;
     return {
-        locale: normalizeLocale(context.detected.locale, config.supportedLocales) ||
-            config.defaultLocale,
+        locale: fallback,
         localeSource: "detected",
     };
 }

package/dist/svelte-kit/src/routing/locale/get-locale-from-query.js

@@ -11,19 +11,11 @@
  *
  * getLocaleFromQuery({}, "locale")
  * // => undefined
- *
- * getLocaleFromQuery({ locale: ["zh-TW"] }, "locale")
- * // => "zh-TW"
- * ```
  */
 function getLocaleFromQuery(query, queryKey) {
     if (!query)
         return;
-    const raw = query[queryKey];
-    if (!raw)
-        return;
-    const value = Array.isArray(raw) ? raw[0] : raw;
-    return value;
+    return query[queryKey];
 }
 
 export { getLocaleFromQuery };

package/dist/svelte-kit/src/routing/{navigation → outbound}/decide-strategy.js

@@ -2,16 +2,13 @@ import { shouldFullReload } from '../../policies/shoud-full-reload.js';
 
 /**
  * Decide how a resolved navigation target should be executed.
- *
- * This function determines whether navigation should be handled
- * by the browser, performed client-side, or forced to reload.
  */
 function decideStrategy(config, target) {
     // External destinations are always handled by the browser
     if (target.isExternal) {
-        return { kind: "external" };
+        return "external";
     }
-    return shouldFullReload(config) ? { kind: "reload" } : { kind: "client" };
+    return shouldFullReload(config) ? "reload" : "client";
 }
 
 export { decideStrategy };

package/dist/{next/src/routing/navigation/derive-target.js → svelte-kit/src/routing/outbound/determine-target.js}

@@ -5,12 +5,9 @@ import { deriveQueryDestination } from './utils/derive-query-destination.js';
 import { isExternalDestination } from './utils/is-external-destination.js';
 
 /**
- * Derives a navigation target for a single navigation attempt.
- *
- * This function computes the final destination URL and execution flags
- * based on the current routing configuration and locale context.
+ * Determines the outbound routing target.
  */
-function deriveTarget(config, currentLocale, currentPathname, intent) {
+function determineTarget(config, currentLocale, currentPathname, intent) {
     const { supportedLocales, routing } = config;
     // ----------------------------------------------------------------
     // Resolve effective locale
@@ -55,4 +52,4 @@ function deriveTarget(config, currentLocale, currentPathname, intent) {
     };
 }
 
-export { deriveTarget };
+export { determineTarget };

package/dist/svelte-kit/src/routing/outbound/resolve-outbound.js

@@ -0,0 +1,23 @@
+import { decideStrategy } from './decide-strategy.js';
+import { determineTarget } from './determine-target.js';
+
+/**
+ * Resolve an outbound routing attempt into an executable result.
+ */
+function resolveOutbound(config, currentLocale, currentPathname, intent) {
+    // --------------------------------------------------
+    // Determine outbound target
+    // --------------------------------------------------
+    const target = determineTarget(config, currentLocale, currentPathname, intent);
+    // --------------------------------------------------
+    // Decide outbound strategy
+    // --------------------------------------------------
+    const strategy = decideStrategy(config, target);
+    return {
+        locale: target.locale,
+        destination: target.destination,
+        kind: strategy,
+    };
+}
+
+export { resolveOutbound };

package/dist/svelte-kit/src/server/messages/load-messages.js

@@ -29,12 +29,12 @@ const loadMessages = async ({ config, locale, readers, allowCacheWrite = false,
         logger.warn("No loader options have been configured in the current config.");
         return;
     }
-    const { type, namespaces, concurrency } = loader;
+    const { mode, namespaces, concurrency } = loader;
     const fallbackLocales = config.fallbackLocales[locale] || [];
     logger.info(`Loading messages for locale "${locale}".`);
     logger.trace("Starting to load messages with runtime context.", {
-        loaderType: type,
-        ...(type === "local" ? { rootDir: loader.rootDir } : {}),
+        loaderMode: mode,
+        ...(mode === "local" ? { rootDir: loader.rootDir } : {}),
         locale,
         fallbackLocales: fallbackLocales.join(", "),
         namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : "*",
@@ -43,7 +43,7 @@ const loadMessages = async ({ config, locale, readers, allowCacheWrite = false,
     // Dispatch to loader implementation
     // ---------------------------------------------------------------------------
     let loadedMessages;
-    if (type === "local") {
+    if (mode === "local") {
         loadedMessages = await loadLocalMessages({
             id: config.id,
             locale,
@@ -56,7 +56,7 @@ const loadMessages = async ({ config, locale, readers, allowCacheWrite = false,
             loggerOptions: config.logger,
         });
     }
-    else if (type === "remote") {
+    else if (mode === "remote") {
         loadedMessages = await loadRemoteMessages({
             locale,
             fallbackLocales,

package/dist/types/export/express/index.d.ts

@@ -1 +1 @@
-export { createIntorMiddleware, getTranslator } from "../../src/adapters/express";
+export { createIntorHandler, getTranslator } from "../../src/adapters/express";

package/dist/types/export/next/index.d.ts

@@ -1 +1 @@
-export { Link, useRouter, redirect } from "../../src/adapters/next/navigation";
+export { Link, useRouter, redirect, createIntorHandler } from "../../src/adapters/next";

package/dist/types/export/svelte-kit/index.d.ts

@@ -1 +1 @@
-export { useNavigation } from "../../src/adapters/svelte-kit/navigation";
+export { useNavigation } from "../../src/adapters/svelte-kit";

package/dist/types/export/svelte-kit/server/index.d.ts

@@ -1 +1 @@
-export { createIntorHandle, intor } from "../../../src/adapters/svelte-kit/server";
+export { createIntorHandler, intor } from "../../../src/adapters/svelte-kit/server";

package/dist/types/src/adapters/express/{middleware/create-intor-middleware.d.ts → create-intor-handler.d.ts}

@@ -1,6 +1,6 @@
-import type { IntorResolvedConfig } from "../../../config";
+import type { IntorResolvedConfig } from "../../config";
 import type { Request, Response, NextFunction } from "express";
-import { type GetTranslatorParams } from "../../../server";
+import { type GetTranslatorParams } from "../../server";
 /**
  * Resolves locale-aware routing for the current execution context.
  *
@@ -11,4 +11,4 @@ import { type GetTranslatorParams } from "../../../server";
  *
  * @platform Express
  */
-export declare function createIntorMiddleware(config: IntorResolvedConfig, options?: Omit<GetTranslatorParams, "locale">): (req: Request, _res: Response, next: NextFunction) => Promise<void>;
+export declare function createIntorHandler(config: IntorResolvedConfig, options?: Omit<GetTranslatorParams, "locale">): (req: Request, _res: Response, next: NextFunction) => Promise<void>;

package/dist/types/src/adapters/express/{helpers/get-translator.d.ts → get-translator.d.ts}

@@ -1,6 +1,6 @@
-import type { IntorResolvedConfig } from "../../../config";
-import type { GenConfigKeys, GenMessages, GenReplacements } from "../../../core";
-import type { GetTranslatorParams, TranslatorInstanceServer } from "../../../server";
+import type { IntorResolvedConfig } from "../../config";
+import type { GenConfigKeys, GenMessages, GenReplacements } from "../../core";
+import type { GetTranslatorParams, TranslatorInstanceServer } from "../../server";
 import type { Request } from "express";
 import type { LocalizedPreKey } from "intor-translator";
 type GetTranslatorExpressParams = Omit<GetTranslatorParams, "locale">;

package/dist/types/src/adapters/express/global.d.ts

@@ -1,6 +1,6 @@
-import type { TranslatorInstance } from "../../core";
 import type { InboundContext } from "../../routing";
-import type { Locale, LocaleMessages, Replacement } from "intor-translator";
+import type { TranslatorInstanceServer } from "../../server";
+import type { Locale, LocaleMessages } from "intor-translator";
 /**
  * Global type augmentations for Express request
  */
@@ -9,8 +9,9 @@ declare global {
         interface Request {
             intor: InboundContext;
             locale: Locale;
-            hasKey: TranslatorInstance<LocaleMessages, Replacement, "string">["hasKey"];
-            t: TranslatorInstance<LocaleMessages, Replacement, "string">["t"];
+            hasKey: TranslatorInstanceServer<LocaleMessages>["hasKey"];
+            t: TranslatorInstanceServer<LocaleMessages>["t"];
+            tRich: TranslatorInstanceServer<LocaleMessages>["tRich"];
         }
     }
 }

package/dist/types/src/adapters/express/index.d.ts

@@ -1,3 +1,3 @@
-export { createIntorMiddleware } from "./middleware";
-export { getTranslator } from "./helpers";
+export { createIntorHandler } from "./create-intor-handler";
+export { getTranslator } from "./get-translator";
 export * from "./global";

package/dist/types/src/adapters/next/{proxy/intor-proxy.d.ts → create-intor-handler.d.ts}

@@ -1,4 +1,4 @@
-import type { IntorResolvedConfig } from "../../../config";
+import type { IntorResolvedConfig } from "../../config";
 import type { NextRequest } from "next/server";
 /**
  * Resolves locale-aware routing for the current execution context.
@@ -9,4 +9,4 @@ import type { NextRequest } from "next/server";
  *
  * @platform Next.js
  */
-export declare const intorProxy: (config: IntorResolvedConfig, request: NextRequest) => Promise<Response>;
+export declare const createIntorHandler: (config: IntorResolvedConfig, request: NextRequest) => Promise<Response>;

package/dist/types/src/adapters/next/{navigation/index.d.ts → index.d.ts}

@@ -1,3 +1,4 @@
 export { Link } from "./link";
 export { useRouter } from "./use-router";
 export { redirect } from "./redirect";
+export { createIntorHandler } from "./create-intor-handler";

package/dist/types/src/adapters/next/{navigation/link.d.ts → link.d.ts}

@@ -1,4 +1,4 @@
-import type { GenConfigKeys, GenLocale } from "../../../core";
+import type { GenConfigKeys, GenLocale } from "../../core";
 import type { Url } from "next/dist/shared/lib/router/router";
 import type { LinkProps as NextLinkProps } from "next/link";
 import * as React from "react";

package/dist/types/src/adapters/next/{navigation/redirect.d.ts → redirect.d.ts}

@@ -1,5 +1,5 @@
-import type { IntorResolvedConfig } from "../../../config";
-import type { GenConfigKeys, GenLocale } from "../../../core";
+import type { IntorResolvedConfig } from "../../config";
+import type { GenConfigKeys, GenLocale } from "../../core";
 import type { RedirectType } from "next/navigation";
 /**
  * Redirect to a locale-aware destination for the current execution context.

package/dist/types/src/adapters/next/{navigation/use-router.d.ts → use-router.d.ts}

@@ -1,4 +1,4 @@
-import type { GenConfigKeys, GenLocale } from "../../../core";
+import type { GenConfigKeys, GenLocale } from "../../core";
 import type { NavigateOptions, PrefetchOptions } from "next/dist/shared/lib/app-router-context.shared-runtime";
 /**
  * Locale-aware router hook for the current execution context.

package/dist/types/src/adapters/svelte-kit/server/{create-intor-handle.d.ts → create-intor-handler.d.ts}

@@ -9,4 +9,4 @@ import type { Handle } from "@sveltejs/kit";
  *
  * @platform SvelteKit
  */
-export declare function createIntorHandle(config: IntorResolvedConfig): Handle;
+export declare function createIntorHandler(config: IntorResolvedConfig): Handle;

package/dist/types/src/adapters/svelte-kit/server/index.d.ts

@@ -1,2 +1,2 @@
-export { createIntorHandle } from "./create-intor-handle";
+export { createIntorHandler } from "./create-intor-handler";
 export { intor } from "./intor";

package/dist/types/src/adapters/svelte-kit/server/utils/is-svelte-kit-ssg.d.ts

@@ -5,4 +5,4 @@ import type { RequestEvent } from "@sveltejs/kit";
  * This is NOT a guaranteed signal.
  * It intentionally prefers false positives over false negatives.
  */
-export declare function isSvelteKitSSG(event: RequestEvent<Record<string, string>, string | null>): boolean;
+export declare function isSvelteKitSSG(event: RequestEvent): boolean;

package/dist/types/src/adapters/svelte-kit/{navigation/use-navigation.d.ts → use-navigation.d.ts}

@@ -1,4 +1,4 @@
-import type { GenConfigKeys, GenLocale } from "../../../core";
+import type { GenConfigKeys, GenLocale } from "../../core";
 import { goto as svelteGoto } from "$app/navigation";
 /**
  * Locale-aware navigation utilities for SvelteKit.