@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.35 → 3.5.0-ultramodern.37

package/dist/cjs/cli/locales.js

@@ -40,19 +40,19 @@ __webpack_require__.d(__webpack_exports__, {
     applyDetectedBackendPaths: ()=>applyDetectedBackendPaths,
     detectLocalesDirectory: ()=>detectLocalesDirectory
 });
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const server_core_namespaceObject = require("@modern-js/server-core");
-const external_fs_namespaceObject = require("fs");
-var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
-const external_path_namespaceObject = require("path");
-var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
 const LOCALES_RESOURCE_PATTERN = '{{lng}}/{{ns}}.json';
 function hasJsonFiles(dirPath) {
     try {
-        if (!external_fs_default().existsSync(dirPath) || !external_fs_default().statSync(dirPath).isDirectory()) return false;
-        const entries = external_fs_default().readdirSync(dirPath);
+        if (!external_node_fs_default().existsSync(dirPath) || !external_node_fs_default().statSync(dirPath).isDirectory()) return false;
+        const entries = external_node_fs_default().readdirSync(dirPath);
         for (const entry of entries){
-            const entryPath = external_path_default().join(dirPath, entry);
-            const stat = external_fs_default().statSync(entryPath);
+            const entryPath = external_node_path_default().join(dirPath, entry);
+            const stat = external_node_fs_default().statSync(entryPath);
             if (stat.isFile() && entry.endsWith('.json')) return true;
             if (stat.isDirectory() && hasJsonFiles(entryPath)) return true;
         }
@@ -62,7 +62,7 @@ function hasJsonFiles(dirPath) {
     }
 }
 function toPosixPath(filePath) {
-    return filePath.split(external_path_default().sep).join(external_path_default().posix.sep);
+    return filePath.split(external_node_path_default().sep).join(external_node_path_default().posix.sep);
 }
 function getPublicDirOutputPath(publicDir) {
     return (0, server_core_namespaceObject.normalizePublicDirPath)(publicDir);
@@ -89,20 +89,20 @@ function detectLocalesDirectory(appDirectory, normalizedConfig) {
     const publicDirPrefixes = (0, server_core_namespaceObject.getPublicDirRoutePrefixes)(normalizedConfig?.server?.publicDir);
     for(let index = 0; index < publicDirs.length; index++){
         const publicDir = publicDirs[index];
-        if (external_path_default().isAbsolute(publicDir)) continue;
-        const publicDirPath = external_path_default().join(appDirectory, publicDir);
+        if (external_node_path_default().isAbsolute(publicDir)) continue;
+        const publicDirPath = external_node_path_default().join(appDirectory, publicDir);
         const publicDirPrefix = publicDirPrefixes[index] || `/${(0, server_core_namespaceObject.normalizePublicDirPath)(publicDir)}`;
         const publicDirOutputPath = getPublicDirOutputPath(publicDir);
-        if ('locales' === external_path_default().basename((0, server_core_namespaceObject.normalizePublicDirPath)(publicDir)) && hasJsonFiles(publicDirPath)) return buildDetectedLocalesDirectory(publicDirPrefix, `./${publicDirOutputPath}`);
-        const localesPath = external_path_default().join(publicDirPath, 'locales');
+        if ('locales' === external_node_path_default().basename((0, server_core_namespaceObject.normalizePublicDirPath)(publicDir)) && hasJsonFiles(publicDirPath)) return buildDetectedLocalesDirectory(publicDirPrefix, `./${publicDirOutputPath}`);
+        const localesPath = external_node_path_default().join(publicDirPath, 'locales');
         if (hasJsonFiles(localesPath)) return buildDetectedLocalesDirectory(`${publicDirPrefix}/locales`, `./${publicDirOutputPath}/locales`);
     }
-    const configPublicPath = external_path_default().join(appDirectory, 'config', 'public', 'locales');
+    const configPublicPath = external_node_path_default().join(appDirectory, 'config', 'public', 'locales');
     if (hasJsonFiles(configPublicPath)) return buildDetectedLocalesDirectory('/locales', './public/locales', [
         './config/public/locales',
         './public/locales'
     ]);
-    const rootLocalesPath = external_path_default().join(appDirectory, 'locales');
+    const rootLocalesPath = external_node_path_default().join(appDirectory, 'locales');
     if (hasJsonFiles(rootLocalesPath)) return buildDetectedLocalesDirectory('/locales', './locales');
 }
 function applyDetectedBackendPaths(backendOptions, detectedLocales) {

package/dist/cjs/runtime/i18n/backend/defaults.node.js

@@ -41,23 +41,23 @@ __webpack_require__.d(__webpack_exports__, {
     convertBackendOptions: ()=>convertBackendOptions,
     resolveDefaultLocalesDir: ()=>resolveDefaultLocalesDir
 });
-const external_fs_namespaceObject = require("fs");
-var external_fs_default = /*#__PURE__*/ __webpack_require__.n(external_fs_namespaceObject);
-const external_path_namespaceObject = require("path");
-var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
 const CONVENTIONAL_LOCALES_DIRS = [
     './locales',
     './config/public/locales'
 ];
 const isDirectory = (dirPath)=>{
     try {
-        return external_fs_default().statSync(dirPath).isDirectory();
+        return external_node_fs_default().statSync(dirPath).isDirectory();
     } catch  {
         return false;
     }
 };
 const resolveDefaultLocalesDir = (cwd = process.cwd())=>{
-    for (const dir of CONVENTIONAL_LOCALES_DIRS)if (isDirectory(external_path_default().resolve(cwd, dir))) return dir;
+    for (const dir of CONVENTIONAL_LOCALES_DIRS)if (isDirectory(external_node_path_default().resolve(cwd, dir))) return dir;
     return CONVENTIONAL_LOCALES_DIRS[0];
 };
 const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
@@ -83,7 +83,7 @@ function getResourceBasePath(resourcePath) {
 }
 function pathExists(resourcePath) {
     try {
-        return external_fs_default().existsSync(getResourceBasePath(resourcePath));
+        return external_node_fs_default().existsSync(getResourceBasePath(resourcePath));
     } catch  {
         return false;
     }

package/dist/cjs/runtime/i18n/detection/cache.js

@@ -50,9 +50,10 @@ const stableStringify = (value)=>{
     if (null == value) return JSON.stringify(value);
     if ('object' != typeof value) return JSON.stringify(value);
     if (Array.isArray(value)) return `[${value.map((item)=>stableStringify(item)).join(',')}]`;
-    const sortedKeys = Object.keys(value).sort();
+    const record = value;
+    const sortedKeys = Object.keys(record).sort();
     const sortedEntries = sortedKeys.map((key)=>{
-        const stringifiedValue = stableStringify(value[key]);
+        const stringifiedValue = stableStringify(record[key]);
         return `${JSON.stringify(key)}:${stringifiedValue}`;
     });
     return `{${sortedEntries.join(',')}}`;

package/dist/cjs/runtime/i18n/instance.js

@@ -29,9 +29,11 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 function isI18nWrapperInstance(obj) {
     if (!obj || 'object' != typeof obj) return false;
-    if (!obj.i18nInstance || 'object' != typeof obj.i18nInstance) return false;
-    if (!obj.i18nInstance.instance) return false;
-    if ('function' != typeof obj.init || 'function' != typeof obj.use) return false;
+    const candidate = obj;
+    if (!candidate.i18nInstance || 'object' != typeof candidate.i18nInstance) return false;
+    const wrapper = candidate.i18nInstance;
+    if (!wrapper.instance) return false;
+    if ('function' != typeof candidate.init || 'function' != typeof candidate.use) return false;
     return true;
 }
 function getI18nWrapperI18nextInstance(wrapperInstance) {
@@ -48,7 +50,8 @@ function getActualI18nextInstance(instance) {
 function isI18nInstance(obj) {
     if (!obj || 'object' != typeof obj) return false;
     if (isI18nWrapperInstance(obj)) return true;
-    return 'function' == typeof obj.init && 'function' == typeof obj.use;
+    const candidate = obj;
+    return 'function' == typeof candidate.init && 'function' == typeof candidate.use;
 }
 async function tryImportI18next() {
     try {
@@ -88,21 +91,18 @@ async function getI18nInstance(userInstance) {
 __webpack_require__.d(__webpack_exports__, {
     getActualI18nextInstance: ()=>getActualI18nextInstance,
     getI18nInstance: ()=>getI18nInstance,
-    getI18nWrapperI18nextInstance: ()=>getI18nWrapperI18nextInstance,
     getI18nextInstanceForProvider: ()=>getI18nextInstanceForProvider,
     isI18nInstance: ()=>isI18nInstance,
     isI18nWrapperInstance: ()=>isI18nWrapperInstance
 });
 exports.getActualI18nextInstance = __webpack_exports__.getActualI18nextInstance;
 exports.getI18nInstance = __webpack_exports__.getI18nInstance;
-exports.getI18nWrapperI18nextInstance = __webpack_exports__.getI18nWrapperI18nextInstance;
 exports.getI18nextInstanceForProvider = __webpack_exports__.getI18nextInstanceForProvider;
 exports.isI18nInstance = __webpack_exports__.isI18nInstance;
 exports.isI18nWrapperInstance = __webpack_exports__.isI18nWrapperInstance;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "getActualI18nextInstance",
     "getI18nInstance",
-    "getI18nWrapperI18nextInstance",
     "getI18nextInstanceForProvider",
     "isI18nInstance",
     "isI18nWrapperInstance"

package/dist/cjs/runtime/utils.js

@@ -89,15 +89,7 @@ const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
         detected: false
     };
 };
-const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>{
-    if (!ignoreRedirectRoutes) return false;
-    const segments = pathname.split('/').filter(Boolean);
-    let pathWithoutLang = pathname;
-    if (segments.length > 0 && languages.includes(segments[0])) pathWithoutLang = `/${segments.slice(1).join('/')}`;
-    const normalizedPath = pathWithoutLang.startsWith('/') ? pathWithoutLang : `/${pathWithoutLang}`;
-    if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(normalizedPath);
-    return ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
-};
+const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>(0, localisedUrls_js_namespaceObject.shouldSkipLocaleRedirect)(pathname, languages, ignoreRedirectRoutes);
 exports.buildLocalizedUrl = __webpack_exports__.buildLocalizedUrl;
 exports.detectLanguageFromPath = __webpack_exports__.detectLanguageFromPath;
 exports.getEntryPath = __webpack_exports__.getEntryPath;

package/dist/cjs/server/redirectPolicy.js

@@ -35,33 +35,27 @@ __webpack_require__.d(__webpack_exports__, {
     shouldIgnoreRedirect: ()=>shouldIgnoreRedirect
 });
 const localisedUrls_js_namespaceObject = require("../shared/localisedUrls.js");
-const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
-    if (!ignoreRedirectRoutes) return false;
+const stripUrlPathPrefix = (pathname, urlPath)=>{
     const basePath = urlPath.replace('/*', '');
+    if (!basePath || '/' === basePath) return pathname;
     const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
-    const normalizedPath = remainingPath.startsWith('/') ? remainingPath : `/${remainingPath}`;
-    if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(normalizedPath);
-    return ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
+    return remainingPath || '/';
+};
+const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
+    return (0, localisedUrls_js_namespaceObject.shouldSkipLocaleRedirect)(remainingPath, [], ignoreRedirectRoutes);
 };
 const isStaticResourceRequest = (pathname, staticRoutePrefixes, languages = [])=>{
-    if (staticRoutePrefixes.some((prefix)=>pathname.startsWith(`${prefix}/`) || pathname === prefix)) return true;
-    const standardStaticPrefixes = [
-        '/static/',
-        '/upload/'
-    ];
-    if (standardStaticPrefixes.some((prefix)=>pathname.startsWith(prefix))) return true;
-    const pathSegments = pathname.split('/').filter(Boolean);
-    if (pathSegments.length > 0 && languages.includes(pathSegments[0])) {
-        const pathWithoutLang = '/' + pathSegments.slice(1).join('/');
-        if (standardStaticPrefixes.some((prefix)=>pathWithoutLang.startsWith(prefix)) || staticRoutePrefixes.some((prefix)=>pathWithoutLang.startsWith(`${prefix}/`) || pathWithoutLang === prefix)) return true;
-    }
-    return false;
+    if ((0, localisedUrls_js_namespaceObject.isDefaultLocaleRedirectSkipPath)(pathname, languages)) return true;
+    const matchesStaticRoutePrefix = (targetPathname)=>staticRoutePrefixes.some((prefix)=>(0, localisedUrls_js_namespaceObject.matchesPathPrefix)(targetPathname, prefix));
+    if (matchesStaticRoutePrefix(pathname)) return true;
+    const pathWithoutLanguage = (0, localisedUrls_js_namespaceObject.stripLanguagePrefix)(pathname, languages);
+    return pathWithoutLanguage !== pathname && matchesStaticRoutePrefix(pathWithoutLanguage);
 };
 const getLanguageFromPath = (req, urlPath, languages)=>{
     const url = new URL(req.url, `http://${req.header().host}`);
     const pathname = url.pathname;
-    const basePath = urlPath.replace('/*', '');
-    const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
     const segments = remainingPath.split('/').filter(Boolean);
     const firstSegment = segments[0];
     if (languages.includes(firstSegment)) return firstSegment;
@@ -71,7 +65,7 @@ const buildLocalizedUrl = (req, urlPath, language, languages, localisedUrls)=>{
     const url = new URL(req.url);
     const pathname = url.pathname;
     const basePath = urlPath.replace('/*', '');
-    const remainingPath = pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
+    const remainingPath = stripUrlPathPrefix(pathname, urlPath);
     const newPathname = (0, localisedUrls_js_namespaceObject.localiseTargetPathname)(remainingPath, language, languages, localisedUrls);
     const suffix = `${url.search}${url.hash}`;
     const localizedUrl = '/' === basePath ? newPathname + suffix : basePath + newPathname + suffix;

package/dist/cjs/shared/detection.js

@@ -1,109 +1,7 @@
 "use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
 var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    detectLanguageFromRequest: ()=>detectLanguageFromRequest
-});
-const config_js_namespaceObject = require("../runtime/i18n/detection/config.js");
-function detectLanguageFromRequest(req, languages, detectionOptions) {
-    try {
-        const mergedDetection = detectionOptions ? (0, config_js_namespaceObject.mergeDetectionOptions)(detectionOptions) : config_js_namespaceObject.DEFAULT_I18NEXT_DETECTION_OPTIONS;
-        const order = (mergedDetection.order || []).filter((item)=>![
-                'path',
-                'localStorage',
-                'navigator',
-                'htmlTag',
-                'subdomain'
-            ].includes(item));
-        const detectionOrder = order.length > 0 ? order : [
-            'querystring',
-            'cookie',
-            'header'
-        ];
-        const getHeader = (name)=>{
-            req.headers, Headers;
-            return req.headers.get(name);
-        };
-        for (const method of detectionOrder){
-            let detectedLang = null;
-            switch(method){
-                case 'querystring':
-                    {
-                        const lookupKey = mergedDetection.lookupQuerystring || config_js_namespaceObject.DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupQuerystring || 'lng';
-                        const host = getHeader('host') || 'localhost';
-                        const url = new URL(req.url, `http://${host}`);
-                        detectedLang = url.searchParams.get(lookupKey);
-                        break;
-                    }
-                case 'cookie':
-                    {
-                        const lookupKey = mergedDetection.lookupCookie || config_js_namespaceObject.DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupCookie || 'i18next';
-                        const cookieHeader = getHeader('Cookie');
-                        if (cookieHeader) {
-                            const cookies = cookieHeader.split(';').reduce((acc, item)=>{
-                                const [key, value] = item.trim().split('=');
-                                if (key && value) acc[key] = value;
-                                return acc;
-                            }, {});
-                            detectedLang = cookies[lookupKey] || null;
-                        }
-                        break;
-                    }
-                case 'header':
-                    {
-                        const lookupKey = mergedDetection.lookupHeader || config_js_namespaceObject.DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupHeader || 'accept-language';
-                        const acceptLanguage = getHeader(lookupKey);
-                        if (acceptLanguage) {
-                            const languagesList = acceptLanguage.split(',').map((lang)=>{
-                                const [code, q] = lang.trim().split(';');
-                                return {
-                                    code: code.split('-')[0],
-                                    quality: q ? parseFloat(q.split('=')[1]) : 1.0
-                                };
-                            }).sort((a, b)=>b.quality - a.quality);
-                            for (const lang of languagesList)if (0 === languages.length || languages.includes(lang.code)) {
-                                detectedLang = lang.code;
-                                break;
-                            }
-                        }
-                        break;
-                    }
-            }
-            if (detectedLang && (0 === languages.length || languages.includes(detectedLang))) return detectedLang;
-        }
-    } catch (error) {}
-    return null;
-}
-exports.detectLanguageFromRequest = __webpack_exports__.detectLanguageFromRequest;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "detectLanguageFromRequest"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+require("../runtime/i18n/detection/config.js");
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true
 });

package/dist/cjs/shared/localisedUrls/index.js

@@ -28,46 +28,62 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
+    DEFAULT_LOCALE_REDIRECT_SKIP_RULES: ()=>external_redirect_js_namespaceObject.DEFAULT_LOCALE_REDIRECT_SKIP_RULES,
     applyLocalisedUrlsToRoutes: ()=>external_routes_js_namespaceObject.applyLocalisedUrlsToRoutes,
     buildPathFromPattern: ()=>external_patterns_js_namespaceObject.buildPathFromPattern,
     canonicalTargetPathname: ()=>external_pathname_js_namespaceObject.canonicalTargetPathname,
+    isDefaultLocaleRedirectSkipPath: ()=>external_redirect_js_namespaceObject.isDefaultLocaleRedirectSkipPath,
     localiseTargetPathname: ()=>external_pathname_js_namespaceObject.localiseTargetPathname,
     matchPathPattern: ()=>external_patterns_js_namespaceObject.matchPathPattern,
+    matchesPathPrefix: ()=>external_redirect_js_namespaceObject.matchesPathPrefix,
     normalisePathPattern: ()=>external_normalise_js_namespaceObject.normalisePathPattern,
     normalisePathname: ()=>external_normalise_js_namespaceObject.normalisePathname,
     resolveCanonicalLocalisedPath: ()=>external_resolve_js_namespaceObject.resolveCanonicalLocalisedPath,
     resolveLocalisedPath: ()=>external_resolve_js_namespaceObject.resolveLocalisedPath,
     resolveLocalisedUrlsConfig: ()=>external_config_js_namespaceObject.resolveLocalisedUrlsConfig,
+    shouldSkipLocaleRedirect: ()=>external_redirect_js_namespaceObject.shouldSkipLocaleRedirect,
+    stripLanguagePrefix: ()=>external_pathname_js_namespaceObject.stripLanguagePrefix,
     validateLocalisedUrls: ()=>external_routes_js_namespaceObject.validateLocalisedUrls
 });
 const external_config_js_namespaceObject = require("./config.js");
 const external_normalise_js_namespaceObject = require("./normalise.js");
 const external_pathname_js_namespaceObject = require("./pathname.js");
 const external_patterns_js_namespaceObject = require("./patterns.js");
+const external_redirect_js_namespaceObject = require("./redirect.js");
 const external_resolve_js_namespaceObject = require("./resolve.js");
 const external_routes_js_namespaceObject = require("./routes.js");
+exports.DEFAULT_LOCALE_REDIRECT_SKIP_RULES = __webpack_exports__.DEFAULT_LOCALE_REDIRECT_SKIP_RULES;
 exports.applyLocalisedUrlsToRoutes = __webpack_exports__.applyLocalisedUrlsToRoutes;
 exports.buildPathFromPattern = __webpack_exports__.buildPathFromPattern;
 exports.canonicalTargetPathname = __webpack_exports__.canonicalTargetPathname;
+exports.isDefaultLocaleRedirectSkipPath = __webpack_exports__.isDefaultLocaleRedirectSkipPath;
 exports.localiseTargetPathname = __webpack_exports__.localiseTargetPathname;
 exports.matchPathPattern = __webpack_exports__.matchPathPattern;
+exports.matchesPathPrefix = __webpack_exports__.matchesPathPrefix;
 exports.normalisePathPattern = __webpack_exports__.normalisePathPattern;
 exports.normalisePathname = __webpack_exports__.normalisePathname;
 exports.resolveCanonicalLocalisedPath = __webpack_exports__.resolveCanonicalLocalisedPath;
 exports.resolveLocalisedPath = __webpack_exports__.resolveLocalisedPath;
 exports.resolveLocalisedUrlsConfig = __webpack_exports__.resolveLocalisedUrlsConfig;
+exports.shouldSkipLocaleRedirect = __webpack_exports__.shouldSkipLocaleRedirect;
+exports.stripLanguagePrefix = __webpack_exports__.stripLanguagePrefix;
 exports.validateLocalisedUrls = __webpack_exports__.validateLocalisedUrls;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_LOCALE_REDIRECT_SKIP_RULES",
     "applyLocalisedUrlsToRoutes",
     "buildPathFromPattern",
     "canonicalTargetPathname",
+    "isDefaultLocaleRedirectSkipPath",
     "localiseTargetPathname",
     "matchPathPattern",
+    "matchesPathPrefix",
     "normalisePathPattern",
     "normalisePathname",
     "resolveCanonicalLocalisedPath",
     "resolveLocalisedPath",
     "resolveLocalisedUrlsConfig",
+    "shouldSkipLocaleRedirect",
+    "stripLanguagePrefix",
     "validateLocalisedUrls"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/shared/localisedUrls/pathname.js

@@ -29,7 +29,8 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     canonicalTargetPathname: ()=>canonicalTargetPathname,
-    localiseTargetPathname: ()=>localiseTargetPathname
+    localiseTargetPathname: ()=>localiseTargetPathname,
+    stripLanguagePrefix: ()=>stripLanguagePrefix
 });
 const external_config_js_namespaceObject = require("./config.js");
 const external_resolve_js_namespaceObject = require("./resolve.js");
@@ -56,9 +57,11 @@ const canonicalTargetPathname = (pathname, languages, localisedUrls)=>{
 };
 exports.canonicalTargetPathname = __webpack_exports__.canonicalTargetPathname;
 exports.localiseTargetPathname = __webpack_exports__.localiseTargetPathname;
+exports.stripLanguagePrefix = __webpack_exports__.stripLanguagePrefix;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "canonicalTargetPathname",
-    "localiseTargetPathname"
+    "localiseTargetPathname",
+    "stripLanguagePrefix"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/shared/localisedUrls/redirect.js

@@ -0,0 +1,95 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    DEFAULT_LOCALE_REDIRECT_SKIP_RULES: ()=>DEFAULT_LOCALE_REDIRECT_SKIP_RULES,
+    isDefaultLocaleRedirectSkipPath: ()=>isDefaultLocaleRedirectSkipPath,
+    matchesPathPrefix: ()=>matchesPathPrefix,
+    shouldSkipLocaleRedirect: ()=>shouldSkipLocaleRedirect
+});
+const external_normalise_js_namespaceObject = require("./normalise.js");
+const external_pathname_js_namespaceObject = require("./pathname.js");
+const DEFAULT_LOCALE_REDIRECT_SKIP_RULES = [
+    {
+        type: 'exact',
+        path: '/mf-manifest.json'
+    },
+    {
+        type: 'exact',
+        path: '/mf-stats.json'
+    },
+    {
+        type: 'exact',
+        path: '/remoteEntry.js'
+    },
+    {
+        type: 'prefix',
+        path: '/static/'
+    },
+    {
+        type: 'prefix',
+        path: '/upload/'
+    }
+];
+const stripTrailingSlash = (pathname)=>pathname.length > 1 ? pathname.replace(/\/+$/, '') : pathname;
+const matchesPathPrefix = (pathname, prefix)=>{
+    const normalizedPathname = (0, external_normalise_js_namespaceObject.normalisePathname)(pathname);
+    const normalizedPrefix = stripTrailingSlash((0, external_normalise_js_namespaceObject.normalisePathname)(prefix));
+    return normalizedPathname === normalizedPrefix || normalizedPathname.startsWith(`${normalizedPrefix}/`);
+};
+const matchesSkipRule = (pathname, rule)=>{
+    if ('exact' === rule.type) return (0, external_normalise_js_namespaceObject.normalisePathname)(pathname) === (0, external_normalise_js_namespaceObject.normalisePathname)(rule.path);
+    return matchesPathPrefix(pathname, rule.path);
+};
+const isDefaultLocaleRedirectSkipPath = (pathname, languages = [])=>{
+    const normalizedPathname = (0, external_normalise_js_namespaceObject.normalisePathname)(pathname);
+    const pathWithoutLanguage = (0, external_pathname_js_namespaceObject.stripLanguagePrefix)(normalizedPathname, languages);
+    return DEFAULT_LOCALE_REDIRECT_SKIP_RULES.some((rule)=>matchesSkipRule(pathWithoutLanguage, rule));
+};
+const shouldSkipLocaleRedirect = (pathname, languages = [], ignoreRedirectRoutes)=>{
+    const normalizedPathname = (0, external_normalise_js_namespaceObject.normalisePathname)(pathname);
+    const pathWithoutLanguage = (0, external_pathname_js_namespaceObject.stripLanguagePrefix)(normalizedPathname, languages);
+    if (isDefaultLocaleRedirectSkipPath(pathWithoutLanguage)) return true;
+    if (!ignoreRedirectRoutes) return false;
+    if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(pathWithoutLanguage);
+    return ignoreRedirectRoutes.some((pattern)=>matchesPathPrefix(pathWithoutLanguage, pattern));
+};
+exports.DEFAULT_LOCALE_REDIRECT_SKIP_RULES = __webpack_exports__.DEFAULT_LOCALE_REDIRECT_SKIP_RULES;
+exports.isDefaultLocaleRedirectSkipPath = __webpack_exports__.isDefaultLocaleRedirectSkipPath;
+exports.matchesPathPrefix = __webpack_exports__.matchesPathPrefix;
+exports.shouldSkipLocaleRedirect = __webpack_exports__.shouldSkipLocaleRedirect;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_LOCALE_REDIRECT_SKIP_RULES",
+    "isDefaultLocaleRedirectSkipPath",
+    "matchesPathPrefix",
+    "shouldSkipLocaleRedirect"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/shared/localisedUrls/resolve.js

@@ -33,53 +33,50 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const external_normalise_js_namespaceObject = require("./normalise.js");
 const external_patterns_js_namespaceObject = require("./patterns.js");
-const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>{
-    const normalizedPathname = (0, external_normalise_js_namespaceObject.normalisePathname)(pathname);
-    const canonicalCandidates = (0, external_patterns_js_namespaceObject.sortPatternsBySpecificity)(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
+const getCanonicalCandidates = (localisedUrls)=>(0, external_patterns_js_namespaceObject.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 = (0, external_patterns_js_namespaceObject.matchPathPattern)(normalizedPathname, canonicalPattern);
-        if (params) return (0, external_patterns_js_namespaceObject.buildPathFromPattern)(targetPattern, params);
-    }
-    const localisedCandidates = (0, external_patterns_js_namespaceObject.sortPatternsBySpecificity)(Object.values(localisedUrls).flatMap((localisedUrlEntry)=>{
-        const targetPattern = localisedUrlEntry[targetLanguage];
-        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 = (0, external_patterns_js_namespaceObject.matchPathPattern)(normalizedPathname, sourcePattern);
-        if (params) return (0, external_patterns_js_namespaceObject.buildPathFromPattern)(targetPattern, params);
-    }
-    return normalizedPathname;
-};
-const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>{
+const resolveLocalisedUrlPath = (pathname, languages, localisedUrls, options)=>{
     const normalizedPathname = (0, external_normalise_js_namespaceObject.normalisePathname)(pathname);
-    const canonicalCandidates = (0, external_patterns_js_namespaceObject.sortPatternsBySpecificity)(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
-            pattern: canonicalPattern,
-            canonicalPattern,
-            localisedUrlEntry
-        })));
+    const canonicalCandidates = getCanonicalCandidates(localisedUrls);
     for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
+        const targetPattern = 'localised' === options.mode ? localisedUrlEntry[options.targetLanguage] : canonicalPattern;
+        if (!targetPattern) continue;
         const canonicalParams = (0, external_patterns_js_namespaceObject.matchPathPattern)(normalizedPathname, canonicalPattern);
-        if (canonicalParams) return (0, external_patterns_js_namespaceObject.buildPathFromPattern)(canonicalPattern, canonicalParams);
-        for (const language of languages){
+        if (canonicalParams) return (0, external_patterns_js_namespaceObject.buildPathFromPattern)(targetPattern, canonicalParams);
+        if ('canonical' === options.mode) for (const language of languages){
             const sourcePattern = localisedUrlEntry[language];
             if (!sourcePattern) continue;
             const params = (0, external_patterns_js_namespaceObject.matchPathPattern)(normalizedPathname, sourcePattern);
             if (params) return (0, external_patterns_js_namespaceObject.buildPathFromPattern)(canonicalPattern, params);
         }
     }
+    if ('localised' === options.mode) {
+        const localisedCandidates = (0, external_patterns_js_namespaceObject.sortPatternsBySpecificity)(Object.values(localisedUrls).flatMap((localisedUrlEntry)=>{
+            const targetPattern = localisedUrlEntry[options.targetLanguage];
+            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 = (0, external_patterns_js_namespaceObject.matchPathPattern)(normalizedPathname, sourcePattern);
+            if (params) return (0, external_patterns_js_namespaceObject.buildPathFromPattern)(targetPattern, params);
+        }
+    }
     return normalizedPathname;
 };
+const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>resolveLocalisedUrlPath(pathname, languages, localisedUrls, {
+        mode: 'localised',
+        targetLanguage
+    });
+const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>resolveLocalisedUrlPath(pathname, languages, localisedUrls, {
+        mode: 'canonical'
+    });
 exports.resolveCanonicalLocalisedPath = __webpack_exports__.resolveCanonicalLocalisedPath;
 exports.resolveLocalisedPath = __webpack_exports__.resolveLocalisedPath;
 for(var __rspack_i in __webpack_exports__)if (-1 === [