@bleedingdev/modern-js-plugin-i18n 3.8.2-ultramodern.9 → 3.8.3-ultramodern.2

package/dist/esm-node/shared/localisedUrls/routes.mjs

@@ -1,90 +0,0 @@
-import "node:module";
-import { getLeadingLocaleParam, normalisePathPattern, normaliseRoutePath, stripLeadingLocaleParam } from "./normalise.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 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 = 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));
-    });
-    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] = 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 = getLeadingLocaleParam(route.path);
-    const localisedPath = leadingLocaleParam ? normaliseRoutePath(`${leadingLocaleParam}/${path}`) : path;
-    const routeWithPath = {
-        ...route,
-        path: localisedPath
-    };
-    routeWithPath.modernCanonicalPath = canonicalPath;
-    return 0 === index ? routeWithPath : suffixRouteIds(routeWithPath, legalRouteIdPart(localisedPath));
-};
-const applyLocalisedUrlsToRoutes = (routes, languages, localisedUrls)=>{
-    const rootLocalisedPaths = languages.reduce((acc, language)=>{
-        acc[language] = '/';
-        return acc;
-    }, {});
-    validateLocalisedUrls(routes, languages, localisedUrls);
-    return routes.flatMap((route)=>transformLocalisedRoute(route, '', rootLocalisedPaths, languages, localisedUrls));
-};
-export { applyLocalisedUrlsToRoutes, validateLocalisedUrls };

package/dist/esm-node/shared/localisedUrls/types.mjs

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

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

@@ -1,2 +0,0 @@
-import "node:module";
-export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, applyLocalisedUrlsToRoutes, buildPathFromPattern, canonicalTargetPathname, isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchPathPattern, matchesPathPrefix, normalisePathPattern, normalisePathname, resolveCanonicalLocalisedPath, resolveLocalisedPath, resolveLocalisedUrlsConfig, shouldSkipLocaleRedirect, stripLanguagePrefix, validateLocalisedUrls } from "./localisedUrls/index.mjs";

package/dist/types/shared/localisedUrls/config.d.ts

@@ -1,9 +0,0 @@
-import type { LocalisedUrlsOption, ResolvedLocalisedUrlsConfig } from './types';
-/**
- * Localised URLs are strictly opt-in: only an explicit, non-empty map enables
- * route expansion and validation. `true`, `false`, an empty map and absence
- * all resolve to disabled, so upstream-style configs (`localePathRedirect` +
- * `languages` without a map) keep plain locale-prefix behavior instead of
- * failing the build for every route missing from a map they never wrote.
- */
-export declare const resolveLocalisedUrlsConfig: (option: LocalisedUrlsOption | undefined) => ResolvedLocalisedUrlsConfig;

package/dist/types/shared/localisedUrls/index.d.ts

@@ -1,9 +0,0 @@
-export { resolveLocalisedUrlsConfig } from './config';
-export { normalisePathname, normalisePathPattern } from './normalise';
-export { canonicalTargetPathname, localiseTargetPathname, stripLanguagePrefix, } from './pathname';
-export { buildPathFromPattern, matchPathPattern } from './patterns';
-export type { LocaleRedirectSkipRule } from './redirect';
-export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, matchesPathPrefix, shouldSkipLocaleRedirect, } from './redirect';
-export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from './resolve';
-export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from './routes';
-export type { LocalisedRoute, LocalisedUrlPathMap, LocalisedUrlsMap, LocalisedUrlsOption, ResolvedLocalisedUrlsConfig, } from './types';

package/dist/types/shared/localisedUrls/normalise.d.ts

@@ -1,10 +0,0 @@
-export declare const normalisePathPattern: (path: string) => string;
-/**
- * Normalise a concrete request pathname: slash cleanup only. Unlike
- * {@link normalisePathPattern} it must not rewrite literal `[x]` segments to
- * `:x` params — pathnames are values, not patterns.
- */
-export declare const normalisePathname: (pathname: string) => string;
-export declare const normaliseRoutePath: (path: string) => string;
-export declare const stripLeadingLocaleParam: (path?: string) => string | undefined;
-export declare const getLeadingLocaleParam: (path?: string) => string | null;

package/dist/types/shared/localisedUrls/pathname.d.ts

@@ -1,4 +0,0 @@
-import type { LocalisedUrlsOption } from './types';
-export declare const stripLanguagePrefix: (pathname: string, languages: string[]) => string;
-export declare const localiseTargetPathname: (pathname: string, language: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;
-export declare const canonicalTargetPathname: (pathname: string, languages: string[], localisedUrls?: LocalisedUrlsOption) => string;

package/dist/types/shared/localisedUrls/patterns.d.ts

@@ -1,5 +0,0 @@
-export declare const sortPatternsBySpecificity: <T extends {
-    pattern: string;
-}>(patterns: T[]) => T[];
-export declare const matchPathPattern: (pathname: string, pattern: string) => Record<string, string> | null;
-export declare const buildPathFromPattern: (pattern: string, params: Record<string, string>) => string;

package/dist/types/shared/localisedUrls/redirect.d.ts

@@ -1,11 +0,0 @@
-export type LocaleRedirectSkipRule = {
-    type: 'exact';
-    path: string;
-} | {
-    type: 'prefix';
-    path: string;
-};
-export declare const DEFAULT_LOCALE_REDIRECT_SKIP_RULES: readonly LocaleRedirectSkipRule[];
-export declare const matchesPathPrefix: (pathname: string, prefix: string) => boolean;
-export declare const isDefaultLocaleRedirectSkipPath: (pathname: string, languages?: string[]) => boolean;
-export declare const shouldSkipLocaleRedirect: (pathname: string, languages?: string[], ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean)) => boolean;

package/dist/types/shared/localisedUrls/resolve.d.ts

@@ -1,7 +0,0 @@
-import type { LocalisedUrlsMap } from './types';
-export declare const resolveLocalisedPath: (pathname: string, targetLanguage: string, languages: string[], localisedUrls: LocalisedUrlsMap) => string;
-/**
- * Reverse-map language-specific pathnames back to language-agnostic
- * LocalisedUrlsMap keys.
- */
-export declare const resolveCanonicalLocalisedPath: (pathname: string, languages: string[], localisedUrls: LocalisedUrlsMap) => string;

package/dist/types/shared/localisedUrls/routes.d.ts

@@ -1,3 +0,0 @@
-import type { LocalisedRoute, LocalisedUrlsMap } from './types';
-export declare const validateLocalisedUrls: (routes: LocalisedRoute[], languages: string[], localisedUrls: LocalisedUrlsMap) => void;
-export declare const applyLocalisedUrlsToRoutes: (routes: LocalisedRoute[], languages: string[], localisedUrls: LocalisedUrlsMap) => LocalisedRoute[];

package/dist/types/shared/localisedUrls/types.d.ts

@@ -1,14 +0,0 @@
-export type LocalisedRoute = {
-    type: 'nested' | 'page';
-    path?: string;
-    id?: string;
-    children?: LocalisedRoute[];
-    [key: string]: any;
-};
-export type LocalisedUrlPathMap = Record<string, string>;
-export type LocalisedUrlsMap = Record<string, LocalisedUrlPathMap>;
-export type LocalisedUrlsOption = boolean | LocalisedUrlsMap;
-export interface ResolvedLocalisedUrlsConfig {
-    enabled: boolean;
-    map: LocalisedUrlsMap;
-}

package/dist/types/shared/localisedUrls.d.ts

@@ -1,2 +0,0 @@
-export type { LocaleRedirectSkipRule, LocalisedRoute, LocalisedUrlPathMap, LocalisedUrlsMap, LocalisedUrlsOption, ResolvedLocalisedUrlsConfig, } from './localisedUrls/index';
-export { applyLocalisedUrlsToRoutes, buildPathFromPattern, canonicalTargetPathname, DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchesPathPrefix, matchPathPattern, normalisePathname, normalisePathPattern, resolveCanonicalLocalisedPath, resolveLocalisedPath, resolveLocalisedUrlsConfig, shouldSkipLocaleRedirect, stripLanguagePrefix, validateLocalisedUrls, } from './localisedUrls/index';

package/src/shared/localisedUrls/config.ts

@@ -1,18 +0,0 @@
-import type { LocalisedUrlsOption, ResolvedLocalisedUrlsConfig } from './types';
-
-/**
- * Localised URLs are strictly opt-in: only an explicit, non-empty map enables
- * route expansion and validation. `true`, `false`, an empty map and absence
- * all resolve to disabled, so upstream-style configs (`localePathRedirect` +
- * `languages` without a map) keep plain locale-prefix behavior instead of
- * failing the build for every route missing from a map they never wrote.
- */
-export const resolveLocalisedUrlsConfig = (
-  option: LocalisedUrlsOption | undefined,
-): ResolvedLocalisedUrlsConfig => {
-  if (option && typeof option === 'object' && Object.keys(option).length > 0) {
-    return { enabled: true, map: option };
-  }
-
-  return { enabled: false, map: {} };
-};

package/src/shared/localisedUrls/index.ts

@@ -1,24 +0,0 @@
-export { resolveLocalisedUrlsConfig } from './config';
-export { normalisePathname, normalisePathPattern } from './normalise';
-export {
-  canonicalTargetPathname,
-  localiseTargetPathname,
-  stripLanguagePrefix,
-} from './pathname';
-export { buildPathFromPattern, matchPathPattern } from './patterns';
-export type { LocaleRedirectSkipRule } from './redirect';
-export {
-  DEFAULT_LOCALE_REDIRECT_SKIP_RULES,
-  isDefaultLocaleRedirectSkipPath,
-  matchesPathPrefix,
-  shouldSkipLocaleRedirect,
-} from './redirect';
-export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from './resolve';
-export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from './routes';
-export type {
-  LocalisedRoute,
-  LocalisedUrlPathMap,
-  LocalisedUrlsMap,
-  LocalisedUrlsOption,
-  ResolvedLocalisedUrlsConfig,
-} from './types';

package/src/shared/localisedUrls/normalise.ts

@@ -1,67 +0,0 @@
-const LOCALE_PARAM_NAMES = new Set(['lang', 'locale', 'language']);
-
-const normaliseSlashes = (path: string): string => {
-  const withoutDuplicateSlashes = path.replace(/\/+/g, '/');
-  const withLeadingSlash = withoutDuplicateSlashes.startsWith('/')
-    ? withoutDuplicateSlashes
-    : `/${withoutDuplicateSlashes}`;
-
-  return withLeadingSlash.length > 1
-    ? withLeadingSlash.replace(/\/+$/, '')
-    : withLeadingSlash;
-};
-
-export const normalisePathPattern = (path: string): string =>
-  normaliseSlashes(path).replace(/\[(.+?)\]/g, ':$1');
-
-/**
- * Normalise a concrete request pathname: slash cleanup only. Unlike
- * {@link normalisePathPattern} it must not rewrite literal `[x]` segments to
- * `:x` params — pathnames are values, not patterns.
- */
-export const normalisePathname = (pathname: string): string =>
-  normaliseSlashes(pathname);
-
-export const normaliseRoutePath = (path: string): string => {
-  const normalized = normalisePathPattern(path);
-  return normalized === '/' ? '' : normalized.slice(1);
-};
-
-const getLocaleParamSegment = (segment: string): string | null => {
-  if (!segment.startsWith(':')) {
-    return null;
-  }
-
-  const paramName = segment.slice(1).replace(/\?$/, '');
-  return LOCALE_PARAM_NAMES.has(paramName) ? segment : null;
-};
-
-const splitPathSegments = (path?: string): string[] => {
-  if (!path) {
-    return [];
-  }
-
-  return normalisePathPattern(path).split('/').filter(Boolean);
-};
-
-export const stripLeadingLocaleParam = (path?: string): string | undefined => {
-  const segments = splitPathSegments(path);
-  const leadingLocaleParam = getLocaleParamSegment(segments[0] || '');
-
-  if (!leadingLocaleParam) {
-    return path;
-  }
-
-  const remainingPath = segments.slice(1).join('/');
-  return remainingPath ? `/${remainingPath}` : undefined;
-};
-
-export const getLeadingLocaleParam = (path?: string): string | null => {
-  const segments = splitPathSegments(path);
-  return getLocaleParamSegment(segments[0] || '');
-};
-
-const isLocaleParamPath = (path?: string): boolean => {
-  const segments = splitPathSegments(path);
-  return segments.length === 1 && Boolean(getLocaleParamSegment(segments[0]));
-};

package/src/shared/localisedUrls/pathname.ts

@@ -1,60 +0,0 @@
-import { resolveLocalisedUrlsConfig } from './config';
-
-import { resolveCanonicalLocalisedPath, resolveLocalisedPath } from './resolve';
-
-import type { LocalisedUrlsOption } from './types';
-
-export const stripLanguagePrefix = (
-  pathname: string,
-  languages: string[],
-): string => {
-  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 || '/';
-};
-
-export const localiseTargetPathname = (
-  pathname: string,
-  language: string,
-  languages: string[],
-  localisedUrls?: LocalisedUrlsOption,
-): string => {
-  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('/')}`;
-};
-
-export const canonicalTargetPathname = (
-  pathname: string,
-  languages: string[],
-  localisedUrls?: LocalisedUrlsOption,
-): string => {
-  const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
-  const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
-
-  return localisedUrlsConfig.enabled
-    ? resolveCanonicalLocalisedPath(
-        pathWithoutLanguage,
-        languages,
-        localisedUrlsConfig.map,
-      )
-    : pathWithoutLanguage;
-};

package/src/shared/localisedUrls/patterns.ts

@@ -1,160 +0,0 @@
-import { normalisePathname, normalisePathPattern } from './normalise';
-
-const escapeRegExp = (value: string): string =>
-  value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-
-const getParamName = (segment: string): string =>
-  segment.slice(1).replace(/\?$/, '');
-
-interface CompiledPathPattern {
-  names: string[];
-  regexp: RegExp;
-}
-
-const compiledPathPatternCache = new Map<string, CompiledPathPattern>();
-
-const compilePathPattern = (pattern: string): CompiledPathPattern => {
-  const normalizedPattern = normalisePathPattern(pattern);
-  const cached = compiledPathPatternCache.get(normalizedPattern);
-  if (cached) {
-    return cached;
-  }
-
-  const names: string[] = [];
-  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: string) => {
-  const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
-  let staticSegments = 0;
-  let dynamicSegments = 0;
-  let splatSegments = 0;
-
-  for (const segment of segments) {
-    if (segment === '*') {
-      splatSegments++;
-    } else if (segment.startsWith(':')) {
-      dynamicSegments++;
-    } else {
-      staticSegments++;
-    }
-  }
-
-  return {
-    staticSegments,
-    dynamicSegments,
-    splatSegments,
-    totalSegments: segments.length,
-  };
-};
-
-const comparePatternSpecificity = (left: string, right: string): number => {
-  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
-  );
-};
-
-export const sortPatternsBySpecificity = <T extends { pattern: string }>(
-  patterns: T[],
-): T[] =>
-  patterns
-    .map((pattern, index) => ({ pattern, index }))
-    .sort(
-      (left, right) =>
-        comparePatternSpecificity(
-          left.pattern.pattern,
-          right.pattern.pattern,
-        ) || left.index - right.index,
-    )
-    .map(({ pattern }) => pattern);
-
-/**
- * `decodeURIComponent` throws `URIError` on malformed percent-encoding
- * (e.g. `%E0%A4%A`), which attacker-controlled request URLs can carry.
- * Treat such segments as undecodable instead of throwing.
- */
-const decodePathParam = (value: string): string | null => {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return null;
-  }
-};
-
-const encodeSplatParam = (value: string): string =>
-  value.split('/').map(encodeURIComponent).join('/');
-
-export const matchPathPattern = (
-  pathname: string,
-  pattern: string,
-): Record<string, string> | null => {
-  const { names, regexp } = compilePathPattern(pattern);
-  const match = regexp.exec(normalisePathname(pathname));
-  if (!match) {
-    return null;
-  }
-
-  const params: Record<string, string> = {};
-  for (let index = 0; index < names.length; index++) {
-    const decoded = decodePathParam(match[index + 1] || '');
-    if (decoded === null) {
-      // Malformed encoding cannot identify a localised route: no match.
-      return null;
-    }
-    params[names[index]] = decoded;
-  }
-
-  return params;
-};
-
-export const buildPathFromPattern = (
-  pattern: string,
-  params: Record<string, string>,
-): string => {
-  const segments = 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}`;
-};

package/src/shared/localisedUrls/redirect.ts

@@ -1,93 +0,0 @@
-import { normalisePathname } from './normalise';
-import { stripLanguagePrefix } from './pathname';
-
-export type LocaleRedirectSkipRule =
-  | {
-      type: 'exact';
-      path: string;
-    }
-  | {
-      type: 'prefix';
-      path: string;
-    };
-
-export const DEFAULT_LOCALE_REDIRECT_SKIP_RULES: readonly LocaleRedirectSkipRule[] =
-  [
-    { 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: string): string =>
-  pathname.length > 1 ? pathname.replace(/\/+$/, '') : pathname;
-
-export const matchesPathPrefix = (
-  pathname: string,
-  prefix: string,
-): boolean => {
-  const normalizedPathname = normalisePathname(pathname);
-  const normalizedPrefix = stripTrailingSlash(normalisePathname(prefix));
-
-  return (
-    normalizedPathname === normalizedPrefix ||
-    normalizedPathname.startsWith(`${normalizedPrefix}/`)
-  );
-};
-
-const matchesSkipRule = (
-  pathname: string,
-  rule: LocaleRedirectSkipRule,
-): boolean => {
-  if (rule.type === 'exact') {
-    return normalisePathname(pathname) === normalisePathname(rule.path);
-  }
-
-  return matchesPathPrefix(pathname, rule.path);
-};
-
-export const isDefaultLocaleRedirectSkipPath = (
-  pathname: string,
-  languages: string[] = [],
-): boolean => {
-  const normalizedPathname = normalisePathname(pathname);
-  const pathWithoutLanguage = stripLanguagePrefix(
-    normalizedPathname,
-    languages,
-  );
-
-  return DEFAULT_LOCALE_REDIRECT_SKIP_RULES.some(rule =>
-    matchesSkipRule(pathWithoutLanguage, rule),
-  );
-};
-
-export const shouldSkipLocaleRedirect = (
-  pathname: string,
-  languages: string[] = [],
-  ignoreRedirectRoutes?: string[] | ((pathname: string) => boolean),
-): boolean => {
-  const normalizedPathname = normalisePathname(pathname);
-  const pathWithoutLanguage = stripLanguagePrefix(
-    normalizedPathname,
-    languages,
-  );
-
-  if (isDefaultLocaleRedirectSkipPath(pathWithoutLanguage)) {
-    return true;
-  }
-
-  if (!ignoreRedirectRoutes) {
-    return false;
-  }
-
-  if (typeof ignoreRedirectRoutes === 'function') {
-    return ignoreRedirectRoutes(pathWithoutLanguage);
-  }
-
-  return ignoreRedirectRoutes.some(pattern =>
-    matchesPathPrefix(pathWithoutLanguage, pattern),
-  );
-};