@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.9 → 3.5.0-ultramodern.91

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

@@ -0,0 +1,87 @@
+"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__);
+const LOCALE_PARAM_NAMES = new Set([
+    'lang',
+    'locale',
+    'language'
+]);
+const normaliseSlashes = (path)=>{
+    const withoutDuplicateSlashes = path.replace(/\/+/g, '/');
+    const withLeadingSlash = withoutDuplicateSlashes.startsWith('/') ? withoutDuplicateSlashes : `/${withoutDuplicateSlashes}`;
+    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);
+};
+const getLocaleParamSegment = (segment)=>{
+    if (!segment.startsWith(':')) return null;
+    const paramName = segment.slice(1).replace(/\?$/, '');
+    return LOCALE_PARAM_NAMES.has(paramName) ? segment : null;
+};
+const splitPathSegments = (path)=>{
+    if (!path) return [];
+    return normalisePathPattern(path).split('/').filter(Boolean);
+};
+const stripLeadingLocaleParam = (path)=>{
+    const segments = splitPathSegments(path);
+    const leadingLocaleParam = getLocaleParamSegment(segments[0] || '');
+    if (!leadingLocaleParam) return path;
+    const remainingPath = segments.slice(1).join('/');
+    return remainingPath ? `/${remainingPath}` : void 0;
+};
+const getLeadingLocaleParam = (path)=>{
+    const segments = splitPathSegments(path);
+    return getLocaleParamSegment(segments[0] || '');
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    getLeadingLocaleParam: getLeadingLocaleParam,
+    normalisePathPattern: normalisePathPattern,
+    normalisePathname: normalisePathname,
+    normaliseRoutePath: normaliseRoutePath,
+    stripLeadingLocaleParam: stripLeadingLocaleParam
+});
+exports.getLeadingLocaleParam = __webpack_exports__.getLeadingLocaleParam;
+exports.normalisePathPattern = __webpack_exports__.normalisePathPattern;
+exports.normalisePathname = __webpack_exports__.normalisePathname;
+exports.normaliseRoutePath = __webpack_exports__.normaliseRoutePath;
+exports.stripLeadingLocaleParam = __webpack_exports__.stripLeadingLocaleParam;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getLeadingLocaleParam",
+    "normalisePathPattern",
+    "normalisePathname",
+    "normaliseRoutePath",
+    "stripLeadingLocaleParam"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,68 @@
+"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__, {
+    canonicalTargetPathname: ()=>canonicalTargetPathname,
+    localiseTargetPathname: ()=>localiseTargetPathname,
+    stripLanguagePrefix: ()=>stripLanguagePrefix
+});
+const external_config_js_namespaceObject = require("./config.js");
+const external_resolve_js_namespaceObject = require("./resolve.js");
+const stripLanguagePrefix = (pathname, languages)=>{
+    const segments = pathname.split('/').filter(Boolean);
+    const firstSegment = segments[0]?.toLowerCase();
+    if (firstSegment && languages.some((language)=>language.toLowerCase() === firstSegment)) return `/${segments.slice(1).join('/')}`;
+    return pathname || '/';
+};
+const localiseTargetPathname = (pathname, language, languages, localisedUrls)=>{
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    const localisedUrlsConfig = (0, external_config_js_namespaceObject.resolveLocalisedUrlsConfig)(localisedUrls);
+    const resolvedPath = localisedUrlsConfig.enabled ? (0, external_resolve_js_namespaceObject.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 = (0, external_config_js_namespaceObject.resolveLocalisedUrlsConfig)(localisedUrls);
+    return localisedUrlsConfig.enabled ? (0, external_resolve_js_namespaceObject.resolveCanonicalLocalisedPath)(pathWithoutLanguage, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+};
+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",
+    "stripLanguagePrefix"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,130 @@
+"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__, {
+    buildPathFromPattern: ()=>buildPathFromPattern,
+    matchPathPattern: ()=>matchPathPattern,
+    sortPatternsBySpecificity: ()=>sortPatternsBySpecificity
+});
+const external_normalise_js_namespaceObject = require("./normalise.js");
+const escapeRegExp = (value)=>value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const getParamName = (segment)=>segment.slice(1).replace(/\?$/, '');
+const compiledPathPatternCache = new Map();
+const compilePathPattern = (pattern)=>{
+    const normalizedPattern = (0, external_normalise_js_namespaceObject.normalisePathPattern)(pattern);
+    const cached = compiledPathPatternCache.get(normalizedPattern);
+    if (cached) return cached;
+    const names = [];
+    const segments = normalizedPattern.split('/').filter(Boolean);
+    const source = segments.map((segment)=>{
+        if (segment.startsWith(':')) {
+            names.push(getParamName(segment));
+            const paramPattern = '([^/]+)';
+            return segment.endsWith('?') ? `(?:/${paramPattern})?` : `/${paramPattern}`;
+        }
+        if ('*' === segment) {
+            names.push('*');
+            return '/(.*)';
+        }
+        return `/${escapeRegExp(segment)}`;
+    }).join('');
+    const compiled = {
+        names,
+        regexp: new RegExp(`^${source || '/'}$`)
+    };
+    compiledPathPatternCache.set(normalizedPattern, compiled);
+    return compiled;
+};
+const getPatternSpecificity = (pattern)=>{
+    const segments = (0, external_normalise_js_namespaceObject.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 encodeSplatParam = (value)=>value.split('/').map(encodeURIComponent).join('/');
+const matchPathPattern = (pathname, pattern)=>{
+    const { names, regexp } = compilePathPattern(pattern);
+    const match = regexp.exec((0, external_normalise_js_namespaceObject.normalisePathname)(pathname));
+    if (!match) return null;
+    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 = (0, external_normalise_js_namespaceObject.normalisePathPattern)(pattern).split('/').filter(Boolean);
+    const path = segments.map((segment)=>{
+        if (segment.startsWith(':')) {
+            const param = params[getParamName(segment)];
+            return param ? encodeURIComponent(param) : '';
+        }
+        if ('*' === segment) return encodeSplatParam(params['*'] || '');
+        return segment;
+    }).filter(Boolean).join('/');
+    return `/${path}`;
+};
+exports.buildPathFromPattern = __webpack_exports__.buildPathFromPattern;
+exports.matchPathPattern = __webpack_exports__.matchPathPattern;
+exports.sortPatternsBySpecificity = __webpack_exports__.sortPatternsBySpecificity;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildPathFromPattern",
+    "matchPathPattern",
+    "sortPatternsBySpecificity"
+].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,103 @@
+"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: '/backend-mf-manifest.json'
+    },
+    {
+        type: 'exact',
+        path: '/backendRemoteEntry.cjs'
+    },
+    {
+        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

@@ -0,0 +1,88 @@
+"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__, {
+    resolveCanonicalLocalisedPath: ()=>resolveCanonicalLocalisedPath,
+    resolveLocalisedPath: ()=>resolveLocalisedPath
+});
+const external_normalise_js_namespaceObject = require("./normalise.js");
+const external_patterns_js_namespaceObject = require("./patterns.js");
+const getCanonicalCandidates = (localisedUrls)=>(0, external_patterns_js_namespaceObject.sortPatternsBySpecificity)(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
+            pattern: canonicalPattern,
+            canonicalPattern,
+            localisedUrlEntry
+        })));
+const resolveLocalisedUrlPath = (pathname, languages, localisedUrls, options)=>{
+    const normalizedPathname = (0, external_normalise_js_namespaceObject.normalisePathname)(pathname);
+    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)(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 === [
+    "resolveCanonicalLocalisedPath",
+    "resolveLocalisedPath"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,130 @@
+"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__, {
+    applyLocalisedUrlsToRoutes: ()=>applyLocalisedUrlsToRoutes,
+    validateLocalisedUrls: ()=>validateLocalisedUrls
+});
+const external_normalise_js_namespaceObject = require("./normalise.js");
+const isLocalisableRoutePath = (path)=>{
+    const pathWithoutLocale = (0, external_normalise_js_namespaceObject.stripLeadingLocaleParam)(path);
+    if (!pathWithoutLocale || '/' === pathWithoutLocale || '*' === pathWithoutLocale) return false;
+    return true;
+};
+const joinPath = (parentPath, routePath)=>{
+    if (!isLocalisableRoutePath(routePath)) return parentPath;
+    const segment = (0, external_normalise_js_namespaceObject.normaliseRoutePath)((0, external_normalise_js_namespaceObject.stripLeadingLocaleParam)(routePath) || '');
+    return (0, external_normalise_js_namespaceObject.normalisePathPattern)(`${parentPath}/${segment}`);
+};
+const isFrameworkInternalRoutePath = (canonicalPath)=>'/_mf' === canonicalPath || canonicalPath.startsWith('/_mf/');
+const ensureLocalisedUrlsForPath = (canonicalPath, languages, localisedUrls)=>{
+    const entry = localisedUrls[canonicalPath];
+    if (!entry) throw new Error(`localisedUrls is enabled, but route "${canonicalPath}" does not define localised URLs for languages: ${languages.join(', ')}. Add localisedUrls["${canonicalPath}"] or set localeDetection.localisedUrls to false.`);
+    const missingLanguages = languages.filter((language)=>!entry[language]);
+    if (missingLanguages.length > 0) throw new Error(`localisedUrls["${canonicalPath}"] is missing languages: ${missingLanguages.join(', ')}. Every configured language must have a localised URL.`);
+    return entry;
+};
+const validateLocalisedUrls = (routes, languages, localisedUrls)=>{
+    const visit = (route, parentPath)=>{
+        const canonicalPath = joinPath(parentPath, route.path);
+        if (isLocalisableRoutePath(route.path) && !isFrameworkInternalRoutePath(canonicalPath)) ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls);
+        if ('children' in route && route.children) route.children.forEach((child)=>visit(child, canonicalPath));
+    };
+    routes.forEach((route)=>visit(route, ''));
+};
+const getLocalisedRoutePaths = (canonicalPath, parentLocalisedPaths, languages, entry)=>{
+    const paths = languages.map((language)=>{
+        const fullPath = (0, external_normalise_js_namespaceObject.normalisePathPattern)(entry[language]);
+        const parentPath = (0, external_normalise_js_namespaceObject.normalisePathPattern)(parentLocalisedPaths[language] || '/');
+        if ('/' === parentPath) return (0, external_normalise_js_namespaceObject.normaliseRoutePath)(fullPath) || void 0;
+        const parentPrefix = `${parentPath}/`;
+        if (!fullPath.startsWith(parentPrefix)) throw new Error(`localisedUrls["${canonicalPath}"].${language} must be nested under "${parentPath}" because its parent route is localised there.`);
+        return (0, external_normalise_js_namespaceObject.normaliseRoutePath)(fullPath.slice(parentPath.length));
+    });
+    return Array.from(new Set(paths.filter(Boolean)));
+};
+const transformLocalisedRoute = (route, parentCanonicalPath, parentLocalisedPaths, languages, localisedUrls)=>{
+    const canonicalPath = joinPath(parentCanonicalPath, route.path);
+    const localisedUrlEntry = isLocalisableRoutePath(route.path) && !isFrameworkInternalRoutePath(canonicalPath) ? ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls) : void 0;
+    const routeLocalisedPaths = localisedUrlEntry ? languages.reduce((acc, language)=>{
+        acc[language] = (0, external_normalise_js_namespaceObject.normalisePathPattern)(localisedUrlEntry[language]);
+        return acc;
+    }, {}) : parentLocalisedPaths;
+    const children = 'children' in route && route.children ? route.children.flatMap((child)=>transformLocalisedRoute(child, canonicalPath, routeLocalisedPaths, languages, localisedUrls)) : void 0;
+    const baseRoute = {
+        ...route,
+        ...children ? {
+            children
+        } : {}
+    };
+    if (!localisedUrlEntry) return [
+        baseRoute
+    ];
+    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)=>{
+    const children = 'children' in route && route.children ? route.children.map((child)=>suffixRouteIds(child, suffix)) : void 0;
+    return {
+        ...route,
+        ...route.id ? {
+            id: `${route.id}__localised_${suffix}`
+        } : {},
+        ...children ? {
+            children
+        } : {}
+    };
+};
+const cloneRouteWithLocalisedPath = (route, path, index, canonicalPath)=>{
+    const leadingLocaleParam = (0, external_normalise_js_namespaceObject.getLeadingLocaleParam)(route.path);
+    const localisedPath = leadingLocaleParam ? (0, external_normalise_js_namespaceObject.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)=>{
+    const rootLocalisedPaths = languages.reduce((acc, language)=>{
+        acc[language] = '/';
+        return acc;
+    }, {});
+    validateLocalisedUrls(routes, languages, localisedUrls);
+    return routes.flatMap((route)=>transformLocalisedRoute(route, '', rootLocalisedPaths, languages, localisedUrls));
+};
+exports.applyLocalisedUrlsToRoutes = __webpack_exports__.applyLocalisedUrlsToRoutes;
+exports.validateLocalisedUrls = __webpack_exports__.validateLocalisedUrls;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "applyLocalisedUrlsToRoutes",
+    "validateLocalisedUrls"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});