intor 2.4.17 → 2.5.0

package/dist/hono/src/routing/pathname/standardize-pathname.js

@@ -1,34 +1,39 @@
 import { LOCALE_PLACEHOLDER } from '../../core/constants/locale-placeholder.js';
-import '../../core/error/intor-error.js';
-import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
 /**
- * Standardizes a canonical pathname into an internal routing template
- * by applying the base path and injecting a locale placeholder.
+ * Standardizes a canonical pathname into an internal routing template.
+ *
+ * Standardized representation:
+ * - Prepends the deployment prefix (`basePath`) if defined
+ * - Injects the `{locale}` placeholder as the first path segment
+ * - Preserves the canonical pathname structure
+ *
+ * Input must be a canonical pathname.
+ *
+ * Output is an internal routing template and
+ * is not a locale-resolved URL.
  *
  * @example
  * ```ts
  * // config.routing.basePath: "/app",
- * // config.routing.prefix: "all"
  * standardizePathname("/about", config);
  * // => "/app/{locale}/about"
  * ```
  */
-const standardizePathname = (canonicalizedPathname, config) => {
-    const { basePath } = config.routing;
-    // Normalize each segment before join to avoid redundant slashes
-    const parts = [
-        normalizePathname(basePath),
-        LOCALE_PLACEHOLDER,
-        normalizePathname(canonicalizedPathname),
-    ];
-    // Avoid double slashes between segments
-    const standardizedPathname = parts.join("/").replaceAll(/\/{2,}/g, "/");
-    // Final normalization to ensure leading slash, no trailing
-    return normalizePathname(standardizedPathname);
+const standardizePathname = (canonicalPathname, config) => {
+    const { routing } = config;
+    const basePath = routing.basePath && routing.basePath !== "/" ? routing.basePath : "";
+    if (canonicalPathname === "/") {
+        return basePath
+            ? `${basePath}/${LOCALE_PLACEHOLDER}`
+            : `/${LOCALE_PLACEHOLDER}`;
+    }
+    return basePath
+        ? `${basePath}/${LOCALE_PLACEHOLDER}${canonicalPathname}`
+        : `/${LOCALE_PLACEHOLDER}${canonicalPathname}`;
 };
 
 export { standardizePathname };

package/dist/next/src/adapters/next/create-intor-handler.js

@@ -1,6 +1,5 @@
 import { NextResponse } from 'next/server';
 import { INTOR_HEADERS } from '../../core/constants/headers.js';
-import '../../core/error/intor-error.js';
 import { normalizeQuery } from '../../core/utils/normalizers/normalize-query.js';
 import 'logry';
 import 'p-limit';
@@ -15,10 +14,10 @@ import { getLocaleFromAcceptLanguage } from '../../routing/locale/get-locale-fro
  *
  * - Acts as the canonical routing authority, guaranteeing a canonical routing result for every request.
  *
- * @platform Next.js
+ * @public
  */
 function createIntorHandler(config) {
-    return async function intorHandler(request) {
+    return function intorHandler(request) {
         const { host, searchParams, pathname: rawPathname } = request.nextUrl;
         // Locale from Accept-Language header
         const acceptLanguageHeader = request.headers.get("accept-language");
@@ -28,11 +27,14 @@ function createIntorHandler(config) {
         // ----------------------------------------------------------
         // Resolve inbound routing decision (pure computation)
         // ----------------------------------------------------------
-        const { locale, localeSource, pathname, shouldRedirect } = await resolveInbound(config, rawPathname, {
+        const cookie = request.cookies.get(config.cookie.name)?.value;
+        const { locale, localeSource, pathname, shouldRedirect } = resolveInbound(config, rawPathname, {
             host,
             query: normalizeQuery(Object.fromEntries(searchParams.entries())),
-            cookie: request.cookies.get(config.cookie.name)?.value,
-            detected: localeFromAcceptLanguage || config.defaultLocale,
+            ...(cookie !== undefined ? { cookie } : {}),
+            ...(localeFromAcceptLanguage !== undefined
+                ? { detected: localeFromAcceptLanguage }
+                : {}),
         }, { hasRedirected });
         // ----------------------------------------------------------
         // Prepare Next.js response (redirect or pass-through)

package/dist/next/src/adapters/next/link.js

@@ -1,15 +1,13 @@
 "use client";
 import { jsx } from 'react/jsx-runtime';
-import { formatUrl } from 'next/dist/shared/lib/router/utils/format-url';
 import NextLink from 'next/link';
 import { usePathname } from 'next/navigation';
 import 'react';
-import { executeNavigation } from '../../client/shared/navigation/execute-navigation.js';
-import { useIntorContext } from 'intor/react';
-import '../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
+import { executeNavigation } from '../../client/shared/navigation/execute-navigation.js';
+import { useIntorContext } from 'intor/react/internal';
 import { resolveOutbound } from '../../routing/outbound/resolve-outbound.js';
 
 /**
@@ -18,15 +16,16 @@ import { resolveOutbound } from '../../routing/outbound/resolve-outbound.js';
  * - Resolves a locale-aware navigation destination.
  * - Determines whether navigation should be executed client-side or via full reload.
  *
- * @platform Next.js
+ * @public
  */
 const Link = ({ href, locale, children, onClick, ...props }) => {
     const { config, locale: currentLocale, setLocale } = useIntorContext();
     const currentPathname = usePathname();
-    // Normalize href into a string destination
-    const rawDestination = typeof href === "string" ? href : href ? formatUrl(href) : undefined;
     // Resolve navigation result for this link
-    const outboundResult = resolveOutbound(config, currentLocale, currentPathname, { destination: rawDestination, locale });
+    const outboundResult = resolveOutbound(config, currentLocale, currentPathname, {
+        ...(href !== undefined ? { destination: href } : {}),
+        ...(locale !== undefined ? { locale } : {}),
+    });
     // --------------------------------------------------
     // Execute navigation on user interaction
     // --------------------------------------------------

package/dist/next/src/adapters/next/redirect.js

@@ -1,5 +1,4 @@
 import { redirect as redirect$1 } from 'next/navigation';
-import '../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
@@ -12,17 +11,16 @@ import { getLocale } from './server/get-locale.js';
  * - Bypasses localization for external destinations.
  * - Automatically resolves the effective locale from the execution context.
  *
- * @platform Next.js
+ * @public
  */
-const redirect = async (config, url, { locale, type }) => {
+const redirect = async (config, url, options) => {
+    const { locale, type } = options ?? {};
     const currentLocale = await getLocale(config);
-    const { destination, kind } = resolveOutbound(config, currentLocale, url, {
-        locale,
+    const { destination } = resolveOutbound(config, currentLocale, "", // server redirect does not depend on current pathname
+    {
+        destination: url,
+        ...(locale !== undefined ? { locale } : {}),
     });
-    if (kind === "external") {
-        redirect$1(url);
-        return;
-    }
     return redirect$1(destination, type);
 };
 

package/dist/next/src/adapters/next/server/get-locale.js

@@ -1,6 +1,5 @@
 import { headers, cookies } from 'next/headers';
 import { INTOR_HEADERS } from '../../../core/constants/headers.js';
-import '../../../core/error/intor-error.js';
 import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
@@ -9,8 +8,9 @@ import 'intor-translator';
 /**
  * Get the locale for the current execution context.
  *
- * @note Uses inbound routing context when available, otherwise falls back to persisted state.
- * @platform Next.js
+ * Uses inbound routing context when available, otherwise falls back to persisted state.
+ *
+ * @public
  */
 const getLocale = async (config) => {
     const headersStore = await headers();

package/dist/next/src/adapters/next/server/get-translator.js

@@ -1,10 +1,4 @@
-import '../../../core/error/intor-error.js';
-import 'logry';
-import 'p-limit';
-import 'intor-translator';
-import 'node:path';
-import 'node:fs/promises';
-import { getTranslator as getTranslator$1 } from '../../../server/helpers/get-translator.js';
+import { getTranslator as getTranslator$1 } from 'intor/server';
 import { getLocale } from './get-locale.js';
 
 /**
@@ -12,19 +6,11 @@ import { getLocale } from './get-locale.js';
  *
  * - Automatically resolves the locale from the framework context.
  *
- * @platform Next.js
+ * @public
  */
 async function getTranslator(config, params) {
-    const { loader, readers, allowCacheWrite, handlers, plugins, preKey } = params || {};
-    return getTranslator$1(config, {
-        locale: await getLocale(config),
-        loader,
-        readers,
-        allowCacheWrite,
-        handlers,
-        plugins,
-        preKey,
-    });
+    const locale = await getLocale(config);
+    return getTranslator$1(config, { locale, ...(params ?? {}) });
 }
 
 export { getTranslator };

package/dist/next/src/adapters/next/server/intor.js

@@ -1,10 +1,4 @@
-import '../../../core/error/intor-error.js';
-import 'logry';
-import 'p-limit';
-import 'intor-translator';
-import { intor as intor$1 } from '../../../server/intor/intor.js';
-import 'node:path';
-import 'node:fs/promises';
+import { intor as intor$1 } from 'intor/server';
 import { getLocale } from './get-locale.js';
 
 /**
@@ -12,12 +6,14 @@ import { getLocale } from './get-locale.js';
  *
  * - Automatically resolves the locale from the framework context.
  * - Permits cache writes during server execution.
- * @platform Next.js
+ *
+ * @public
  */
 async function intor(config, options) {
+    const { readers, allowCacheWrite = true } = options ?? {};
     return await intor$1(config, await getLocale(config), {
-        readers: options?.readers,
-        allowCacheWrite: options?.allowCacheWrite ?? true,
+        ...(readers !== undefined ? { readers } : {}),
+        allowCacheWrite,
     });
 }
 

package/dist/next/src/adapters/next/use-router.js

@@ -1,55 +1,81 @@
 import { usePathname, useRouter as useRouter$1 } from 'next/navigation';
-import { executeNavigation } from '../../client/shared/navigation/execute-navigation.js';
-import { useIntorContext } from 'intor/react';
-import '../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
+import { executeNavigation } from '../../client/shared/navigation/execute-navigation.js';
+import { useIntorContext } from 'intor/react/internal';
 import { resolveOutbound } from '../../routing/outbound/resolve-outbound.js';
 
 /**
  * Locale-aware router hook for the current execution context.
  *
  * - Resolves a locale-aware navigation destination.
- * - Determines whether navigation should be executed client-side or via full reload.
+ * - Commits locale changes only on actual navigation.
+ * - Keeps routing logic pure and side-effects explicit.
  *
- * @platform Next.js
+ * @public
  */
-const useRouter = () => {
+function useRouter() {
     const { config, locale: currentLocale, setLocale } = useIntorContext();
     const currentPathname = usePathname();
-    const { push: nextRouterPush, replace: nextRouterReplace, prefetch: nextRouterPrefetch, ...rest } = useRouter$1();
+    const nextRouter = useRouter$1();
+    function resolve(href, locale) {
+        return resolveOutbound(config, currentLocale, currentPathname, {
+            destination: href,
+            ...(locale !== undefined ? { locale } : {}),
+        });
+    }
+    function execute(outboundResult) {
+        executeNavigation(outboundResult, { config, currentLocale, setLocale });
+    }
     // --------------------------------------------------
     // push
     // --------------------------------------------------
-    const push = (href, options) => {
-        const outboundResult = resolveOutbound(config, currentLocale, currentPathname, { destination: href, locale: options?.locale });
-        executeNavigation(outboundResult, { config, currentLocale, setLocale });
-        nextRouterPush(outboundResult.destination, options);
-    };
+    function push(href, options) {
+        const outboundResult = resolve(href, options?.locale);
+        execute(outboundResult);
+        if (!options) {
+            nextRouter.push(outboundResult.destination);
+            return;
+        }
+        const { locale: _, ...rest } = options;
+        nextRouter.push(outboundResult.destination, rest);
+    }
     // --------------------------------------------------
     // replace
     // --------------------------------------------------
-    const replace = (href, options) => {
-        const outboundResult = resolveOutbound(config, currentLocale, currentPathname, { destination: href, locale: options?.locale });
-        executeNavigation(outboundResult, { config, currentLocale, setLocale });
-        nextRouterReplace(outboundResult.destination, options);
-    };
+    function replace(href, options) {
+        const outboundResult = resolve(href, options?.locale);
+        execute(outboundResult);
+        if (!options) {
+            nextRouter.replace(outboundResult.destination);
+            return;
+        }
+        const { locale: _, ...rest } = options;
+        nextRouter.replace(outboundResult.destination, rest);
+    }
     // --------------------------------------------------
-    // prefetch
+    // prefetch (NO side effects)
     // --------------------------------------------------
-    const prefetch = (href, options) => {
-        const { kind, destination } = resolveOutbound(config, currentLocale, currentPathname, { destination: href, locale: options?.locale });
-        if (kind !== "client")
-            return; // Prefetch only makes sense for client-side navigation
-        nextRouterPrefetch(destination, options);
-    };
+    function prefetch(href, options) {
+        const outboundResult = resolve(href, options?.locale);
+        if (outboundResult.kind !== "client")
+            return;
+        if (!options) {
+            nextRouter.prefetch(outboundResult.destination);
+            return;
+        }
+        const { locale: _, ...rest } = options;
+        nextRouter.prefetch(outboundResult.destination, rest);
+    }
     return {
         push,
         replace,
         prefetch,
-        ...rest,
+        back: () => nextRouter.back(),
+        forward: () => nextRouter.forward(),
+        refresh: () => nextRouter.refresh(),
     };
-};
+}
 
 export { useRouter };

package/dist/next/src/client/shared/navigation/execute-navigation.js

@@ -1,4 +1,3 @@
-import '../../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';

package/dist/next/src/client/shared/utils/build-cookie-string.js

@@ -6,7 +6,7 @@ const buildCookieString = (cookieOptions, value) => {
     // Cookie name and encoded value
     const parts = [`${name}=${encodeURIComponent(value)}`];
     // Add expiration and max-age if provided
-    if (maxAge) {
+    if (maxAge !== undefined) {
         const expires = new Date(Date.now() + maxAge * 1000).toUTCString();
         parts.push(`expires=${expires}`, `max-age=${maxAge}`);
     }
@@ -18,7 +18,8 @@ const buildCookieString = (cookieOptions, value) => {
     }
     // Add SameSite policy (e.g., Lax, Strict)
     if (sameSite) {
-        parts.push(`SameSite=${sameSite[0].toUpperCase()}${sameSite.slice(1).toLowerCase()}`);
+        const normalized = sameSite.charAt(0).toUpperCase() + sameSite.slice(1).toLowerCase();
+        parts.push(`SameSite=${normalized}`);
     }
     // Add Secure flag if not explicitly disabled
     if (secure !== false) {

package/dist/next/src/core/locale/match-locale.js

@@ -9,12 +9,16 @@ import { parseLocale } from './parse-locale.js';
  * 2. Same language + same script
  * 3. Same language only (only if candidate has no script)
  *
+ * Returns one of the original `supportedLocales` values if matched.
  * Returns `undefined` if no match is found.
  *
  * Notes:
  * - Matching is deterministic and order-sensitive.
- * - Does not perform automatic fallback to default locale.
- * - Does not cross script boundaries.
+ * - Does not perform automatic fallback to a default locale.
+ *   Consumers are responsible for applying fallback logic.
+ * - If the candidate includes a script subtag, language-only fallback is skipped.
+ *
+ * @public
  */
 function matchLocale(locale, supportedLocales = []) {
     if (!locale || supportedLocales.length === 0)

package/dist/next/src/core/locale/parse-locale.js

@@ -12,8 +12,8 @@ function parseLocale(tag) {
             const locale = new Intl.Locale(tag);
             return {
                 language: locale.language,
-                script: locale.script,
-                region: locale.region,
+                ...(locale.script !== undefined ? { script: locale.script } : {}),
+                ...(locale.region !== undefined ? { region: locale.region } : {}),
             };
         }
     }

package/dist/next/src/core/utils/normalizers/normalize-pathname.js

@@ -1,21 +1,24 @@
 /**
- * Normalize a raw pathname string to ensure consistent formatting.
+ * Normalizes a raw pathname string into a consistent structural form.
  *
- * - Trims leading and trailing whitespace (code points ≤ 32).
- * - Collapses consecutive slashes into a single slash.
- * - Ensures a single leading slash and removes redundant trailing slashes.
- * - Optionally removes the leading slash.
- * - Avoids intermediate array allocations for performance.
+ * Canonical guarantees:
+ * - Leading and trailing whitespace (code points ≤ 32) are trimmed
+ * - Consecutive slashes are collapsed into a single slash
+ * - The result always starts with a single "/"
+ * - Redundant trailing slashes are removed
+ * - The root path is represented as "/"
+ *
+ * This function is deterministic and allocation-minimized.
  */
-const normalizePathname = (rawPathname, options = {}) => {
+const normalizePathname = (rawPathname) => {
     const length = rawPathname.length;
     let start = 0;
     let end = length - 1;
     // Trim leading whitespace
-    while (start <= end && (rawPathname.codePointAt(start) ?? 0) <= 32)
+    while (start <= end && rawPathname.codePointAt(start) <= 32)
         start++;
     // Trim trailing whitespace
-    while (end >= start && (rawPathname.codePointAt(end) ?? 0) <= 32)
+    while (end >= start && rawPathname.codePointAt(end) <= 32)
         end--;
     if (start > end)
         return "/"; // Only whitespace
@@ -33,10 +36,6 @@ const normalizePathname = (rawPathname, options = {}) => {
             hasSlash = false;
         }
     }
-    // If the result has a leading slash and we want to remove it, do so
-    if (options.removeLeadingSlash && result.startsWith("/")) {
-        result = result.slice(1);
-    }
     return result || "/";
 };
 

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

@@ -21,7 +21,7 @@ const resolveLoaderOptions = (config, runtime) => {
     // ------------------------------------------------
     // runtime: client
     // ------------------------------------------------
-    if (runtime === "client") {
+    {
         const client = config.client?.loader;
         if (client) {
             // Client loader is always remote by design
@@ -29,10 +29,6 @@ const resolveLoaderOptions = (config, runtime) => {
         }
         return config.server?.loader ?? config.loader;
     }
-    // ------------------------------------------------
-    // runtime: server
-    // ------------------------------------------------
-    return config.server?.loader ?? config.loader;
 };
 
 export { resolveLoaderOptions };

package/dist/next/src/policies/shoud-full-reload.js

@@ -1,4 +1,3 @@
-import '../core/error/intor-error.js';
 import { resolveLoaderOptions } from '../core/utils/resolve-loader-options.js';
 import 'logry';
 import 'p-limit';
@@ -8,7 +7,7 @@ import 'intor-translator';
  * Determine whether client-side navigation must be forced to reload.
  */
 function shouldFullReload(config) {
-    const loader = resolveLoaderOptions(config, "client");
+    const loader = resolveLoaderOptions(config);
     return (loader?.mode === "local" || config.routing.outbound.forceFullReload === true);
 }
 

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

@@ -2,7 +2,7 @@ import { getLocaleFromPathname } from '../locale/get-locale-from-pathname.js';
 import { getLocaleFromHost } from '../locale/get-locale-from-host.js';
 import { getLocaleFromQuery } from '../locale/get-locale-from-query.js';
 import { resolveLocale } from './resolve-locale/resolve-locale.js';
-import { resolvePath } from './resolve-path/resolve-path.js';
+import { resolvePathname } from './resolve-pathname/resolve-pathname.js';
 
 /**
  * Resolves inbound routing state.
@@ -13,24 +13,26 @@ import { resolvePath } from './resolve-path/resolve-path.js';
  *
  * No side effects. No navigation.
  */
-async function resolveInbound(config, rawPathname, localeInputs, options) {
+function resolveInbound(config, rawPathname, localeInputs, options) {
     const { queryKey } = config.routing.inbound;
     const { host, query, cookie, detected } = localeInputs;
     // ------------------------------------------------------
     // Resolve locale from inbound inputs
     // ------------------------------------------------------
     const pathLocale = getLocaleFromPathname(rawPathname, config);
+    const hostLocale = getLocaleFromHost(host);
+    const queryLocale = getLocaleFromQuery(query, queryKey);
     const { locale, localeSource } = resolveLocale(config, {
-        path: { locale: pathLocale },
-        host: { locale: getLocaleFromHost(host) },
-        query: { locale: getLocaleFromQuery(query, queryKey) },
-        cookie: { locale: cookie },
-        detected: { locale: detected },
+        ...(pathLocale !== undefined && { path: { locale: pathLocale } }),
+        ...(hostLocale !== undefined && { host: { locale: hostLocale } }),
+        ...(queryLocale !== undefined && { query: { locale: queryLocale } }),
+        ...(cookie !== undefined && { cookie: { locale: cookie } }),
+        ...(detected !== undefined && { detected: { locale: detected } }),
     });
     // ------------------------------------------------------
     // Resolve localized pathname and redirect requirement
     // ------------------------------------------------------
-    const { pathname, shouldRedirect } = resolvePath(config, rawPathname, {
+    const { pathname, shouldRedirect } = resolvePathname(config, rawPathname, {
         locale,
         hasPathLocale: !!pathLocale,
         hasPersisted: !!cookie,

package/dist/next/src/routing/inbound/resolve-locale/resolve-locale.js

@@ -1,18 +1,23 @@
-import '../../../core/error/intor-error.js';
 import { matchLocale } from '../../../core/locale/match-locale.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';
 
 /**
- * Resolve the active locale from inbound routing configuration.
+ * Resolves the active locale from inbound routing configuration.
  *
- * Iterates through configured locale sources and returns the first normalized, supported locale.
+ * Resolution order:
+ * 1. Configured locale signals (path / query / host / cookie)
+ * 2. Runtime detection signal ("detected")
+ * 3. Invariant fallback ("default")
  *
- * Falls back to the detected locale or the default locale if none match.
+ * Always returns a supported locale.
  */
 function resolveLocale(config, context) {
     const { localeSources } = config.routing.inbound;
+    // ------------------------------------------------------
+    // 1. Configured resolution signals (policy-ordered)
+    // ------------------------------------------------------
     for (const source of localeSources) {
         const locale = context[source]?.locale;
         const normalized = matchLocale(locale, config.supportedLocales);
@@ -23,12 +28,22 @@ function resolveLocale(config, context) {
             localeSource: source,
         };
     }
-    // Fallback: detected is always available
-    const fallback = matchLocale(context.detected.locale, config.supportedLocales) ||
-        config.defaultLocale;
+    // ------------------------------------------------------
+    // 2. Detection fallback (runtime signal)
+    // ------------------------------------------------------
+    const detected = matchLocale(context.detected?.locale, config.supportedLocales);
+    if (detected) {
+        return {
+            locale: detected,
+            localeSource: "detected",
+        };
+    }
+    // ------------------------------------------------------
+    // 3. Final invariant fallback (guaranteed)
+    // ------------------------------------------------------
     return {
-        locale: fallback,
-        localeSource: "detected",
+        locale: config.defaultLocale,
+        localeSource: "default",
     };
 }
 

package/dist/next/src/routing/inbound/resolve-pathname/resolve-pathname.js

@@ -0,0 +1,42 @@
+import { localizePathname } from '../../pathname/localize-pathname.js';
+import { all } from './strategies/all.js';
+import { exceptDefault } from './strategies/except-default.js';
+import { none } from './strategies/none.js';
+
+const assertNever = (x) => {
+    throw new Error(`Unhandled prefix strategy: ${String(x)}`);
+};
+/**
+ * Resolves the canonical pathname based on locale prefix behavior.
+ *
+ * The resolved pathname represents the final, normalized form
+ * used for routing and navigation.
+ */
+const resolvePathname = (config, rawPathname, context) => {
+    const { localePrefix } = config.routing;
+    let directive;
+    switch (localePrefix) {
+        case "all": {
+            directive = all(config, context);
+            break;
+        }
+        case "except-default": {
+            directive = exceptDefault(config, context);
+            break;
+        }
+        case "none": {
+            directive = none();
+            break;
+        }
+        default: {
+            return assertNever(localePrefix);
+        }
+    }
+    const { pathname } = localizePathname(rawPathname, config, context.locale);
+    return {
+        pathname,
+        shouldRedirect: directive.type === "redirect",
+    };
+};
+
+export { resolvePathname };