@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.11 → 3.9.0-ultramodern.12

package/dist/esm/routerState.mjs

@@ -7,66 +7,52 @@ function getRouterRuntimeState(runtimeContext) {
 function getRouterServerSnapshot(runtimeContext) {
     return routerServerSnapshotExtension.get(runtimeContext);
 }
-function toHydrationScripts(state) {
-    if (state.hydrationScripts?.length) return state.hydrationScripts;
-    return state.hydrationScript ? [
-        state.hydrationScript
-    ] : void 0;
-}
-function getMatchedRouteIdsFromMatches(matches) {
-    const routeIds = matches?.map((match)=>match.assetRouteId ?? match.routeId).filter((routeId)=>'string' == typeof routeId);
-    return routeIds?.length ? routeIds : void 0;
-}
-function createRouterServerSnapshot(state) {
-    const hydrationScripts = toHydrationScripts(state);
-    const matchedRouteIds = state.matchedRouteIds ?? getMatchedRouteIdsFromMatches(state.matches);
-    return {
-        ...state,
-        ...hydrationScripts?.length ? {
-            hydrationScript: state.hydrationScript ?? hydrationScripts[0],
-            hydrationScripts
+function createRouterServerSnapshot(snapshot) {
+    const matches = snapshot.matches?.map((match)=>Object.freeze({
+            ...match,
+            ...match.params ? {
+                params: Object.freeze({
+                    ...match.params
+                })
+            } : {}
+        }));
+    const matchedRouteIds = snapshot.matchedRouteIds ?? matches?.map((match)=>match.assetRouteId ?? match.routeId);
+    return Object.freeze({
+        ...snapshot,
+        ...snapshot.hydrationScripts ? {
+            hydrationScripts: Object.freeze([
+                ...snapshot.hydrationScripts
+            ])
         } : {},
         ...matchedRouteIds ? {
-            matchedRouteIds
-        } : {}
-    };
-}
-function createRouterRuntimeState(state) {
-    const hasSnapshotState = Boolean(state.serverSnapshot) || Boolean(state.hydrationScript) || Boolean(state.hydrationScripts?.length) || Boolean(state.matchedRouteIds?.length) || Boolean(state.matches?.length);
-    const serverSnapshot = state.serverSnapshot ? createRouterServerSnapshot({
-        ...state.serverSnapshot,
-        framework: state.serverSnapshot.framework ?? state.framework,
-        basename: state.serverSnapshot.basename ?? state.basename,
-        hydrationScript: state.serverSnapshot.hydrationScript ?? state.hydrationScript,
-        hydrationScripts: state.serverSnapshot.hydrationScripts ?? state.hydrationScripts,
-        matchedRouteIds: state.serverSnapshot.matchedRouteIds ?? state.matchedRouteIds,
-        matches: state.serverSnapshot.matches ?? state.matches
-    }) : hasSnapshotState ? createRouterServerSnapshot({
-        framework: state.framework,
-        basename: state.basename,
-        hydrationScript: state.hydrationScript,
-        hydrationScripts: state.hydrationScripts,
-        matchedRouteIds: state.matchedRouteIds,
-        matches: state.matches
-    }) : void 0;
-    const hydrationScripts = toHydrationScripts({
-        hydrationScript: state.hydrationScript ?? serverSnapshot?.hydrationScript,
-        hydrationScripts: state.hydrationScripts ?? serverSnapshot?.hydrationScripts
-    });
-    const matchedRouteIds = state.matchedRouteIds ?? serverSnapshot?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(state.matches);
-    return {
-        ...state,
-        ...hydrationScripts?.length ? {
-            hydrationScript: state.hydrationScript ?? hydrationScripts[0],
-            hydrationScripts
+            matchedRouteIds: Object.freeze([
+                ...matchedRouteIds
+            ])
         } : {},
-        ...matchedRouteIds ? {
-            matchedRouteIds
+        ...matches ? {
+            matches: Object.freeze(matches)
+        } : {},
+        ...snapshot.errors ? {
+            errors: Object.freeze({
+                ...snapshot.errors
+            })
         } : {},
-        ...serverSnapshot ? {
-            serverSnapshot
+        ...snapshot.routerData ? {
+            routerData: Object.freeze({
+                ...snapshot.routerData,
+                ...snapshot.routerData.loaderData ? {
+                    loaderData: Object.freeze({
+                        ...snapshot.routerData.loaderData
+                    })
+                } : {},
+                ...snapshot.routerData.errors ? {
+                    errors: Object.freeze({
+                        ...snapshot.routerData.errors
+                    })
+                } : {}
+            })
         } : {}
-    };
+    });
 }
 const routerRuntimeStateListeners = new WeakMap();
 function subscribeRouterRuntimeState(runtimeContext, listener) {
@@ -102,38 +88,26 @@ function notifyRouterRuntimeState(runtimeContext) {
 }
 function applyRouterRuntimeState(runtimeContext, state) {
     const previous = routerRuntimeStateExtension.get(runtimeContext);
-    const normalized = createRouterRuntimeState(state);
-    routerRuntimeStateExtension.set(runtimeContext, normalized);
-    if (normalized.serverSnapshot) routerServerSnapshotExtension.set(runtimeContext, normalized.serverSnapshot);
-    if (previous?.instance !== normalized.instance || previous?.framework !== normalized.framework) notifyRouterRuntimeState(runtimeContext);
+    routerRuntimeStateExtension.set(runtimeContext, state);
+    if (previous?.instance !== state.instance || previous?.framework !== state.framework || previous?.navigation !== state.navigation) notifyRouterRuntimeState(runtimeContext);
     return runtimeContext;
 }
 function applyRouterServerPrepareResult(runtimeContext, result) {
-    const state = createRouterRuntimeState({
+    if (result.snapshot) routerServerSnapshotExtension.set(runtimeContext, createRouterServerSnapshot(result.snapshot));
+    return applyRouterRuntimeState(runtimeContext, {
         ...result.state,
-        cleanup: result.cleanup ?? result.state.cleanup,
-        serverSnapshot: result.snapshot ?? result.state.serverSnapshot
+        cleanup: result.cleanup ?? result.state.cleanup
     });
-    applyRouterRuntimeState(runtimeContext, state);
-    return runtimeContext;
 }
 function getRouterHydrationScripts(runtimeContext) {
-    const serverSnapshot = getRouterServerSnapshot(runtimeContext);
-    const runtimeState = getRouterRuntimeState(runtimeContext);
-    return serverSnapshot?.hydrationScripts ?? toHydrationScripts({
-        hydrationScript: serverSnapshot?.hydrationScript
-    }) ?? runtimeState?.hydrationScripts ?? toHydrationScripts({
-        hydrationScript: runtimeState?.hydrationScript
-    }) ?? [];
+    return getRouterServerSnapshot(runtimeContext)?.hydrationScripts ?? [];
 }
 function getRouterMatchedRouteIds(runtimeContext) {
-    const serverSnapshot = getRouterServerSnapshot(runtimeContext);
-    const runtimeState = getRouterRuntimeState(runtimeContext);
-    return serverSnapshot?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(serverSnapshot?.matches) ?? runtimeState?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(runtimeState?.matches);
+    return getRouterServerSnapshot(runtimeContext)?.matchedRouteIds;
 }
 async function cleanupRouterRuntimeState(runtimeContext) {
     try {
         await getRouterRuntimeState(runtimeContext)?.cleanup?.();
     } catch  {}
 }
-export { applyRouterRuntimeState, applyRouterServerPrepareResult, cleanupRouterRuntimeState, createRouterRuntimeState, createRouterServerSnapshot, getRouterHydrationScripts, getRouterMatchedRouteIds, getRouterRuntimeState, getRouterServerSnapshot, subscribeRouterRuntimeState };
+export { applyRouterRuntimeState, applyRouterServerPrepareResult, cleanupRouterRuntimeState, createRouterServerSnapshot, getRouterHydrationScripts, getRouterMatchedRouteIds, getRouterRuntimeState, getRouterServerSnapshot, subscribeRouterRuntimeState };

package/dist/esm/routerStatePlugin.mjs

@@ -1,5 +1,24 @@
 import { createRouterPrefetchPolicy } from "./routerPrefetchPolicy.mjs";
-import { applyRouterRuntimeState, createRouterServerSnapshot } from "./routerState.mjs";
+import { applyRouterRuntimeState, applyRouterServerPrepareResult } from "./routerState.mjs";
+function createReactRouterNavigation(router, Link) {
+    let state;
+    let snapshot;
+    return {
+        Link,
+        getSnapshot () {
+            if (state !== router.state) {
+                state = router.state;
+                snapshot = {
+                    location: state.location,
+                    params: Object.assign({}, ...state.matches.map((match)=>match.params))
+                };
+            }
+            return snapshot;
+        },
+        subscribe: (listener)=>router.subscribe(listener),
+        navigate: (href, options)=>router.navigate(href, options)
+    };
+}
 function createRouterStatePlugin({ registryHooks }) {
     return {
         name: '@modern-js/router-runtime-policy',
@@ -14,7 +33,7 @@ function createRouterStatePlugin({ registryHooks }) {
                 if ('ssr-prepare' === event.phase) {
                     const { routerContext } = event.runtimeContext;
                     if (!routerContext) return;
-                    const serverSnapshot = createRouterServerSnapshot({
+                    const snapshot = {
                         framework: event.framework,
                         basename: event.basename,
                         statusCode: routerContext.statusCode,
@@ -28,19 +47,27 @@ function createRouterStatePlugin({ registryHooks }) {
                                     routeId: match.route.id
                                 }
                             ] : [])
+                    };
+                    applyRouterServerPrepareResult(event.runtimeContext, {
+                        snapshot,
+                        state: {
+                            framework: event.framework,
+                            basename: event.basename,
+                            instance: event.router
+                        }
                     });
+                } else if ('client-create' === event.phase) {
+                    const router = event.router;
+                    const { router: api } = event.runtimeContext;
                     applyRouterRuntimeState(event.runtimeContext, {
                         framework: event.framework,
                         basename: event.basename,
-                        instance: event.router,
-                        matchedRouteIds: serverSnapshot.matchedRouteIds,
-                        serverSnapshot
+                        instance: router,
+                        ...api?.Link ? {
+                            navigation: createReactRouterNavigation(router, api.Link)
+                        } : {}
                     });
-                } else if ('client-create' === event.phase) applyRouterRuntimeState(event.runtimeContext, {
-                    framework: event.framework,
-                    basename: event.basename,
-                    instance: event.router
-                });
+                }
             });
         }
     };

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

@@ -0,0 +1,12 @@
+import "node:module";
+const resolveLocalisedUrlsConfig = (option)=>{
+    if (option && 'object' == typeof option && Object.keys(option).length > 0) return {
+        enabled: true,
+        map: option
+    };
+    return {
+        enabled: false,
+        map: {}
+    };
+};
+export { resolveLocalisedUrlsConfig };

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

@@ -0,0 +1,9 @@
+import "node:module";
+export { resolveLocalisedUrlsConfig } from "./config.mjs";
+export { normalisePathPattern, normalisePathname } from "./normalise.mjs";
+export { canonicalTargetPathname, localiseTargetPathname, stripLanguagePrefix } from "./pathname.mjs";
+export { buildPathFromPattern, matchPathPattern } from "./patterns.mjs";
+export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, matchesPathPrefix, shouldSkipLocaleRedirect } from "./redirect.mjs";
+export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from "./resolve.mjs";
+export { createLocalisedRouteRewrite } from "./routeIdentity.mjs";
+export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from "./routes.mjs";

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

@@ -0,0 +1,38 @@
+import "node:module";
+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] || '');
+};
+export { getLeadingLocaleParam, normalisePathPattern, normalisePathname, normaliseRoutePath, stripLeadingLocaleParam };

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

@@ -0,0 +1,25 @@
+import "node:module";
+import { resolveLocalisedUrlsConfig } from "./config.mjs";
+import { resolveCanonicalLocalisedPath, resolveLocalisedPath } from "./resolve.mjs";
+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 = 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 { canonicalTargetPathname, localiseTargetPathname, stripLanguagePrefix };

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

@@ -0,0 +1,153 @@
+import "node:module";
+import { normalisePathPattern, normalisePathname } from "./normalise.mjs";
+const escapeRegExp = (value)=>value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const getParamName = (segment)=>segment.slice(1).replace(/\?$/, '');
+const getOrderedPathParamSignature = (pattern)=>normalisePathPattern(pattern).split('/').filter(Boolean).flatMap((segment)=>{
+        if ('*' === segment) return [
+            '*'
+        ];
+        if (!segment.startsWith(':')) return [];
+        return [
+            `:${getParamName(segment)}${segment.endsWith('?') ? '?' : ''}`
+        ];
+    });
+const getPathParamSignature = (pattern)=>getOrderedPathParamSignature(pattern).sort((left, right)=>left < right ? -1 : left > right ? 1 : 0);
+const getPathPatternValidationIssue = (pattern)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const seenParams = new Set();
+    for (const [index, segment] of segments.entries()){
+        if ('*' === segment) {
+            if (index !== segments.length - 1) return 'splat parameter "*" must be the final segment';
+            if (seenParams.has('*')) return 'duplicate splat parameter "*"';
+            seenParams.add('*');
+            continue;
+        }
+        if (!segment.startsWith(':')) continue;
+        const paramName = getParamName(segment);
+        if (seenParams.has(paramName)) return `duplicate path parameter ":${paramName}"`;
+        seenParams.add(paramName);
+    }
+};
+const getPhysicalPathPattern = (pattern)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const physicalSegments = segments.map((segment)=>{
+        if ('*' === segment) return '*';
+        if (segment.startsWith(':')) return segment.endsWith('?') ? ':param?' : ':param';
+        return segment;
+    });
+    return `/${physicalSegments.join('/')}`;
+};
+const compiledPathPatternCache = new Map();
+const compilePathPattern = (pattern)=>{
+    const normalizedPattern = 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 = normalisePathPattern(pattern).split('/').filter(Boolean);
+    let staticSegments = 0;
+    let dynamicSegments = 0;
+    let optionalSegments = 0;
+    let splatSegments = 0;
+    for (const segment of segments)if ('*' === segment) splatSegments++;
+    else if (segment.startsWith(':')) {
+        dynamicSegments++;
+        if (segment.endsWith('?')) optionalSegments++;
+    } else staticSegments++;
+    return {
+        staticSegments,
+        dynamicSegments,
+        optionalSegments,
+        splatSegments,
+        totalSegments: segments.length
+    };
+};
+const comparePatternSpecificity = (left, right)=>{
+    const a = getPatternSpecificity(left);
+    const b = getPatternSpecificity(right);
+    return b.staticSegments - a.staticSegments || a.splatSegments - b.splatSegments || a.optionalSegments - b.optionalSegments || b.totalSegments - a.totalSegments || a.dynamicSegments - b.dynamicSegments;
+};
+const haveEqualPatternSpecificity = (left, right)=>0 === comparePatternSpecificity(left, right);
+const doPathPatternsOverlap = (left, right)=>{
+    const leftSegments = normalisePathPattern(left).split('/').filter(Boolean);
+    const rightSegments = normalisePathPattern(right).split('/').filter(Boolean);
+    if (leftSegments.length !== rightSegments.length) return false;
+    return leftSegments.every((leftSegment, index)=>{
+        const rightSegment = rightSegments[index];
+        const leftIsDynamic = '*' === leftSegment || leftSegment.startsWith(':');
+        const rightIsDynamic = '*' === rightSegment || rightSegment.startsWith(':');
+        return leftIsDynamic || rightIsDynamic || leftSegment === rightSegment;
+    });
+};
+const comparePatternNames = (left, right)=>{
+    const normalizedLeft = normalisePathPattern(left);
+    const normalizedRight = normalisePathPattern(right);
+    return normalizedLeft < normalizedRight ? -1 : normalizedLeft > normalizedRight ? 1 : 0;
+};
+const sortPatternsBySpecificity = (patterns)=>patterns.map((pattern, index)=>({
+            pattern,
+            index
+        })).sort((left, right)=>comparePatternSpecificity(left.pattern.pattern, right.pattern.pattern) || comparePatternNames(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(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;
+        Object.defineProperty(params, names[index], {
+            configurable: true,
+            enumerable: true,
+            value: decoded,
+            writable: true
+        });
+    }
+    return params;
+};
+const buildPathFromPattern = (pattern, params)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const path = segments.map((segment)=>{
+        if (segment.startsWith(':')) {
+            const paramName = getParamName(segment);
+            const param = Object.hasOwn(params, paramName) ? params[paramName] : void 0;
+            if (void 0 === param || '' === param) {
+                if (segment.endsWith('?')) return '';
+                throw new Error(`Missing required path parameter "${paramName}" for pattern "${normalisePathPattern(pattern)}".`);
+            }
+            return encodeURIComponent(param);
+        }
+        if ('*' === segment) return encodeSplatParam(params['*'] || '');
+        return segment;
+    }).filter(Boolean).join('/');
+    return `/${path}`;
+};
+export { buildPathFromPattern, doPathPatternsOverlap, getOrderedPathParamSignature, getPathParamSignature, getPathPatternValidationIssue, getPhysicalPathPattern, haveEqualPatternSpecificity, matchPathPattern, sortPatternsBySpecificity };

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

@@ -0,0 +1,54 @@
+import "node:module";
+import { normalisePathname } from "./normalise.mjs";
+import { stripLanguagePrefix } from "./pathname.mjs";
+const DEFAULT_LOCALE_REDIRECT_SKIP_RULES = [
+    {
+        type: 'exact',
+        path: '/backend-mf-manifest.json'
+    },
+    {
+        type: 'exact',
+        path: '/mf-manifest.json'
+    },
+    {
+        type: 'exact',
+        path: '/mf-stats.json'
+    },
+    {
+        type: 'pattern',
+        path: /^\/(?:backendRemoteEntry(?:\.[a-zA-Z0-9_-]+)?\.cjs|remoteEntry(?:\.[a-zA-Z0-9_-]+)?\.js)$/
+    },
+    {
+        type: 'prefix',
+        path: '/static/'
+    },
+    {
+        type: 'prefix',
+        path: '/upload/'
+    }
+];
+const stripTrailingSlash = (pathname)=>pathname.length > 1 ? pathname.replace(/\/+$/, '') : pathname;
+const matchesPathPrefix = (pathname, prefix)=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const normalizedPrefix = stripTrailingSlash(normalisePathname(prefix));
+    return normalizedPathname === normalizedPrefix || normalizedPathname.startsWith(`${normalizedPrefix}/`);
+};
+const matchesSkipRule = (pathname, rule)=>{
+    if ('exact' === rule.type) return normalisePathname(pathname) === normalisePathname(rule.path);
+    if ('pattern' === rule.type) return rule.path.test(normalisePathname(pathname));
+    return matchesPathPrefix(pathname, rule.path);
+};
+const isDefaultLocaleRedirectSkipPath = (pathname, languages = [])=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const pathWithoutLanguage = stripLanguagePrefix(normalizedPathname, languages);
+    return DEFAULT_LOCALE_REDIRECT_SKIP_RULES.some((rule)=>matchesSkipRule(pathWithoutLanguage, rule));
+};
+const shouldSkipLocaleRedirect = (pathname, languages = [], ignoreRedirectRoutes)=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const pathWithoutLanguage = 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));
+};
+export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, matchesPathPrefix, shouldSkipLocaleRedirect };

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

@@ -0,0 +1,38 @@
+import "node:module";
+import { normalisePathname } from "./normalise.mjs";
+import { buildPathFromPattern, matchPathPattern, sortPatternsBySpecificity } from "./patterns.mjs";
+const getCanonicalCandidates = (localisedUrls)=>sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
+            pattern: canonicalPattern,
+            canonicalPattern,
+            localisedUrlEntry
+        })));
+const resolveLocalisedUrlPath = (pathname, languages, localisedUrls, options)=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const canonicalCandidates = getCanonicalCandidates(localisedUrls);
+    const candidates = sortPatternsBySpecificity(canonicalCandidates.flatMap(({ canonicalPattern, localisedUrlEntry })=>{
+        const targetPattern = 'localised' === options.mode ? localisedUrlEntry[options.targetLanguage] : canonicalPattern;
+        if (!targetPattern) return [];
+        const sourcePatterns = new Set([
+            canonicalPattern,
+            ...languages.map((language)=>localisedUrlEntry[language]).filter((sourcePattern)=>Boolean(sourcePattern))
+        ]);
+        return Array.from(sourcePatterns, (sourcePattern)=>({
+                pattern: sourcePattern,
+                sourcePattern,
+                targetPattern
+            }));
+    }));
+    for (const { sourcePattern, targetPattern } of candidates){
+        const params = matchPathPattern(normalizedPathname, sourcePattern);
+        if (params) return 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'
+    });
+export { resolveCanonicalLocalisedPath, resolveLocalisedPath };

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

@@ -0,0 +1,55 @@
+import "node:module";
+import { normalisePathPattern } from "./normalise.mjs";
+import { buildPathFromPattern, matchPathPattern } from "./patterns.mjs";
+function rewritePath(url, mappings) {
+    for (const { from, to } of mappings){
+        const params = matchPathPattern(url.pathname, from);
+        if (params) {
+            url.pathname = buildPathFromPattern(to, params);
+            break;
+        }
+    }
+    return url;
+}
+function createLocalisedRouteRewrite(routes) {
+    const input = [];
+    const output = [];
+    const visit = (nodes, parent)=>{
+        for (const route of nodes){
+            const fullPath = normalisePathPattern(`${parent}/${route.path ?? ''}`);
+            const identity = route.modernLocalisedRoute;
+            if (identity?.paths && fullPath.endsWith(identity.canonicalPath)) {
+                const prefix = fullPath.slice(0, -identity.canonicalPath.length);
+                const hasLocale = prefix.split('/').some((segment)=>/^:(?:lang|locale|language)\??$/.test(segment));
+                for (const [language, localisedPath] of Object.entries(identity.paths)){
+                    const localePrefix = prefix.split('/').map((segment)=>/^:(?:lang|locale|language)\??$/.test(segment) ? language : segment).join('/');
+                    const canonical = normalisePathPattern(`${localePrefix}/${identity.canonicalPath}`);
+                    const localised = normalisePathPattern(`${localePrefix}/${localisedPath}`);
+                    if (canonical !== localised) {
+                        input.push({
+                            from: localised,
+                            to: canonical
+                        });
+                        if (hasLocale) output.push({
+                            from: canonical,
+                            to: localised
+                        });
+                    }
+                }
+            }
+            if (route.children) visit(route.children, fullPath);
+        }
+    };
+    visit(routes, '');
+    if (0 === input.length) return;
+    const specificity = (pattern)=>pattern.split('/').filter((segment)=>segment && !segment.startsWith(':') && '*' !== segment).length;
+    for (const mappings of [
+        input,
+        output
+    ])mappings.sort((a, b)=>specificity(b.from) - specificity(a.from));
+    return {
+        input: ({ url })=>rewritePath(url, input),
+        output: ({ url })=>rewritePath(url, output)
+    };
+}
+export { createLocalisedRouteRewrite };