intor 2.4.17 → 2.5.0

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

@@ -1,4 +1,3 @@
-import '../../core/error/intor-error.js';
 import { resolveLoaderOptions } from '../../core/utils/resolve-loader-options.js';
 import { getLogger } from '../../core/logger/get-logger.js';
 import { loadRemoteMessages } from '../../core/messages/load-remote-messages/load-remote-messages.js';
@@ -44,27 +43,29 @@ const loadMessages = async ({ config, locale, readers, allowCacheWrite = false,
     // ---------------------------------------------------------------------------
     let loadedMessages;
     if (mode === "local") {
+        const { rootDir } = loader;
         loadedMessages = await loadLocalMessages({
             id: config.id,
             locale,
             fallbackLocales,
-            namespaces,
-            rootDir: loader.rootDir,
-            concurrency,
-            readers,
+            ...(namespaces !== undefined ? { namespaces } : {}),
+            ...(rootDir !== undefined ? { rootDir } : {}),
+            ...(concurrency !== undefined ? { concurrency } : {}),
+            readers: readers ?? {},
             allowCacheWrite,
             loggerOptions: config.logger,
         });
     }
     else if (mode === "remote") {
+        const { url, headers } = loader;
         loadedMessages = await loadRemoteMessages({
             locale,
             fallbackLocales,
-            namespaces,
-            concurrency,
+            ...(namespaces !== undefined ? { namespaces } : {}),
+            ...(concurrency !== undefined ? { concurrency } : {}),
             fetch,
-            url: loader.url,
-            headers: loader.headers,
+            url,
+            ...(headers !== undefined ? { headers } : {}),
             loggerOptions: config.logger,
         });
     }

package/dist/core/src/server/translator/init-translator.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';
@@ -15,25 +14,31 @@ import 'node:fs/promises';
  * - Creates an immutable Translator instance for server usage
  */
 async function initTranslator(config, locale, options) {
-    const { loader, readers, allowCacheWrite = false, fetch, handlers, plugins, } = options;
+    const { loader, readers, allowCacheWrite = false, fetch, handlers, hooks, } = options;
     const loaderOptions = resolveLoaderOptions(config, "server");
     // Load messages
     let messages = {};
-    if (loaderOptions && !loader) {
+    if (loader) {
+        messages = await loader(config, locale);
+    }
+    else if (loaderOptions) {
         const loaded = await loadMessages({
             config,
             locale,
-            readers,
+            ...(readers !== undefined ? { readers } : {}),
             allowCacheWrite,
             fetch,
         });
         messages = loaded || {};
     }
-    if (loader) {
-        messages = await loader(config, locale);
-    }
     // Create immutable translator snapshot
-    return createTranslator({ config, locale, messages, handlers, plugins });
+    return createTranslator({
+        config,
+        locale,
+        messages,
+        ...(handlers !== undefined ? { handlers } : {}),
+        ...(hooks !== undefined ? { hooks } : {}),
+    });
 }
 
 export { initTranslator };

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

@@ -1,4 +1,4 @@
-import '../../core/error/intor-error.js';
+import { getTranslator } from 'intor/server';
 import { parseCookieHeader } from '../../core/utils/parse-cookie-header.js';
 import { normalizeQuery } from '../../core/utils/normalizers/normalize-query.js';
 import 'logry';
@@ -6,17 +6,14 @@ import 'p-limit';
 import 'intor-translator';
 import { resolveInbound } from '../../routing/inbound/resolve-inbound.js';
 import { getLocaleFromAcceptLanguage } from '../../routing/locale/get-locale-from-accept-language.js';
-import 'node:path';
-import 'node:fs/promises';
-import { getTranslator } from '../../server/helpers/get-translator.js';
 
 /**
  * Resolves locale-aware routing for the current execution context.
  *
  * - Binds resolved routing state to the request.
- * - Convenience routing shortcuts are also bound to the request for downstream consumption.
+ * - Optionally binds convenience routing shortcuts for downstream consumption.
  *
- * @platform Express
+ * @public
  */
 function createIntorHandler(config, options) {
     return async function intorHandler(req, _res, next) {
@@ -26,22 +23,27 @@ function createIntorHandler(config, options) {
         // ----------------------------------------------------------
         // Resolve inbound routing decision (pure computation)
         // ----------------------------------------------------------
-        const { locale, localeSource, pathname } = await resolveInbound(config, req.path, {
+        const cookie = parseCookieHeader(req.headers.cookie)[config.cookie.name];
+        const { locale, localeSource, pathname } = resolveInbound(config, req.path, {
             host: req.hostname,
             query: normalizeQuery(req.query),
-            cookie: parseCookieHeader(req.headers.cookie)[config.cookie.name],
-            detected: localeFromAcceptLanguage || config.defaultLocale,
+            ...(cookie !== undefined ? { cookie } : {}),
+            ...(localeFromAcceptLanguage !== undefined
+                ? { detected: localeFromAcceptLanguage }
+                : {}),
         });
         // --------------------------------------------------
         // Bind inbound routing context
         // --------------------------------------------------
         req.intor = { locale, localeSource, pathname };
+        const { loader, readers, handlers, hooks } = options ?? {};
         const { hasKey, t, tRich } = await getTranslator(config, {
             locale,
-            handlers: options?.handlers,
-            plugins: options?.plugins,
-            readers: options?.readers,
+            ...(loader !== undefined ? { loader } : {}),
+            ...(readers !== undefined ? { readers } : {}),
             allowCacheWrite: true,
+            ...(handlers !== undefined ? { handlers } : {}),
+            ...(hooks !== undefined ? { hooks } : {}),
         });
         // DX shortcuts (enabled by default)
         if (options?.shortcuts !== false) {

package/dist/express/src/adapters/express/get-translator.js

@@ -1,29 +1,15 @@
-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';
 
 /**
  * Get a server-side translator for the current execution context.
  *
  * - Automatically resolves the locale from the framework context.
  *
- * @platform Express
+ * @public
  */
 async function getTranslator(config, req, params) {
-    const { loader, readers, allowCacheWrite, handlers, plugins, preKey } = params || {};
-    return getTranslator$1(config, {
-        locale: req.intor?.locale || config.defaultLocale,
-        loader,
-        readers,
-        allowCacheWrite,
-        handlers,
-        plugins,
-        preKey,
-    });
+    const locale = req.intor?.locale ?? config.defaultLocale;
+    return getTranslator$1(config, { locale, ...(params ?? {}) });
 }
 
 export { getTranslator };

package/dist/express/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/express/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/express/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/express/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/express/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/express/src/routing/inbound/{resolve-path/resolve-path.js → resolve-pathname/resolve-pathname.js}

@@ -4,7 +4,7 @@ import { exceptDefault } from './strategies/except-default.js';
 import { none } from './strategies/none.js';
 
 const assertNever = (x) => {
-    throw new Error(`Unhandled prefix strategy: ${x}`);
+    throw new Error(`Unhandled prefix strategy: ${String(x)}`);
 };
 /**
  * Resolves the canonical pathname based on locale prefix behavior.
@@ -12,7 +12,7 @@ const assertNever = (x) => {
  * The resolved pathname represents the final, normalized form
  * used for routing and navigation.
  */
-const resolvePath = (config, rawPathname, context) => {
+const resolvePathname = (config, rawPathname, context) => {
     const { localePrefix } = config.routing;
     let directive;
     switch (localePrefix) {
@@ -39,4 +39,4 @@ const resolvePath = (config, rawPathname, context) => {
     };
 };
 
-export { resolvePath };
+export { resolvePathname };

package/dist/express/src/routing/locale/get-locale-from-accept-language.js

@@ -20,16 +20,18 @@ const getLocaleFromAcceptLanguage = (acceptLanguageHeader, supportedLocales) =>
     const supportedLocalesSet = new Set(supportedLocales);
     // 1. Parse Accept-Language header into language + priority pairs
     const parsedLanguages = acceptLanguageHeader.split(",").map((part) => {
-        const [rawLang, rawQ] = part.split(";");
+        const segments = part.split(";");
+        const rawLang = segments[0];
+        const rawQ = segments[1];
         const lang = rawLang.trim();
-        const q = rawQ ? Number.parseFloat(rawQ.split("=")[1]) : 1;
+        const q = rawQ !== undefined ? Number.parseFloat(rawQ.split("=")[1] ?? "") : 1;
         return {
             lang,
             q: Number.isNaN(q) ? 0 : q, // Invalid q values have lowest priority
         };
     });
     // 2. Sort by priority (highest first)
-    const sortedByPriority = parsedLanguages.toSorted((a, b) => b.q - a.q);
+    const sortedByPriority = parsedLanguages.sort((a, b) => b.q - a.q);
     // 3. Pick the first language explicitly supported
     const preferred = sortedByPriority.find(({ lang }) => supportedLocalesSet.has(lang))?.lang;
     return preferred;

package/dist/express/src/routing/locale/get-locale-from-pathname.js

@@ -1,4 +1,3 @@
-import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
 import 'p-limit';

package/dist/express/src/routing/pathname/canonicalize-pathname.js

@@ -1,47 +1,78 @@
 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';
 
 /**
- * Returns a canonical, locale-agnostic pathname.
+ * Returns the internal canonical pathname.
+ *
+ * Canonical representation is the locale-neutral and deployment-neutral
+ * internal routing form used for identity and routing computation.
+ *
+ * Guarantees:
+ * - Pathname is normalized
+ * - Deployment prefix (`basePath`) is removed
+ * - Leading locale segment or `{locale}` placeholder is removed
+ * - Only the first path segment is evaluated for locale stripping
+ * - Result always starts with "/"
+ * - Root is represented as "/"
  *
  * Accepts `{locale}` as a locale placeholder segment.
  *
  * @example
  * ```ts
- * // config.supportedLocales: ["en-US"]
+ * // config.supportedLocales: ["en"]
  * // config.routing.basePath: "/app"
  * // config.routing.prefix: "all"
- * canonicalizePathname("/app/en-US/about", config);
+ * canonicalizePathname("/app/en/about", config);
  * // => "/about"
  *```
  */
 function canonicalizePathname(rawPathname, config) {
     const { routing, supportedLocales } = config;
-    const { basePath } = routing;
     const normalizedPathname = normalizePathname(rawPathname);
-    // Strip basePath
-    let prefixedPathname = normalizedPathname;
-    if (basePath && normalizedPathname === basePath) {
-        prefixedPathname = "/";
+    // ---------------------------------------------------------------------------
+    // Strip basePath (deployment prefix)
+    // ---------------------------------------------------------------------------
+    const basePath = routing.basePath === "/" ? "" : routing.basePath;
+    let path = normalizedPathname;
+    if (basePath) {
+        if (path === basePath) {
+            path = "/";
+        }
+        else if (path.startsWith(basePath + "/")) {
+            path = path.slice(basePath.length);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Detect first segment (allocation-minimized)
+    // ---------------------------------------------------------------------------
+    if (path === "/")
+        return "/";
+    const segmentStart = 1; // skip leading "/"
+    const nextSlash = path.indexOf("/", segmentStart);
+    const firstSegment = nextSlash === -1
+        ? path.slice(segmentStart)
+        : path.slice(segmentStart, nextSlash);
+    // ---------------------------------------------------------------------------
+    // Determine if first segment is locale representation
+    // ---------------------------------------------------------------------------
+    let localeLength;
+    if (firstSegment === LOCALE_PLACEHOLDER) {
+        localeLength = firstSegment.length;
+    }
+    else if (supportedLocales.includes(firstSegment)) {
+        localeLength = firstSegment.length;
     }
-    else if (basePath && normalizedPathname.startsWith(basePath + "/")) {
-        prefixedPathname = normalizedPathname.slice(basePath.length);
+    // ---------------------------------------------------------------------------
+    // Strip locale segment (if any)
+    // ---------------------------------------------------------------------------
+    if (localeLength !== undefined) {
+        const stripped = path.slice(localeLength + 1);
+        return stripped || "/";
     }
-    // Detect locale segment
-    const firstSegment = prefixedPathname.split("/").find(Boolean);
-    const locale = firstSegment === LOCALE_PLACEHOLDER
-        ? LOCALE_PLACEHOLDER
-        : firstSegment && supportedLocales.includes(firstSegment)
-            ? firstSegment
-            : undefined;
-    // Strip locale segment
-    return locale
-        ? prefixedPathname.slice(locale.length + 1) || "/"
-        : prefixedPathname;
+    return path;
 }
 
 export { canonicalizePathname };

package/dist/express/src/routing/pathname/localize-pathname.js

@@ -14,22 +14,24 @@ import { standardizePathname } from './standardize-pathname.js';
  * localizePathname("/app/en-US/about", config, "en-US");
  * // => {
  * //   pathname: '/app/en-US/about'
- * //   unprefixedPathname: '/about',
+ * //   canonicalPathname: '/about',
  * //   templatedPathname: '/app/{locale}/about',
  * // }
  * ```
+ *
+ * @public
  */
 const localizePathname = (rawPathname, config, locale) => {
     // 1. Canonicalize: normalize and remove routing-specific prefixes
-    const canonicalized = canonicalizePathname(rawPathname, config);
+    const canonicalPathname = canonicalizePathname(rawPathname, config);
     // 2. Standardize: convert to internal pathname shape with locale placeholder
-    const standardized = standardizePathname(canonicalized, config);
+    const standardizedPathname = standardizePathname(canonicalPathname, config);
     // 3. Materialize: apply routing rules to produce the final pathname
-    const materialized = materializePathname(standardized, config, locale);
+    const materializedPathname = materializePathname(standardizedPathname, config, locale);
     return {
-        pathname: materialized,
-        unprefixedPathname: canonicalized,
-        templatedPathname: standardized,
+        canonicalPathname,
+        templatedPathname: standardizedPathname,
+        pathname: materializedPathname,
     };
 };
 

package/dist/express/src/routing/pathname/materialize-pathname.js

@@ -1,42 +1,53 @@
 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';
 
 /**
- * Materializes a standardized pathname by applying
- * the configured locale prefix behavior.
+ * Materializes a standardized pathname into a concrete, locale-aware URL.
+ *
+ * This function resolves the `{locale}` placeholder according to the
+ * configured `localePrefix` strategy and produces the final pathname.
+ *
+ * Behavior:
+ * - "all": always injects the locale segment
+ * - "except-default": injects the locale unless it equals `defaultLocale`
+ * - "none": removes the locale placeholder entirely
+ *
+ * Invariants:
+ * - `standardizedPathname` must be produced by `standardizePathname`
+ * - The pathname must contain exactly one `{locale}` placeholder
+ * - The placeholder must appear as the first path segment
+ *
+ * This function performs structural transformation only.
+ * It does not normalize or sanitize the resulting pathname.
  *
  * @example
  * ```ts
  * // config.routing.localePrefix: "all"
- * materializePathname("/app/{locale}/about", config, "en-US");
- * // => /app/en-US/about
+ * materializePathname("/app/{locale}/about", config, "en");
+ * // => /app/en/about
  *
  * // config.routing.localePrefix: "none"
- * materializePathname("/app/{locale}/about", config, "en-US");
+ * materializePathname("/app/{locale}/about", config, "en");
  * // => /app/about
  * ```
  */
 const materializePathname = (standardizedPathname, config, locale) => {
     const { localePrefix } = config.routing;
-    if (localePrefix !== "none" && !locale) {
-        throw new Error('No locale when using localePrefix "all", "except-default"');
-    }
+    const removeLocale = () => {
+        const result = standardizedPathname.replace(`/${LOCALE_PLACEHOLDER}`, "");
+        return result === "" ? "/" : result;
+    };
+    const injectLocale = () => standardizedPathname.replace(LOCALE_PLACEHOLDER, locale);
+    // localePrefix: "none"
+    if (localePrefix === "none")
+        return removeLocale();
     // localePrefix: "all"
-    if (localePrefix === "all") {
-        return normalizePathname(standardizedPathname.replaceAll(LOCALE_PLACEHOLDER, locale));
-    }
+    if (localePrefix === "all")
+        return injectLocale();
     // localePrefix: "except-default"
-    if (localePrefix === "except-default") {
-        return locale === config.defaultLocale
-            ? normalizePathname(standardizedPathname.replaceAll(`/${LOCALE_PLACEHOLDER}`, ""))
-            : normalizePathname(standardizedPathname.replaceAll(LOCALE_PLACEHOLDER, locale));
-    }
-    // localePrefix: "none"
-    return normalizePathname(standardizedPathname.replaceAll(`/${LOCALE_PLACEHOLDER}`, ""));
+    return locale === config.defaultLocale ? removeLocale() : injectLocale();
 };
 
 export { materializePathname };