@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.120 → 3.2.0-ultramodern.121

package/dist/esm/server/index.mjs

@@ -1,5 +1,5 @@
 import { DEFAULT_I18NEXT_DETECTION_OPTIONS, mergeDetectionOptions } from "../runtime/i18n/detection/config.mjs";
-import { resolveLocalisedPath, resolveLocalisedUrlsConfig } from "../shared/localisedUrls.mjs";
+import { localiseTargetPathname, resolveLocalisedUrlsConfig } from "../shared/localisedUrls.mjs";
 import { getLocaleDetectionOptions } from "../shared/utils.mjs";
 import * as __rspack_external__modern_js_server_core_hono_a76ca254 from "@modern-js/server-core/hono";
 const { languageDetector: languageDetector } = __rspack_external__modern_js_server_core_hono_a76ca254;
@@ -127,15 +127,7 @@ const buildLocalizedUrl = (req, urlPath, language, languages, localisedUrls)=>{
     const pathname = url.pathname;
     const basePath = urlPath.replace('/*', '');
     const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
-    const segments = remainingPath.split('/').filter(Boolean);
-    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
-    const pathWithoutLanguage = segments.length > 0 && languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : remainingPath;
-    const resolvedPath = localisedUrlsConfig.enabled ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
-    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
-    const newPathname = `/${[
-        language,
-        ...resolvedSegments
-    ].join('/')}`;
+    const newPathname = localiseTargetPathname(remainingPath, language, languages, localisedUrls);
     const suffix = `${url.search}${url.hash}`;
     const localizedUrl = '/' === basePath ? newPathname + suffix : basePath + newPathname + suffix;
     return localizedUrl;

package/dist/esm/shared/localisedUrls.mjs

@@ -3,12 +3,13 @@ const LOCALE_PARAM_NAMES = new Set([
     'locale',
     'language'
 ]);
-const normalisePathPattern = (path)=>{
+const normaliseSlashes = (path)=>{
     const withoutDuplicateSlashes = path.replace(/\/+/g, '/');
     const withLeadingSlash = withoutDuplicateSlashes.startsWith('/') ? withoutDuplicateSlashes : `/${withoutDuplicateSlashes}`;
-    const withoutTrailingSlash = withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/, '') : withLeadingSlash;
-    return withoutTrailingSlash.replace(/\[(.+?)\]/g, ':$1');
+    return withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/, '') : withLeadingSlash;
 };
+const normalisePathPattern = (path)=>normaliseSlashes(path).replace(/\[(.+?)\]/g, ':$1');
+const normalisePathname = (pathname)=>normaliseSlashes(pathname);
 const normaliseRoutePath = (path)=>{
     const normalized = normalisePathPattern(path);
     return '/' === normalized ? '' : normalized.slice(1);
@@ -34,16 +35,12 @@ const getLeadingLocaleParam = (path)=>{
     return getLocaleParamSegment(segments[0] || '');
 };
 const resolveLocalisedUrlsConfig = (option)=>{
-    if (false === option) return {
-        enabled: false,
-        map: {}
-    };
-    if (option && 'object' == typeof option) return {
+    if (option && 'object' == typeof option && Object.keys(option).length > 0) return {
         enabled: true,
         map: option
     };
     return {
-        enabled: true,
+        enabled: false,
         map: {}
     };
 };
@@ -135,9 +132,13 @@ const applyLocalisedUrlsToRoutes = (routes, languages, localisedUrls)=>{
 };
 const escapeRegExp = (value)=>value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 const getParamName = (segment)=>segment.slice(1).replace(/\?$/, '');
+const compiledPathPatternCache = new Map();
 const compilePathPattern = (pattern)=>{
+    const normalizedPattern = normalisePathPattern(pattern);
+    const cached = compiledPathPatternCache.get(normalizedPattern);
+    if (cached) return cached;
     const names = [];
-    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const segments = normalizedPattern.split('/').filter(Boolean);
     const source = segments.map((segment)=>{
         if (segment.startsWith(':')) {
             names.push(getParamName(segment));
@@ -150,19 +151,55 @@ const compilePathPattern = (pattern)=>{
         }
         return `/${escapeRegExp(segment)}`;
     }).join('');
-    return {
+    const compiled = {
         names,
         regexp: new RegExp(`^${source || '/'}$`)
     };
+    compiledPathPatternCache.set(normalizedPattern, compiled);
+    return compiled;
+};
+const getPatternSpecificity = (pattern)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    let staticSegments = 0;
+    let dynamicSegments = 0;
+    let splatSegments = 0;
+    for (const segment of segments)if ('*' === segment) splatSegments++;
+    else if (segment.startsWith(':')) dynamicSegments++;
+    else staticSegments++;
+    return {
+        staticSegments,
+        dynamicSegments,
+        splatSegments,
+        totalSegments: segments.length
+    };
+};
+const comparePatternSpecificity = (left, right)=>{
+    const a = getPatternSpecificity(left);
+    const b = getPatternSpecificity(right);
+    return b.staticSegments - a.staticSegments || b.totalSegments - a.totalSegments || a.splatSegments - b.splatSegments || a.dynamicSegments - b.dynamicSegments;
+};
+const sortPatternsBySpecificity = (patterns)=>patterns.map((pattern, index)=>({
+            pattern,
+            index
+        })).sort((left, right)=>comparePatternSpecificity(left.pattern.pattern, right.pattern.pattern) || left.index - right.index).map(({ pattern })=>pattern);
+const decodePathParam = (value)=>{
+    try {
+        return decodeURIComponent(value);
+    } catch  {
+        return null;
+    }
 };
 const matchPathPattern = (pathname, pattern)=>{
     const { names, regexp } = compilePathPattern(pattern);
-    const match = regexp.exec(normalisePathPattern(pathname));
+    const match = regexp.exec(normalisePathname(pathname));
     if (!match) return null;
-    return names.reduce((params, name, index)=>{
-        params[name] = decodeURIComponent(match[index + 1] || '');
-        return params;
-    }, {});
+    const params = {};
+    for(let index = 0; index < names.length; index++){
+        const decoded = decodePathParam(match[index + 1] || '');
+        if (null === decoded) return null;
+        params[names[index]] = decoded;
+    }
+    return params;
 };
 const buildPathFromPattern = (pattern, params)=>{
     const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
@@ -177,27 +214,41 @@ const buildPathFromPattern = (pattern, params)=>{
     return `/${path}`;
 };
 const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>{
-    const normalizedPathname = normalisePathPattern(pathname);
-    for (const [canonicalPattern, localisedUrlEntry] of Object.entries(localisedUrls)){
+    const normalizedPathname = normalisePathname(pathname);
+    const canonicalCandidates = sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
+            pattern: canonicalPattern,
+            canonicalPattern,
+            localisedUrlEntry
+        })));
+    for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
         const targetPattern = localisedUrlEntry[targetLanguage];
         if (!targetPattern) continue;
         const params = matchPathPattern(normalizedPathname, canonicalPattern);
         if (params) return buildPathFromPattern(targetPattern, params);
     }
-    for (const localisedUrlEntry of Object.values(localisedUrls)){
+    const localisedCandidates = sortPatternsBySpecificity(Object.values(localisedUrls).flatMap((localisedUrlEntry)=>{
         const targetPattern = localisedUrlEntry[targetLanguage];
-        if (targetPattern) for (const language of languages){
-            const sourcePattern = localisedUrlEntry[language];
-            if (!sourcePattern) continue;
-            const params = matchPathPattern(normalizedPathname, sourcePattern);
-            if (params) return buildPathFromPattern(targetPattern, params);
-        }
+        if (!targetPattern) return [];
+        return languages.map((language)=>localisedUrlEntry[language]).filter((sourcePattern)=>Boolean(sourcePattern)).map((sourcePattern)=>({
+                pattern: sourcePattern,
+                sourcePattern,
+                targetPattern
+            }));
+    }));
+    for (const { sourcePattern, targetPattern } of localisedCandidates){
+        const params = matchPathPattern(normalizedPathname, sourcePattern);
+        if (params) return buildPathFromPattern(targetPattern, params);
     }
     return normalizedPathname;
 };
 const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>{
-    const normalizedPathname = normalisePathPattern(pathname);
-    for (const [canonicalPattern, localisedUrlEntry] of Object.entries(localisedUrls)){
+    const normalizedPathname = normalisePathname(pathname);
+    const canonicalCandidates = sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
+            pattern: canonicalPattern,
+            canonicalPattern,
+            localisedUrlEntry
+        })));
+    for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
         const canonicalParams = matchPathPattern(normalizedPathname, canonicalPattern);
         if (canonicalParams) return buildPathFromPattern(canonicalPattern, canonicalParams);
         for (const language of languages){
@@ -209,4 +260,24 @@ const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>{
     }
     return normalizedPathname;
 };
-export { applyLocalisedUrlsToRoutes, buildPathFromPattern, matchPathPattern, normalisePathPattern, resolveCanonicalLocalisedPath, resolveLocalisedPath, resolveLocalisedUrlsConfig, validateLocalisedUrls };
+const stripLanguagePrefix = (pathname, languages)=>{
+    const segments = pathname.split('/').filter(Boolean);
+    if (segments.length > 0 && languages.includes(segments[0])) return `/${segments.slice(1).join('/')}`;
+    return pathname || '/';
+};
+const localiseTargetPathname = (pathname, language, languages, localisedUrls)=>{
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+    const resolvedPath = localisedUrlsConfig.enabled ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
+    return `/${[
+        language,
+        ...resolvedSegments
+    ].join('/')}`;
+};
+const canonicalTargetPathname = (pathname, languages, localisedUrls)=>{
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+    return localisedUrlsConfig.enabled ? resolveCanonicalLocalisedPath(pathWithoutLanguage, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+};
+export { applyLocalisedUrlsToRoutes, buildPathFromPattern, canonicalTargetPathname, localiseTargetPathname, matchPathPattern, normalisePathPattern, normalisePathname, resolveCanonicalLocalisedPath, resolveLocalisedPath, resolveLocalisedUrlsConfig, validateLocalisedUrls };

package/dist/esm-node/runtime/Link.mjs

@@ -89,7 +89,7 @@ const mergeClassNames = (...values)=>{
     return classNames.length > 0 ? classNames.join(' ') : void 0;
 };
 const Link = (props)=>{
-    const { to, params, children, hash: hashProp, search: searchProp, hashScrollIntoView, activeOptions, activeProps, ...rest } = props;
+    const { to, params, children, hash: hashProp, search: searchProp, hashScrollIntoView, activeOptions, activeProps, prefetch, preload, ...rest } = props;
     const adapter = useI18nRouterAdapter();
     const { language, supportedLanguages, localisedUrls } = useModernI18n();
     const config = {
@@ -147,7 +147,7 @@ const Link = (props)=>{
         'aria-current': rest['aria-current'] ?? resolvedActiveProps['aria-current'] ?? 'page'
     } : {};
     if (!target) {
-        const { prefetch: _prefetch, preload: _preload, replace: _replace, ...anchorProps } = rest;
+        const { replace: _replace, ...anchorProps } = rest;
         return /*#__PURE__*/ jsx("a", {
             href: to,
             ...anchorProps,
@@ -156,7 +156,7 @@ const Link = (props)=>{
     }
     const { Link: RouterLink, hasRouter, framework } = adapter;
     if (!hasRouter || !RouterLink) {
-        const { prefetch: _prefetch, preload: _preload, replace: _replace, ...anchorProps } = rest;
+        const { replace: _replace, ...anchorProps } = rest;
         const { className: activeClassName, style: activeStyle, ...activeRest } = resolvedActiveProps;
         return /*#__PURE__*/ jsx("a", {
             href: target.href,
@@ -177,26 +177,38 @@ const Link = (props)=>{
         ...rest.style,
         ...activeStyle
     };
-    if ('tanstack' === framework) return /*#__PURE__*/ jsx(RouterLink, {
-        to: target.localizedPathname,
-        ...target.searchObject ? {
-            search: target.searchObject
-        } : {},
-        ...target.hash ? {
-            hash: target.hash
-        } : {},
-        ...void 0 === hashScrollIntoView ? {} : {
-            hashScrollIntoView
-        },
-        ...rest,
-        ...activeRest,
-        ...activeAttributes,
-        className: mergedClassName,
-        style: mergedStyle,
-        children: children
-    });
+    if ('tanstack' === framework) {
+        const tanstackPreload = void 0 !== preload ? preload : void 0 === prefetch ? void 0 : 'none' === prefetch ? false : prefetch;
+        return /*#__PURE__*/ jsx(RouterLink, {
+            to: target.localizedPathname,
+            ...target.searchObject ? {
+                search: target.searchObject
+            } : {},
+            ...target.hash ? {
+                hash: target.hash
+            } : {},
+            ...void 0 === hashScrollIntoView ? {} : {
+                hashScrollIntoView
+            },
+            ...void 0 === tanstackPreload ? {} : {
+                preload: tanstackPreload
+            },
+            ...rest,
+            ...activeRest,
+            ...activeAttributes,
+            className: mergedClassName,
+            style: mergedStyle,
+            children: children
+        });
+    }
     return /*#__PURE__*/ jsx(RouterLink, {
         to: target.href,
+        ...void 0 === prefetch ? {} : {
+            prefetch
+        },
+        ...void 0 === preload ? {} : {
+            preload
+        },
         ...rest,
         ...activeRest,
         ...activeAttributes,

package/dist/esm-node/runtime/i18n/backend/defaults.node.mjs

@@ -1,7 +1,28 @@
 import "node:module";
+import fs from "fs";
+import path_0 from "path";
+const CONVENTIONAL_LOCALES_DIRS = [
+    './locales',
+    './config/public/locales'
+];
+const isDirectory = (dirPath)=>{
+    try {
+        return fs.statSync(dirPath).isDirectory();
+    } catch  {
+        return false;
+    }
+};
+const resolveDefaultLocalesDir = (cwd = process.cwd())=>{
+    for (const dir of CONVENTIONAL_LOCALES_DIRS)if (isDirectory(path_0.resolve(cwd, dir))) return dir;
+    return CONVENTIONAL_LOCALES_DIRS[0];
+};
 const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
-    loadPath: './config/public/locales/{{lng}}/{{ns}}.json',
-    addPath: './config/public/locales/{{lng}}/{{ns}}.json'
+    get loadPath () {
+        return `${resolveDefaultLocalesDir()}/{{lng}}/{{ns}}.json`;
+    },
+    get addPath () {
+        return `${resolveDefaultLocalesDir()}/{{lng}}/{{ns}}.json`;
+    }
 };
 function convertPath(path) {
     if (!path) return path;
@@ -17,4 +38,4 @@ function convertBackendOptions(options) {
     if (converted.addPath) converted.addPath = convertPath(converted.addPath);
     return converted;
 }
-export { DEFAULT_I18NEXT_BACKEND_OPTIONS, convertBackendOptions };
+export { DEFAULT_I18NEXT_BACKEND_OPTIONS, convertBackendOptions, resolveDefaultLocalesDir };

package/dist/esm-node/runtime/localizedPaths.mjs

@@ -1,16 +1,13 @@
 import "node:module";
 import { useMemo } from "react";
-import { resolveCanonicalLocalisedPath, resolveLocalisedUrlsConfig } from "../shared/localisedUrls.mjs";
+import { canonicalTargetPathname } from "../shared/localisedUrls.mjs";
 import { useModernI18n } from "./context.mjs";
 import { useI18nRouterAdapter } from "./routerAdapter.mjs";
 import { buildLocalizedUrl, splitUrlTarget } from "./utils.mjs";
 const localizePath = (pathname, language, config)=>buildLocalizedUrl(pathname, language, config.languages, config.localisedUrls);
 const canonicalPath = (target, config)=>{
     const { pathname, search, hash } = splitUrlTarget(target);
-    const segments = pathname.split('/').filter(Boolean);
-    const pathWithoutLanguage = segments.length > 0 && config.languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : pathname || '/';
-    const localisedUrlsConfig = resolveLocalisedUrlsConfig(config.localisedUrls);
-    const resolvedPath = localisedUrlsConfig.enabled ? resolveCanonicalLocalisedPath(pathWithoutLanguage, config.languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+    const resolvedPath = canonicalTargetPathname(pathname, config.languages, config.localisedUrls);
     return `${resolvedPath}${search}${hash}`;
 };
 const useLocalizedPaths = ()=>{

package/dist/esm-node/runtime/routerAdapter.mjs

@@ -1,6 +1,6 @@
 import "node:module";
 import { RuntimeContext, isBrowser } from "@modern-js/runtime";
-import { InternalRuntimeContext } from "@modern-js/runtime/context";
+import { InternalRuntimeContext, getRouterRuntimeState } from "@modern-js/runtime/context";
 import { Link as router_Link, useInRouterContext, useLocation, useNavigate, useParams } from "@modern-js/runtime/router";
 import { useCallback, useContext, useEffect, useState } from "react";
 const normalizeUrlPart = (value, prefix)=>{
@@ -26,7 +26,7 @@ const getWindowLocation = ()=>{
     };
 };
 const getRouterFramework = (runtimeContext, internalContext, inReactRouter)=>{
-    const framework = internalContext.routerFramework || internalContext.routerRuntime?.framework || runtimeContext.routerFramework;
+    const framework = getRouterRuntimeState(internalContext)?.framework || getRouterRuntimeState(runtimeContext)?.framework;
     if (framework) return framework;
     if (internalContext.router?.useRouter || runtimeContext.router?.useRouter) return 'tanstack';
     if (internalContext.router?.useLocation || internalContext.router?.useHref || runtimeContext.router?.useLocation || runtimeContext.router?.useHref) return 'react-router';
@@ -34,7 +34,7 @@ const getRouterFramework = (runtimeContext, internalContext, inReactRouter)=>{
 };
 const getRouterInstance = (internalContext, contextRouter)=>{
     if (contextRouter) return contextRouter;
-    const router = internalContext.routerInstance || internalContext.routerRuntime?.instance;
+    const router = getRouterRuntimeState(internalContext)?.instance;
     if (!router || 'object' != typeof router) return null;
     return router;
 };

package/dist/esm-node/runtime/utils.mjs

@@ -1,7 +1,7 @@
 import "node:module";
 import { isBrowser } from "@modern-js/runtime";
 import { getGlobalBasename } from "@modern-js/runtime/context";
-import { resolveLocalisedPath, resolveLocalisedUrlsConfig } from "../shared/localisedUrls.mjs";
+import { localiseTargetPathname } from "../shared/localisedUrls.mjs";
 const getPathname = (context)=>{
     if (isBrowser()) return window.location.pathname;
     return context.ssrContext?.request?.pathname || '/';
@@ -32,15 +32,8 @@ const splitUrlTarget = (target)=>{
 };
 const buildLocalizedUrl = (target, language, languages, localisedUrls)=>{
     const { pathname, search, hash } = splitUrlTarget(target);
-    const segments = pathname.split('/').filter(Boolean);
-    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
-    const pathWithoutLanguage = segments.length > 0 && languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : pathname || '/';
-    const resolvedPath = localisedUrlsConfig.enabled ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
-    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
-    return `/${[
-        language,
-        ...resolvedSegments
-    ].join('/')}${search}${hash}`;
+    const localizedPathname = localiseTargetPathname(pathname, language, languages, localisedUrls);
+    return `${localizedPathname}${search}${hash}`;
 };
 const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
     if (!localePathRedirect) return {

package/dist/esm-node/server/index.mjs

@@ -1,6 +1,6 @@
 import "node:module";
 import { DEFAULT_I18NEXT_DETECTION_OPTIONS, mergeDetectionOptions } from "../runtime/i18n/detection/config.mjs";
-import { resolveLocalisedPath, resolveLocalisedUrlsConfig } from "../shared/localisedUrls.mjs";
+import { localiseTargetPathname, resolveLocalisedUrlsConfig } from "../shared/localisedUrls.mjs";
 import { getLocaleDetectionOptions } from "../shared/utils.mjs";
 import * as __rspack_external__modern_js_server_core_hono_a76ca254 from "@modern-js/server-core/hono";
 const { languageDetector: languageDetector } = __rspack_external__modern_js_server_core_hono_a76ca254;
@@ -128,15 +128,7 @@ const buildLocalizedUrl = (req, urlPath, language, languages, localisedUrls)=>{
     const pathname = url.pathname;
     const basePath = urlPath.replace('/*', '');
     const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
-    const segments = remainingPath.split('/').filter(Boolean);
-    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
-    const pathWithoutLanguage = segments.length > 0 && languages.includes(segments[0]) ? `/${segments.slice(1).join('/')}` : remainingPath;
-    const resolvedPath = localisedUrlsConfig.enabled ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
-    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
-    const newPathname = `/${[
-        language,
-        ...resolvedSegments
-    ].join('/')}`;
+    const newPathname = localiseTargetPathname(remainingPath, language, languages, localisedUrls);
     const suffix = `${url.search}${url.hash}`;
     const localizedUrl = '/' === basePath ? newPathname + suffix : basePath + newPathname + suffix;
     return localizedUrl;

package/dist/esm-node/shared/localisedUrls.mjs

@@ -4,12 +4,13 @@ const LOCALE_PARAM_NAMES = new Set([
     'locale',
     'language'
 ]);
-const normalisePathPattern = (path)=>{
+const normaliseSlashes = (path)=>{
     const withoutDuplicateSlashes = path.replace(/\/+/g, '/');
     const withLeadingSlash = withoutDuplicateSlashes.startsWith('/') ? withoutDuplicateSlashes : `/${withoutDuplicateSlashes}`;
-    const withoutTrailingSlash = withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/, '') : withLeadingSlash;
-    return withoutTrailingSlash.replace(/\[(.+?)\]/g, ':$1');
+    return withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/, '') : withLeadingSlash;
 };
+const normalisePathPattern = (path)=>normaliseSlashes(path).replace(/\[(.+?)\]/g, ':$1');
+const normalisePathname = (pathname)=>normaliseSlashes(pathname);
 const normaliseRoutePath = (path)=>{
     const normalized = normalisePathPattern(path);
     return '/' === normalized ? '' : normalized.slice(1);
@@ -35,16 +36,12 @@ const getLeadingLocaleParam = (path)=>{
     return getLocaleParamSegment(segments[0] || '');
 };
 const resolveLocalisedUrlsConfig = (option)=>{
-    if (false === option) return {
-        enabled: false,
-        map: {}
-    };
-    if (option && 'object' == typeof option) return {
+    if (option && 'object' == typeof option && Object.keys(option).length > 0) return {
         enabled: true,
         map: option
     };
     return {
-        enabled: true,
+        enabled: false,
         map: {}
     };
 };
@@ -136,9 +133,13 @@ const applyLocalisedUrlsToRoutes = (routes, languages, localisedUrls)=>{
 };
 const escapeRegExp = (value)=>value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 const getParamName = (segment)=>segment.slice(1).replace(/\?$/, '');
+const compiledPathPatternCache = new Map();
 const compilePathPattern = (pattern)=>{
+    const normalizedPattern = normalisePathPattern(pattern);
+    const cached = compiledPathPatternCache.get(normalizedPattern);
+    if (cached) return cached;
     const names = [];
-    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const segments = normalizedPattern.split('/').filter(Boolean);
     const source = segments.map((segment)=>{
         if (segment.startsWith(':')) {
             names.push(getParamName(segment));
@@ -151,19 +152,55 @@ const compilePathPattern = (pattern)=>{
         }
         return `/${escapeRegExp(segment)}`;
     }).join('');
-    return {
+    const compiled = {
         names,
         regexp: new RegExp(`^${source || '/'}$`)
     };
+    compiledPathPatternCache.set(normalizedPattern, compiled);
+    return compiled;
+};
+const getPatternSpecificity = (pattern)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    let staticSegments = 0;
+    let dynamicSegments = 0;
+    let splatSegments = 0;
+    for (const segment of segments)if ('*' === segment) splatSegments++;
+    else if (segment.startsWith(':')) dynamicSegments++;
+    else staticSegments++;
+    return {
+        staticSegments,
+        dynamicSegments,
+        splatSegments,
+        totalSegments: segments.length
+    };
+};
+const comparePatternSpecificity = (left, right)=>{
+    const a = getPatternSpecificity(left);
+    const b = getPatternSpecificity(right);
+    return b.staticSegments - a.staticSegments || b.totalSegments - a.totalSegments || a.splatSegments - b.splatSegments || a.dynamicSegments - b.dynamicSegments;
+};
+const sortPatternsBySpecificity = (patterns)=>patterns.map((pattern, index)=>({
+            pattern,
+            index
+        })).sort((left, right)=>comparePatternSpecificity(left.pattern.pattern, right.pattern.pattern) || left.index - right.index).map(({ pattern })=>pattern);
+const decodePathParam = (value)=>{
+    try {
+        return decodeURIComponent(value);
+    } catch  {
+        return null;
+    }
 };
 const matchPathPattern = (pathname, pattern)=>{
     const { names, regexp } = compilePathPattern(pattern);
-    const match = regexp.exec(normalisePathPattern(pathname));
+    const match = regexp.exec(normalisePathname(pathname));
     if (!match) return null;
-    return names.reduce((params, name, index)=>{
-        params[name] = decodeURIComponent(match[index + 1] || '');
-        return params;
-    }, {});
+    const params = {};
+    for(let index = 0; index < names.length; index++){
+        const decoded = decodePathParam(match[index + 1] || '');
+        if (null === decoded) return null;
+        params[names[index]] = decoded;
+    }
+    return params;
 };
 const buildPathFromPattern = (pattern, params)=>{
     const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
@@ -178,27 +215,41 @@ const buildPathFromPattern = (pattern, params)=>{
     return `/${path}`;
 };
 const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>{
-    const normalizedPathname = normalisePathPattern(pathname);
-    for (const [canonicalPattern, localisedUrlEntry] of Object.entries(localisedUrls)){
+    const normalizedPathname = normalisePathname(pathname);
+    const canonicalCandidates = sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
+            pattern: canonicalPattern,
+            canonicalPattern,
+            localisedUrlEntry
+        })));
+    for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
         const targetPattern = localisedUrlEntry[targetLanguage];
         if (!targetPattern) continue;
         const params = matchPathPattern(normalizedPathname, canonicalPattern);
         if (params) return buildPathFromPattern(targetPattern, params);
     }
-    for (const localisedUrlEntry of Object.values(localisedUrls)){
+    const localisedCandidates = sortPatternsBySpecificity(Object.values(localisedUrls).flatMap((localisedUrlEntry)=>{
         const targetPattern = localisedUrlEntry[targetLanguage];
-        if (targetPattern) for (const language of languages){
-            const sourcePattern = localisedUrlEntry[language];
-            if (!sourcePattern) continue;
-            const params = matchPathPattern(normalizedPathname, sourcePattern);
-            if (params) return buildPathFromPattern(targetPattern, params);
-        }
+        if (!targetPattern) return [];
+        return languages.map((language)=>localisedUrlEntry[language]).filter((sourcePattern)=>Boolean(sourcePattern)).map((sourcePattern)=>({
+                pattern: sourcePattern,
+                sourcePattern,
+                targetPattern
+            }));
+    }));
+    for (const { sourcePattern, targetPattern } of localisedCandidates){
+        const params = matchPathPattern(normalizedPathname, sourcePattern);
+        if (params) return buildPathFromPattern(targetPattern, params);
     }
     return normalizedPathname;
 };
 const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>{
-    const normalizedPathname = normalisePathPattern(pathname);
-    for (const [canonicalPattern, localisedUrlEntry] of Object.entries(localisedUrls)){
+    const normalizedPathname = normalisePathname(pathname);
+    const canonicalCandidates = sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
+            pattern: canonicalPattern,
+            canonicalPattern,
+            localisedUrlEntry
+        })));
+    for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
         const canonicalParams = matchPathPattern(normalizedPathname, canonicalPattern);
         if (canonicalParams) return buildPathFromPattern(canonicalPattern, canonicalParams);
         for (const language of languages){
@@ -210,4 +261,24 @@ const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>{
     }
     return normalizedPathname;
 };
-export { applyLocalisedUrlsToRoutes, buildPathFromPattern, matchPathPattern, normalisePathPattern, resolveCanonicalLocalisedPath, resolveLocalisedPath, resolveLocalisedUrlsConfig, validateLocalisedUrls };
+const stripLanguagePrefix = (pathname, languages)=>{
+    const segments = pathname.split('/').filter(Boolean);
+    if (segments.length > 0 && languages.includes(segments[0])) return `/${segments.slice(1).join('/')}`;
+    return pathname || '/';
+};
+const localiseTargetPathname = (pathname, language, languages, localisedUrls)=>{
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+    const resolvedPath = localisedUrlsConfig.enabled ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
+    return `/${[
+        language,
+        ...resolvedSegments
+    ].join('/')}`;
+};
+const canonicalTargetPathname = (pathname, languages, localisedUrls)=>{
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+    return localisedUrlsConfig.enabled ? resolveCanonicalLocalisedPath(pathWithoutLanguage, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+};
+export { applyLocalisedUrlsToRoutes, buildPathFromPattern, canonicalTargetPathname, localiseTargetPathname, matchPathPattern, normalisePathPattern, normalisePathname, resolveCanonicalLocalisedPath, resolveLocalisedPath, resolveLocalisedUrlsConfig, validateLocalisedUrls };

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

@@ -24,7 +24,17 @@ export interface LinkBaseProps extends AnchorRest {
     search?: string | Record<string, unknown>;
     hashScrollIntoView?: boolean | ScrollIntoViewOptions;
     replace?: boolean;
+    /**
+     * Prefetching behavior, forwarded to the underlying router link:
+     * react-router gets it verbatim (Modern.js `PrefetchLink` supports it),
+     * TanStack receives it as its native `preload` prop (`'none'` -> `false`).
+     * Stripped from plain `<a>` fallbacks (external / no-router targets).
+     */
     prefetch?: 'intent' | 'render' | 'viewport' | 'none';
+    /**
+     * Native preload value of the underlying router link. When set, it wins
+     * over `prefetch` on the TanStack branch.
+     */
     preload?: unknown;
     activeOptions?: LinkActiveOptions;
     /** Extra anchor props applied when the link is active. */