@bleedingdev/modern-js-i18n-runtime-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.21

package/dist/esm/localisedUrls/redirect.mjs

@@ -1,56 +0,0 @@
-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: '/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 = 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);
-    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/localisedUrls/resolve.mjs

@@ -1,37 +0,0 @@
-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/localisedUrls/routes.mjs

@@ -1,161 +0,0 @@
-import { getLeadingLocaleParam, normalisePathPattern, normaliseRoutePath, stripLeadingLocaleParam } from "./normalise.mjs";
-import { doPathPatternsOverlap, getOrderedPathParamSignature, getPathParamSignature, getPathPatternValidationIssue, getPhysicalPathPattern, haveEqualPatternSpecificity } from "./patterns.mjs";
-const isLocalisableRoutePath = (path)=>{
-    const pathWithoutLocale = stripLeadingLocaleParam(path);
-    if (!pathWithoutLocale || '/' === pathWithoutLocale || '*' === pathWithoutLocale) return false;
-    return true;
-};
-const joinPath = (parentPath, routePath)=>{
-    if (!isLocalisableRoutePath(routePath)) return parentPath;
-    const segment = normaliseRoutePath(stripLeadingLocaleParam(routePath) || '');
-    return normalisePathPattern(`${parentPath}/${segment}`);
-};
-const isFrameworkInternalRoutePath = (canonicalPath)=>'/_mf' === canonicalPath || canonicalPath.startsWith('/_mf/');
-const legalRouteIdPart = (value)=>value.replace(/[^a-zA-Z0-9_$-]+/g, '_').replace(/^_+|_+$/g, '') || 'index';
-const formatParamSignature = (signature)=>signature.length > 0 ? signature.join(', ') : '(none)';
-const validateLocalisedUrlPatterns = (languages, localisedUrls)=>{
-    const physicalPatterns = new Map();
-    const claimedPatterns = [];
-    const claimPhysicalPattern = (sourcePattern, canonicalPath, source)=>{
-        const physicalPattern = getPhysicalPathPattern(sourcePattern);
-        const existing = physicalPatterns.get(physicalPattern);
-        if (existing && existing.canonicalPath !== canonicalPath) throw new Error(`localisedUrls["${existing.canonicalPath}"] ${existing.source} and localisedUrls["${canonicalPath}"] ${source} generate the same physical route pattern "${physicalPattern}". Localised route patterns must identify exactly one canonical route.`);
-        const overlapping = claimedPatterns.find((claimed)=>claimed.canonicalPath !== canonicalPath && haveEqualPatternSpecificity(claimed.pattern, sourcePattern) && doPathPatternsOverlap(claimed.pattern, sourcePattern));
-        if (overlapping) throw new Error(`localisedUrls["${overlapping.canonicalPath}"] ${overlapping.source} pattern "${overlapping.pattern}" and localisedUrls["${canonicalPath}"] ${source} pattern "${sourcePattern}" are equal-specificity overlapping route patterns. Localised route patterns must identify exactly one canonical route.`);
-        physicalPatterns.set(physicalPattern, {
-            canonicalPath,
-            source
-        });
-        claimedPatterns.push({
-            canonicalPath,
-            pattern: sourcePattern,
-            source
-        });
-    };
-    for (const [canonicalPath, entry] of Object.entries(localisedUrls).sort(([left], [right])=>left < right ? -1 : left > right ? 1 : 0)){
-        const canonicalIssue = getPathPatternValidationIssue(canonicalPath);
-        if (canonicalIssue) throw new Error(`localisedUrls["${canonicalPath}"] canonical pattern has ${canonicalIssue}.`);
-        const expectedSignature = getPathParamSignature(canonicalPath);
-        const expectedOrderedSignature = getOrderedPathParamSignature(canonicalPath);
-        claimPhysicalPattern(canonicalPath, canonicalPath, 'canonical pattern');
-        for (const language of languages){
-            const localisedPattern = entry[language];
-            if (!localisedPattern) continue;
-            const localisedIssue = getPathPatternValidationIssue(localisedPattern);
-            if (localisedIssue) throw new Error(`localisedUrls["${canonicalPath}"].${language} has ${localisedIssue}.`);
-            const actualSignature = getPathParamSignature(localisedPattern);
-            if (actualSignature.length !== expectedSignature.length || actualSignature.some((parameter, index)=>parameter !== expectedSignature[index])) throw new Error(`localisedUrls["${canonicalPath}"].${language} must use the same parameter signature as "${canonicalPath}": expected ${formatParamSignature(expectedSignature)}; received ${formatParamSignature(actualSignature)}.`);
-            const actualOrderedSignature = getOrderedPathParamSignature(localisedPattern);
-            if (expectedOrderedSignature.some((parameter)=>'*' === parameter || parameter.endsWith('?')) && actualOrderedSignature.some((parameter, index)=>parameter !== expectedOrderedSignature[index])) throw new Error(`localisedUrls["${canonicalPath}"].${language} must keep optional and splat parameters in canonical order: expected ${formatParamSignature(expectedOrderedSignature)}; received ${formatParamSignature(actualOrderedSignature)}.`);
-            claimPhysicalPattern(localisedPattern, canonicalPath, `.${language}`);
-        }
-    }
-};
-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)=>{
-    validateLocalisedUrlPatterns(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 getLocalisedRouteIdSuffixes = (paths)=>{
-    const usedSuffixes = new Set();
-    return paths.map((path, index)=>{
-        if (0 === index) return;
-        const baseSuffix = legalRouteIdPart(path);
-        let suffix = baseSuffix;
-        let disambiguator = 2;
-        while(usedSuffixes.has(suffix))suffix = `${baseSuffix}_${disambiguator++}`;
-        usedSuffixes.add(suffix);
-        return suffix;
-    });
-};
-const getLocalisedRoutePaths = (canonicalPath, parentLocalisedPaths, languages, entry)=>{
-    const paths = languages.map((language)=>{
-        const fullPath = normalisePathPattern(entry[language]);
-        const parentPath = normalisePathPattern(parentLocalisedPaths[language] || '/');
-        if ('/' === parentPath) return 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 normaliseRoutePath(fullPath.slice(parentPath.length));
-    });
-    const uniquePaths = Array.from(new Set(paths.filter(Boolean)));
-    return uniquePaths;
-};
-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] = 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
-    ];
-    const localisedPaths = getLocalisedRoutePaths(canonicalPath, parentLocalisedPaths, languages, localisedUrlEntry);
-    const leadingLocaleParam = getLeadingLocaleParam(route.path);
-    const routeIdPaths = leadingLocaleParam ? localisedPaths.map((path)=>normaliseRoutePath(`${leadingLocaleParam}/${path}`)) : localisedPaths;
-    const routeIdSuffixes = getLocalisedRouteIdSuffixes(routeIdPaths);
-    return localisedPaths.map((localisedPath, index)=>cloneRouteWithLocalisedPath(baseRoute, localisedPath, routeIdSuffixes[index], canonicalPath));
-};
-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 collectRouteIdCounts = (routes, counts = new Map())=>{
-    for (const route of routes){
-        if (route.id) counts.set(route.id, (counts.get(route.id) ?? 0) + 1);
-        if ('children' in route && route.children) collectRouteIdCounts(route.children, counts);
-    }
-    return counts;
-};
-const validateNoNewRouteIdCollisions = (sourceRoutes, localisedRoutes)=>{
-    const sourceCounts = collectRouteIdCounts(sourceRoutes);
-    const localisedCounts = collectRouteIdCounts(localisedRoutes);
-    for (const [routeId, count] of localisedCounts)if (count > 1 && count > (sourceCounts.get(routeId) ?? 0)) throw new Error(`Localised route expansion generated duplicate route ID "${routeId}". Change the source route ID or localised path so every generated route remains identifiable.`);
-};
-const cloneRouteWithLocalisedPath = (route, path, routeIdSuffix, canonicalPath)=>{
-    const leadingLocaleParam = getLeadingLocaleParam(route.path);
-    const localisedPath = leadingLocaleParam ? normaliseRoutePath(`${leadingLocaleParam}/${path}`) : path;
-    const routeWithPath = {
-        ...route,
-        path: localisedPath
-    };
-    routeWithPath.modernCanonicalPath = canonicalPath;
-    return routeIdSuffix ? suffixRouteIds(routeWithPath, routeIdSuffix) : routeWithPath;
-};
-const applyLocalisedUrlsToRoutes = (routes, languages, localisedUrls)=>{
-    const rootLocalisedPaths = languages.reduce((acc, language)=>{
-        acc[language] = '/';
-        return acc;
-    }, {});
-    validateLocalisedUrls(routes, languages, localisedUrls);
-    const localisedRoutes = routes.flatMap((route)=>transformLocalisedRoute(route, '', rootLocalisedPaths, languages, localisedUrls));
-    validateNoNewRouteIdCollisions(routes, localisedRoutes);
-    return localisedRoutes;
-};
-export { applyLocalisedUrlsToRoutes, validateLocalisedUrls };

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

@@ -1,12 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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 { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from "./routes.mjs";

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

@@ -1,38 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,153 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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: '/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 = 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);
-    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

@@ -1,38 +0,0 @@
-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 };