@bleedingdev/modern-js-plugin-i18n 3.2.0-ultramodern.98 → 3.4.0-ultramodern.0

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: {}
     };
 };
@@ -100,7 +97,7 @@ const transformLocalisedRoute = (route, parentCanonicalPath, parentLocalisedPath
     if (!localisedUrlEntry) return [
         baseRoute
     ];
-    return getLocalisedRoutePaths(canonicalPath, parentLocalisedPaths, languages, localisedUrlEntry).map((localisedPath, index)=>cloneRouteWithLocalisedPath(baseRoute, localisedPath, index));
+    return getLocalisedRoutePaths(canonicalPath, parentLocalisedPaths, languages, localisedUrlEntry).map((localisedPath, index)=>cloneRouteWithLocalisedPath(baseRoute, localisedPath, index, canonicalPath));
 };
 const legalRouteIdPart = (value)=>value.replace(/[^a-zA-Z0-9_$-]+/g, '_').replace(/^_+|_+$/g, '') || 'index';
 const suffixRouteIds = (route, suffix)=>{
@@ -115,13 +112,14 @@ const suffixRouteIds = (route, suffix)=>{
         } : {}
     };
 };
-const cloneRouteWithLocalisedPath = (route, path, index)=>{
+const cloneRouteWithLocalisedPath = (route, path, index, canonicalPath)=>{
     const leadingLocaleParam = getLeadingLocaleParam(route.path);
     const localisedPath = leadingLocaleParam ? normaliseRoutePath(`${leadingLocaleParam}/${path}`) : path;
     const routeWithPath = {
         ...route,
         path: localisedPath
     };
+    routeWithPath.modernCanonicalPath = canonicalPath;
     return 0 === index ? routeWithPath : suffixRouteIds(routeWithPath, legalRouteIdPart(localisedPath));
 };
 const applyLocalisedUrlsToRoutes = (routes, languages, localisedUrls)=>{
@@ -134,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));
@@ -149,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);
@@ -176,16 +214,70 @@ const buildPathFromPattern = (pattern, params)=>{
     return `/${path}`;
 };
 const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>{
-    const normalizedPathname = normalisePathPattern(pathname);
-    for (const localisedUrlEntry of Object.values(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);
+    }
+    const localisedCandidates = sortPatternsBySpecificity(Object.values(localisedUrls).flatMap((localisedUrlEntry)=>{
         const targetPattern = localisedUrlEntry[targetLanguage];
-        if (targetPattern) for (const language of languages){
+        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 = 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){
             const sourcePattern = localisedUrlEntry[language];
             if (!sourcePattern) continue;
             const params = matchPathPattern(normalizedPathname, sourcePattern);
-            if (params) return buildPathFromPattern(targetPattern, params);
+            if (params) return buildPathFromPattern(canonicalPattern, params);
         }
     }
     return normalizedPathname;
 };
-export { applyLocalisedUrlsToRoutes, normalisePathPattern, 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/cli/index.mjs

@@ -1,39 +1,9 @@
 import "node:module";
 import { getPublicDirRoutePrefixes } from "@modern-js/server-core";
-import fs from "fs";
-import path from "path";
 import { applyLocalisedUrlsToRoutes, resolveLocalisedUrlsConfig } from "../shared/localisedUrls.mjs";
 import { getBackendOptions, getLocaleDetectionOptions } from "../shared/utils.mjs";
-function hasJsonFiles(dirPath) {
-    try {
-        if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) return false;
-        const entries = fs.readdirSync(dirPath);
-        for (const entry of entries){
-            const entryPath = path.join(dirPath, entry);
-            const stat = fs.statSync(entryPath);
-            if (stat.isFile() && entry.endsWith('.json')) return true;
-            if (stat.isDirectory()) {
-                if (hasJsonFiles(entryPath)) return true;
-            }
-        }
-        return false;
-    } catch  {
-        return false;
-    }
-}
-function detectLocalesDirectory(appDirectory, normalizedConfig) {
-    const rootLocalesPath = path.join(appDirectory, 'locales');
-    if (hasJsonFiles(rootLocalesPath)) return true;
-    const configPublicPath = path.join(appDirectory, 'config', 'public', 'locales');
-    if (hasJsonFiles(configPublicPath)) return true;
-    const publicDir = normalizedConfig?.server?.publicDir;
-    if (publicDir) {
-        const publicDirPath = Array.isArray(publicDir) ? publicDir[0] : publicDir;
-        const localesPath = path.isAbsolute(publicDirPath) ? path.join(publicDirPath, 'locales') : path.join(appDirectory, publicDirPath, 'locales');
-        if (hasJsonFiles(localesPath)) return true;
-    }
-    return false;
-}
+import { applyDetectedBackendPaths, detectLocalesDirectory } from "./locales.mjs";
+import "../runtime/types.mjs";
 const i18nPlugin = (options = {})=>({
         name: '@modern-js/plugin-i18n',
         setup: (api)=>{
@@ -43,26 +13,16 @@ const i18nPlugin = (options = {})=>({
                 let backendOptions;
                 const { appDirectory } = api.getAppContext();
                 const normalizedConfig = api.getNormalizedConfig();
+                const detectedLocales = detectLocalesDirectory(appDirectory, normalizedConfig);
                 if (backend) {
                     const entryBackendOptions = getBackendOptions(entrypoint.entryName, backend);
-                    if (entryBackendOptions?.enabled === false) backendOptions = entryBackendOptions;
-                    else if (entryBackendOptions?.loadPath || entryBackendOptions?.addPath) backendOptions = {
+                    backendOptions = entryBackendOptions?.enabled === false ? entryBackendOptions : detectedLocales ? applyDetectedBackendPaths(entryBackendOptions, detectedLocales) : entryBackendOptions?.loadPath || entryBackendOptions?.addPath ? {
                         ...entryBackendOptions,
                         enabled: true
-                    };
-                    else if (entryBackendOptions?.enabled !== true) {
-                        const hasLocales = detectLocalesDirectory(appDirectory, normalizedConfig);
-                        backendOptions = hasLocales ? {
-                            ...entryBackendOptions,
-                            enabled: true
-                        } : entryBackendOptions;
-                    } else backendOptions = entryBackendOptions;
-                } else {
-                    const hasLocales = detectLocalesDirectory(appDirectory, normalizedConfig);
-                    if (hasLocales) backendOptions = getBackendOptions(entrypoint.entryName, {
-                        enabled: true
-                    });
-                }
+                    } : entryBackendOptions;
+                } else if (detectedLocales) backendOptions = applyDetectedBackendPaths(getBackendOptions(entrypoint.entryName, {
+                    enabled: true
+                }), detectedLocales);
                 const { metaName } = api.getAppContext();
                 let extendedConfig = restOptions;
                 if (transformRuntimeConfig) extendedConfig = transformRuntimeConfig(restOptions, entrypoint);

package/dist/esm-node/cli/locales.mjs

@@ -0,0 +1,81 @@
+import "node:module";
+import { getPublicDirRoutePrefixes, normalizePublicDir, normalizePublicDirPath } from "@modern-js/server-core";
+import fs from "fs";
+import path from "path";
+const LOCALES_RESOURCE_PATTERN = '{{lng}}/{{ns}}.json';
+function hasJsonFiles(dirPath) {
+    try {
+        if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) return false;
+        const entries = fs.readdirSync(dirPath);
+        for (const entry of entries){
+            const entryPath = path.join(dirPath, entry);
+            const stat = fs.statSync(entryPath);
+            if (stat.isFile() && entry.endsWith('.json')) return true;
+            if (stat.isDirectory() && hasJsonFiles(entryPath)) return true;
+        }
+        return false;
+    } catch  {
+        return false;
+    }
+}
+function toPosixPath(filePath) {
+    return filePath.split(path.sep).join(path.posix.sep);
+}
+function getPublicDirOutputPath(publicDir) {
+    return normalizePublicDirPath(publicDir);
+}
+function buildDetectedLocalesDirectory(clientBasePath, serverBasePath, serverBasePathCandidates = [
+    serverBasePath
+]) {
+    const normalizedClientBasePath = clientBasePath.startsWith('/') ? clientBasePath : `/${clientBasePath}`;
+    const normalizedServerBasePath = toPosixPath(serverBasePath).replace(/\/$/, '');
+    const normalizedServerBasePathCandidates = Array.from(new Set(serverBasePathCandidates.map((candidate)=>toPosixPath(candidate).replace(/\/$/, ''))));
+    const serverLoadPaths = normalizedServerBasePathCandidates.map((candidate)=>`${candidate}/${LOCALES_RESOURCE_PATTERN}`);
+    const serverAddPaths = normalizedServerBasePathCandidates.map((candidate)=>`${candidate}/${LOCALES_RESOURCE_PATTERN}`);
+    return {
+        loadPath: `${normalizedClientBasePath}/${LOCALES_RESOURCE_PATTERN}`,
+        addPath: `${normalizedClientBasePath}/${LOCALES_RESOURCE_PATTERN}`,
+        serverLoadPath: `${normalizedServerBasePath}/${LOCALES_RESOURCE_PATTERN}`,
+        serverAddPath: `${normalizedServerBasePath}/${LOCALES_RESOURCE_PATTERN}`,
+        serverLoadPaths,
+        serverAddPaths
+    };
+}
+function detectLocalesDirectory(appDirectory, normalizedConfig) {
+    const publicDirs = normalizePublicDir(normalizedConfig?.server?.publicDir);
+    const publicDirPrefixes = getPublicDirRoutePrefixes(normalizedConfig?.server?.publicDir);
+    for(let index = 0; index < publicDirs.length; index++){
+        const publicDir = publicDirs[index];
+        if (path.isAbsolute(publicDir)) continue;
+        const publicDirPath = path.join(appDirectory, publicDir);
+        const publicDirPrefix = publicDirPrefixes[index] || `/${normalizePublicDirPath(publicDir)}`;
+        const publicDirOutputPath = getPublicDirOutputPath(publicDir);
+        if ('locales' === path.basename(normalizePublicDirPath(publicDir)) && hasJsonFiles(publicDirPath)) return buildDetectedLocalesDirectory(publicDirPrefix, `./${publicDirOutputPath}`);
+        const localesPath = path.join(publicDirPath, 'locales');
+        if (hasJsonFiles(localesPath)) return buildDetectedLocalesDirectory(`${publicDirPrefix}/locales`, `./${publicDirOutputPath}/locales`);
+    }
+    const configPublicPath = path.join(appDirectory, 'config', 'public', 'locales');
+    if (hasJsonFiles(configPublicPath)) return buildDetectedLocalesDirectory('/locales', './public/locales', [
+        './config/public/locales',
+        './public/locales'
+    ]);
+    const rootLocalesPath = path.join(appDirectory, 'locales');
+    if (hasJsonFiles(rootLocalesPath)) return buildDetectedLocalesDirectory('/locales', './locales');
+}
+function applyDetectedBackendPaths(backendOptions, detectedLocales) {
+    if (!detectedLocales) return backendOptions;
+    const backendWithDetectedPaths = {
+        ...backendOptions,
+        enabled: true,
+        loadPath: backendOptions.loadPath ?? detectedLocales.loadPath,
+        addPath: backendOptions.addPath ?? detectedLocales.addPath,
+        serverLoadPath: backendOptions.serverLoadPath ?? detectedLocales.serverLoadPath,
+        serverLoadPaths: backendOptions.serverLoadPath || backendOptions.serverLoadPaths ? backendOptions.serverLoadPaths : detectedLocales.serverLoadPaths,
+        serverAddPath: backendOptions.serverAddPath ?? detectedLocales.serverAddPath,
+        serverAddPaths: backendOptions.serverAddPath || backendOptions.serverAddPaths ? backendOptions.serverAddPaths : detectedLocales.serverAddPaths,
+        _detectedLoadPath: detectedLocales.loadPath,
+        _detectedAddPath: detectedLocales.addPath
+    };
+    return backendWithDetectedPaths;
+}
+export { applyDetectedBackendPaths, detectLocalesDirectory };

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

@@ -1,21 +1,14 @@
 import "node:module";
 import { jsx } from "react/jsx-runtime";
-import { useModernI18n } from "./context.mjs";
-import { useI18nRouterAdapter } from "./routerAdapter.mjs";
-import { buildLocalizedUrl } from "./utils.mjs";
+import { Link } from "./Link.mjs";
+let warnedDeprecation = false;
 const I18nLink = ({ to, children, ...props })=>{
-    const { Link, params, hasRouter } = useI18nRouterAdapter();
-    const { language, supportedLanguages, localisedUrls } = useModernI18n();
-    const currentLang = language;
-    const localizedTo = buildLocalizedUrl(to, currentLang, supportedLanguages, localisedUrls);
-    if ('development' === process.env.NODE_ENV && hasRouter && !params.lang) console.warn("I18nLink is being used outside of a :lang dynamic route context. This may cause unexpected behavior. Please ensure I18nLink is used within a route that has a :lang parameter.");
-    if (!hasRouter || !Link) return /*#__PURE__*/ jsx("a", {
-        href: localizedTo,
-        ...props,
-        children: children
-    });
+    if ('development' === process.env.NODE_ENV && !warnedDeprecation) {
+        warnedDeprecation = true;
+        console.warn("[plugin-i18n] I18nLink is deprecated. Import { Link } from '@modern-js/plugin-i18n/runtime' instead — it accepts the same language-agnostic `to` values.");
+    }
     return /*#__PURE__*/ jsx(Link, {
-        to: localizedTo,
+        to: to,
         ...props,
         children: children
     });

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

@@ -0,0 +1,222 @@
+import "node:module";
+import { jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { useModernI18n } from "./context.mjs";
+import { canonicalPath } from "./localizedPaths.mjs";
+import { useI18nRouterAdapter } from "./routerAdapter.mjs";
+import { buildLocalizedUrl, splitUrlTarget } from "./utils.mjs";
+const EXTERNAL_TARGET_RE = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+const warnedTargets = new Set();
+const warnOnce = (key, message)=>{
+    if ('development' !== process.env.NODE_ENV || warnedTargets.has(key)) return;
+    warnedTargets.add(key);
+    console.warn(message);
+};
+const interpolateRouteParams = (pathname, params)=>{
+    if (!/[$:*{]/.test(pathname)) return pathname;
+    const resolveParam = (name)=>{
+        const value = params?.[name];
+        return void 0 === value ? void 0 : String(value);
+    };
+    const segments = pathname.split('/').map((segment)=>{
+        if (!segment) return segment;
+        if (segment.startsWith('{-$') && segment.endsWith('}')) {
+            const value = resolveParam(segment.slice(3, -1));
+            return void 0 === value ? null : encodeURIComponent(value);
+        }
+        if ('$' === segment || '*' === segment) {
+            const value = resolveParam('_splat') ?? resolveParam('*');
+            return void 0 === value ? null : value.split('/').map(encodeURIComponent).join('/');
+        }
+        if (segment.startsWith('$')) {
+            const value = resolveParam(segment.slice(1));
+            if (void 0 === value) {
+                warnOnce(`missing-param:${pathname}:${segment}`, `[plugin-i18n] <Link to="${pathname}"> is missing required param "${segment.slice(1)}".`);
+                return segment;
+            }
+            return encodeURIComponent(value);
+        }
+        if (segment.startsWith(':')) {
+            const optional = segment.endsWith('?');
+            const name = segment.slice(1, optional ? -1 : void 0);
+            const value = resolveParam(name);
+            if (void 0 === value) {
+                if (optional) return null;
+                warnOnce(`missing-param:${pathname}:${segment}`, `[plugin-i18n] <Link to="${pathname}"> is missing required param "${name}".`);
+                return segment;
+            }
+            return encodeURIComponent(value);
+        }
+        return segment;
+    }).filter((segment)=>null !== segment);
+    return segments.join('/') || '/';
+};
+const normalizeSearch = (search, searchFromTo)=>{
+    if (search && 'object' == typeof search) {
+        const entries = Object.entries(search).filter(([, value])=>null != value);
+        const searchObject = Object.fromEntries(entries.map(([key, value])=>[
+                key,
+                String(value)
+            ]));
+        const params = new URLSearchParams(searchObject);
+        const serialized = params.toString();
+        return {
+            searchString: serialized ? `?${serialized}` : '',
+            searchObject
+        };
+    }
+    const raw = 'string' == typeof search && search ? search : searchFromTo;
+    if (!raw) return {
+        searchString: '',
+        searchObject: void 0
+    };
+    const searchString = raw.startsWith('?') ? raw : `?${raw}`;
+    const searchObject = {};
+    new URLSearchParams(searchString).forEach((value, key)=>{
+        searchObject[key] = value;
+    });
+    return {
+        searchString,
+        searchObject
+    };
+};
+const splitActiveProps = (active, activeProps)=>{
+    if (!active || !activeProps) return {};
+    return activeProps;
+};
+const mergeClassNames = (...values)=>{
+    const classNames = values.filter((value)=>'string' == typeof value && value.length > 0);
+    return classNames.length > 0 ? classNames.join(' ') : void 0;
+};
+const Link = (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 = {
+        languages: supportedLanguages,
+        localisedUrls
+    };
+    const isExternal = EXTERNAL_TARGET_RE.test(to);
+    const isBareHash = to.startsWith('#');
+    const target = useMemo(()=>{
+        if (isExternal || isBareHash) return null;
+        const { pathname, search: searchFromTo, hash: hashFromTo } = splitUrlTarget(to);
+        const interpolated = interpolateRouteParams(pathname || '/', params);
+        const firstSegment = interpolated.split('/').filter(Boolean)[0];
+        if (firstSegment && supportedLanguages.includes(firstSegment)) warnOnce(`lang-prefix:${to}`, `[plugin-i18n] <Link to="${to}"> starts with a language prefix. Write language-agnostic canonical paths; the Link localizes them automatically.`);
+        const localizedPathname = buildLocalizedUrl(interpolated, language, supportedLanguages, localisedUrls);
+        const hash = hashProp ?? (hashFromTo ? hashFromTo.slice(1) : '');
+        const { searchString, searchObject } = normalizeSearch(searchProp, searchFromTo);
+        return {
+            canonicalPathname: interpolated,
+            localizedPathname,
+            hash,
+            searchString,
+            searchObject,
+            href: `${localizedPathname}${searchString}${hash ? `#${hash}` : ''}`
+        };
+    }, [
+        to,
+        params,
+        hashProp,
+        searchProp,
+        isExternal,
+        isBareHash,
+        language,
+        supportedLanguages,
+        localisedUrls
+    ]);
+    const isActive = useMemo(()=>{
+        if (!target || !adapter.location) return false;
+        const current = canonicalPath(adapter.location.pathname, config);
+        const targetCanonical = canonicalPath(target.canonicalPathname, config);
+        const exact = activeOptions?.exact ?? '/' === targetCanonical;
+        if (current === targetCanonical) return true;
+        if (exact) return false;
+        return current.startsWith('/' === targetCanonical ? '/' : `${targetCanonical}/`);
+    }, [
+        target,
+        adapter.location,
+        activeOptions?.exact,
+        supportedLanguages,
+        localisedUrls
+    ]);
+    const resolvedActiveProps = splitActiveProps(isActive, activeProps);
+    const activeAttributes = isActive ? {
+        'data-status': 'active',
+        'aria-current': rest['aria-current'] ?? resolvedActiveProps['aria-current'] ?? 'page'
+    } : {};
+    if (!target) {
+        const { replace: _replace, ...anchorProps } = rest;
+        return /*#__PURE__*/ jsx("a", {
+            href: to,
+            ...anchorProps,
+            children: children
+        });
+    }
+    const { Link: RouterLink, hasRouter, framework } = adapter;
+    if (!hasRouter || !RouterLink) {
+        const { replace: _replace, ...anchorProps } = rest;
+        const { className: activeClassName, style: activeStyle, ...activeRest } = resolvedActiveProps;
+        return /*#__PURE__*/ jsx("a", {
+            href: target.href,
+            ...anchorProps,
+            ...activeRest,
+            ...activeAttributes,
+            className: mergeClassNames(rest.className, activeClassName),
+            style: {
+                ...rest.style,
+                ...activeStyle
+            },
+            children: children
+        });
+    }
+    const { className: activeClassName, style: activeStyle, ...activeRest } = resolvedActiveProps;
+    const mergedClassName = mergeClassNames(rest.className, activeClassName);
+    const mergedStyle = {
+        ...rest.style,
+        ...activeStyle
+    };
+    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,
+        className: mergedClassName,
+        style: mergedStyle,
+        children: children
+    });
+};
+const runtime_Link = Link;
+export default runtime_Link;
+export { Link, interpolateRouteParams };

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

@@ -0,0 +1 @@
+import "node:module";

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

@@ -4,8 +4,6 @@ const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
     addPath: '/locales/{{lng}}/{{ns}}.json'
 };
 function convertPath(path) {
-    if (!path) return path;
-    if (path.startsWith('/')) return "u" < typeof window ? path : `${window.__assetPrefix__ || ''}${path}`;
     return path;
 }
 function convertBackendOptions(options) {
@@ -13,6 +11,12 @@ function convertBackendOptions(options) {
     const converted = {
         ...options
     };
+    delete converted.serverLoadPath;
+    delete converted.serverAddPath;
+    delete converted.serverLoadPaths;
+    delete converted.serverAddPaths;
+    delete converted._detectedLoadPath;
+    delete converted._detectedAddPath;
     if (converted.loadPath) converted.loadPath = convertPath(converted.loadPath);
     if (converted.addPath) converted.addPath = convertPath(converted.addPath);
     return converted;