@depup/next-intl 4.8.3-depup.0

package/dist/esm/development/middleware/getAlternateLinksHeaderValue.js

@@ -0,0 +1,91 @@
+import { normalizeTrailingSlash } from '../shared/utils.js';
+import { getHost, getNormalizedPathname, getLocalePrefixes, isLocaleSupportedOnDomain, applyBasePath, formatTemplatePathname } from './utils.js';
+
+/**
+ * See https://developers.google.com/search/docs/specialty/international/localized-versions
+ */
+function getAlternateLinksHeaderValue({
+  internalTemplateName,
+  localizedPathnames,
+  request,
+  resolvedLocale,
+  routing
+}) {
+  const normalizedUrl = request.nextUrl.clone();
+  const host = getHost(request.headers);
+  if (host) {
+    normalizedUrl.port = '';
+    normalizedUrl.host = host;
+  }
+  normalizedUrl.protocol = request.headers.get('x-forwarded-proto') ?? normalizedUrl.protocol;
+  normalizedUrl.pathname = getNormalizedPathname(normalizedUrl.pathname, routing.locales, routing.localePrefix);
+  function getAlternateEntry(url, locale) {
+    url.pathname = normalizeTrailingSlash(url.pathname);
+    if (request.nextUrl.basePath) {
+      url = new URL(url);
+      url.pathname = applyBasePath(url.pathname, request.nextUrl.basePath);
+    }
+    return `<${url.toString()}>; rel="alternate"; hreflang="${locale}"`;
+  }
+  function getLocalizedPathname(pathname, locale) {
+    if (localizedPathnames && typeof localizedPathnames === 'object') {
+      const sourceTemplate = localizedPathnames[resolvedLocale];
+      return formatTemplatePathname(pathname, sourceTemplate ?? internalTemplateName, localizedPathnames[locale] ?? internalTemplateName);
+    } else {
+      return pathname;
+    }
+  }
+  const links = getLocalePrefixes(routing.locales, routing.localePrefix, false).flatMap(([locale, prefix]) => {
+    function prefixPathname(pathname) {
+      if (pathname === '/') {
+        return prefix;
+      } else {
+        return prefix + pathname;
+      }
+    }
+    let url;
+    if (routing.domains) {
+      const domainConfigs = routing.domains.filter(cur => isLocaleSupportedOnDomain(locale, cur));
+      return domainConfigs.map(domainConfig => {
+        url = new URL(normalizedUrl);
+        url.port = '';
+        url.host = domainConfig.domain;
+
+        // Important: Use `normalizedUrl` here, as `url` potentially uses
+        // a `basePath` that automatically gets applied to the pathname
+        url.pathname = getLocalizedPathname(normalizedUrl.pathname, locale);
+        if (locale !== domainConfig.defaultLocale || routing.localePrefix.mode === 'always') {
+          url.pathname = prefixPathname(url.pathname);
+        }
+        return getAlternateEntry(url, locale);
+      });
+    } else {
+      let pathname;
+      if (localizedPathnames && typeof localizedPathnames === 'object') {
+        pathname = getLocalizedPathname(normalizedUrl.pathname, locale);
+      } else {
+        pathname = normalizedUrl.pathname;
+      }
+      if (locale !== routing.defaultLocale || routing.localePrefix.mode === 'always') {
+        pathname = prefixPathname(pathname);
+      }
+      url = new URL(pathname, normalizedUrl);
+    }
+    return getAlternateEntry(url, locale);
+  });
+
+  // Add x-default entry
+  const shouldAddXDefault =
+  // For domain-based routing there is no reasonable x-default
+  !routing.domains || routing.domains.length === 0;
+  if (shouldAddXDefault) {
+    const localizedPathname = getLocalizedPathname(normalizedUrl.pathname, routing.defaultLocale);
+    if (localizedPathname) {
+      const url = new URL(localizedPathname, normalizedUrl);
+      links.push(getAlternateEntry(url, 'x-default'));
+    }
+  }
+  return links.join(', ');
+}
+
+export { getAlternateLinksHeaderValue as default };

package/dist/esm/development/middleware/middleware.js

@@ -0,0 +1,168 @@
+import { NextResponse } from 'next/server';
+import { receiveRoutingConfig } from '../routing/config.js';
+import { HEADER_LOCALE_NAME } from '../shared/constants.js';
+import { matchesPathname, normalizeTrailingSlash, getLocalePrefix, getLocalizedTemplate } from '../shared/utils.js';
+import getAlternateLinksHeaderValue from './getAlternateLinksHeaderValue.js';
+import resolveLocale from './resolveLocale.js';
+import syncCookie from './syncCookie.js';
+import { sanitizePathname, isLocaleSupportedOnDomain, getNormalizedPathname, getPathnameMatch, getInternalTemplate, formatTemplatePathname, formatPathname, getBestMatchingDomain, applyBasePath, getLocaleAsPrefix } from './utils.js';
+
+function createMiddleware(routing) {
+  const resolvedRouting = receiveRoutingConfig(routing);
+  return function middleware(request) {
+    let unsafeExternalPathname;
+    try {
+      // Resolve potential foreign symbols (e.g. /ja/%E7%B4%84 → /ja/約))
+      unsafeExternalPathname = decodeURI(request.nextUrl.pathname);
+    } catch {
+      // In case an invalid pathname is encountered, forward
+      // it to Next.js which in turn responds with a 400
+      return NextResponse.next();
+    }
+
+    // Sanitize malicious URIs to prevent open redirect attacks due to
+    // decodeURI doesn't escape encoded backslashes ('%5C' & '%5c')
+    const externalPathname = sanitizePathname(unsafeExternalPathname);
+    const {
+      domain,
+      locale
+    } = resolveLocale(resolvedRouting, request.headers, request.cookies, externalPathname);
+    const hasMatchedDefaultLocale = domain ? domain.defaultLocale === locale : locale === resolvedRouting.defaultLocale;
+    const domainsConfig = resolvedRouting.domains?.filter(curDomain => isLocaleSupportedOnDomain(locale, curDomain)) || [];
+    const hasUnknownHost = resolvedRouting.domains != null && !domain;
+    function next(url) {
+      const urlObj = new URL(url, request.url);
+      if (request.nextUrl.basePath) {
+        urlObj.pathname = applyBasePath(urlObj.pathname, request.nextUrl.basePath);
+      }
+      const headers = new Headers(request.headers);
+      headers.set(HEADER_LOCALE_NAME, locale);
+      const isRewriteNecessary = normalizeTrailingSlash(request.nextUrl.pathname) !== normalizeTrailingSlash(urlObj.pathname);
+      if (isRewriteNecessary) {
+        return NextResponse.rewrite(urlObj, {
+          request: {
+            headers
+          }
+        });
+      } else {
+        return NextResponse.next({
+          request: {
+            headers
+          }
+        });
+      }
+    }
+    function redirect(url, redirectDomain) {
+      const urlObj = new URL(url, request.url);
+      urlObj.pathname = normalizeTrailingSlash(urlObj.pathname);
+      if (domainsConfig.length > 0 && !redirectDomain && domain) {
+        const bestMatchingDomain = getBestMatchingDomain(domain, locale, domainsConfig);
+        if (bestMatchingDomain) {
+          redirectDomain = bestMatchingDomain.domain;
+          if (bestMatchingDomain.defaultLocale === locale && resolvedRouting.localePrefix.mode === 'as-needed') {
+            urlObj.pathname = getNormalizedPathname(urlObj.pathname, resolvedRouting.locales, resolvedRouting.localePrefix);
+          }
+        }
+      }
+      if (redirectDomain) {
+        urlObj.host = redirectDomain;
+        if (request.headers.get('x-forwarded-host')) {
+          urlObj.protocol = request.headers.get('x-forwarded-proto') ?? request.nextUrl.protocol;
+          const redirectDomainPort = redirectDomain.split(':')[1];
+          urlObj.port = redirectDomainPort ?? request.headers.get('x-forwarded-port') ?? '';
+        }
+      }
+      if (request.nextUrl.basePath) {
+        urlObj.pathname = applyBasePath(urlObj.pathname, request.nextUrl.basePath);
+      }
+      hasRedirected = true;
+      return NextResponse.redirect(urlObj.toString());
+    }
+    const unprefixedExternalPathname = getNormalizedPathname(externalPathname, resolvedRouting.locales, resolvedRouting.localePrefix);
+    const pathnameMatch = getPathnameMatch(externalPathname, resolvedRouting.locales, resolvedRouting.localePrefix, domain);
+    const hasLocalePrefix = pathnameMatch != null;
+    const isUnprefixedRouting = resolvedRouting.localePrefix.mode === 'never' || hasMatchedDefaultLocale && resolvedRouting.localePrefix.mode === 'as-needed';
+    let response;
+    let internalTemplateName;
+    let hasRedirected;
+    let unprefixedInternalPathname = unprefixedExternalPathname;
+    const pathnames = resolvedRouting.pathnames;
+    if (pathnames) {
+      let resolvedTemplateLocale;
+      [resolvedTemplateLocale, internalTemplateName] = getInternalTemplate(pathnames, unprefixedExternalPathname, locale);
+      if (internalTemplateName) {
+        const pathnameConfig = pathnames[internalTemplateName];
+        const localeTemplate = getLocalizedTemplate(pathnameConfig, locale, internalTemplateName);
+        if (matchesPathname(localeTemplate, unprefixedExternalPathname)) {
+          unprefixedInternalPathname = formatTemplatePathname(unprefixedExternalPathname, localeTemplate, internalTemplateName);
+        } else {
+          let sourceTemplate;
+          if (resolvedTemplateLocale) {
+            // A localized pathname from another locale has matched
+            sourceTemplate = getLocalizedTemplate(pathnameConfig, resolvedTemplateLocale, internalTemplateName);
+          } else {
+            // An internal pathname has matched that
+            // doesn't have a localized pathname
+            sourceTemplate = internalTemplateName;
+          }
+          const localePrefix = isUnprefixedRouting ? undefined : getLocalePrefix(locale, resolvedRouting.localePrefix);
+          const template = formatTemplatePathname(unprefixedExternalPathname, sourceTemplate, localeTemplate);
+          response = redirect(formatPathname(template, localePrefix, request.nextUrl.search));
+        }
+      }
+    }
+    if (!response) {
+      if (unprefixedInternalPathname === '/' && !hasLocalePrefix) {
+        if (isUnprefixedRouting) {
+          response = next(formatPathname(unprefixedInternalPathname, getLocaleAsPrefix(locale), request.nextUrl.search));
+        } else {
+          response = redirect(formatPathname(unprefixedExternalPathname, getLocalePrefix(locale, resolvedRouting.localePrefix), request.nextUrl.search));
+        }
+      } else {
+        const internalHref = formatPathname(unprefixedInternalPathname, getLocaleAsPrefix(locale), request.nextUrl.search);
+        if (hasLocalePrefix) {
+          const externalHref = formatPathname(unprefixedExternalPathname, pathnameMatch.prefix, request.nextUrl.search);
+          if (resolvedRouting.localePrefix.mode === 'never') {
+            response = redirect(formatPathname(unprefixedExternalPathname, undefined, request.nextUrl.search));
+          } else if (pathnameMatch.exact) {
+            if (hasMatchedDefaultLocale && isUnprefixedRouting) {
+              response = redirect(formatPathname(unprefixedExternalPathname, undefined, request.nextUrl.search));
+            } else {
+              if (resolvedRouting.domains) {
+                const pathDomain = getBestMatchingDomain(domain, pathnameMatch.locale, domainsConfig);
+                if (domain?.domain !== pathDomain?.domain && !hasUnknownHost) {
+                  response = redirect(externalHref, pathDomain?.domain);
+                } else {
+                  response = next(internalHref);
+                }
+              } else {
+                response = next(internalHref);
+              }
+            }
+          } else {
+            response = redirect(externalHref);
+          }
+        } else {
+          if (isUnprefixedRouting) {
+            response = next(internalHref);
+          } else {
+            response = redirect(formatPathname(unprefixedExternalPathname, getLocalePrefix(locale, resolvedRouting.localePrefix), request.nextUrl.search));
+          }
+        }
+      }
+    }
+    syncCookie(request, response, locale, resolvedRouting, domain);
+    if (!hasRedirected && resolvedRouting.localePrefix.mode !== 'never' && resolvedRouting.alternateLinks && resolvedRouting.locales.length > 1) {
+      response.headers.set('Link', getAlternateLinksHeaderValue({
+        routing: resolvedRouting,
+        internalTemplateName,
+        localizedPathnames: internalTemplateName != null && pathnames ? pathnames[internalTemplateName] : undefined,
+        request,
+        resolvedLocale: locale
+      }));
+    }
+    return response;
+  };
+}
+
+export { createMiddleware as default };

package/dist/esm/development/middleware/resolveLocale.js

@@ -0,0 +1,129 @@
+import { match } from '@formatjs/intl-localematcher';
+import Negotiator from 'negotiator';
+import { getPathnameMatch, isLocaleSupportedOnDomain, getHost } from './utils.js';
+
+function findDomainFromHost(requestHeaders, domains) {
+  const host = getHost(requestHeaders);
+  if (host) {
+    return domains.find(cur => cur.domain === host);
+  }
+  return undefined;
+}
+function orderLocales(locales) {
+  // Workaround for https://github.com/formatjs/formatjs/issues/4469
+  return locales.slice().sort((a, b) => b.length - a.length);
+}
+function mapToProvidedLocale(locales, locale) {
+  return locales.find(cur => cur.toLowerCase() === locale.toLowerCase());
+}
+function getAcceptLanguageLocale(requestHeaders, locales, defaultLocale) {
+  let locale;
+  const languages = new Negotiator({
+    headers: {
+      'accept-language': requestHeaders.get('accept-language') || undefined
+    }
+  }).languages();
+  try {
+    const orderedLocales = orderLocales(locales);
+    locale = mapToProvidedLocale(locales, match(languages, orderedLocales, defaultLocale));
+  } catch {
+    // Invalid language
+  }
+  return locale;
+}
+function getLocaleFromCookie(routing, requestCookies) {
+  if (routing.localeCookie && requestCookies.has(routing.localeCookie.name)) {
+    const value = requestCookies.get(routing.localeCookie.name)?.value;
+    if (value && routing.locales.includes(value)) {
+      return value;
+    }
+  }
+}
+function resolveLocaleFromPrefix(routing, requestHeaders, requestCookies, pathname) {
+  let locale;
+
+  // Prio 1: Use route prefix
+  if (pathname) {
+    locale = getPathnameMatch(pathname, routing.locales, routing.localePrefix)?.locale;
+  }
+
+  // Prio 2: Use existing cookie
+  if (!locale && routing.localeDetection) {
+    locale = getLocaleFromCookie(routing, requestCookies);
+  }
+
+  // Prio 3: Use the `accept-language` header
+  if (!locale && routing.localeDetection) {
+    locale = getAcceptLanguageLocale(requestHeaders, routing.locales, routing.defaultLocale);
+  }
+
+  // Prio 4: Use default locale
+  if (!locale) {
+    locale = routing.defaultLocale;
+  }
+  return locale;
+}
+function resolveLocaleFromDomain(routing, requestHeaders, requestCookies, pathname) {
+  const domains = routing.domains;
+  const domain = findDomainFromHost(requestHeaders, domains);
+  if (!domain) {
+    return {
+      locale: resolveLocaleFromPrefix(routing, requestHeaders, requestCookies, pathname)
+    };
+  }
+  let locale;
+
+  // Prio 1: Use route prefix
+  if (pathname) {
+    const prefixLocale = getPathnameMatch(pathname, routing.locales, routing.localePrefix, domain)?.locale;
+    if (prefixLocale) {
+      if (isLocaleSupportedOnDomain(prefixLocale, domain)) {
+        locale = prefixLocale;
+      } else {
+        // Causes a redirect to a domain that supports the locale
+        return {
+          locale: prefixLocale,
+          domain
+        };
+      }
+    }
+  }
+
+  // Prio 2: Use existing cookie
+  if (!locale && routing.localeDetection) {
+    const cookieLocale = getLocaleFromCookie(routing, requestCookies);
+    if (cookieLocale) {
+      if (isLocaleSupportedOnDomain(cookieLocale, domain)) {
+        locale = cookieLocale;
+      }
+    }
+  }
+
+  // Prio 3: Use the `accept-language` header
+  if (!locale && routing.localeDetection) {
+    const headerLocale = getAcceptLanguageLocale(requestHeaders, domain.locales, domain.defaultLocale);
+    if (headerLocale) {
+      locale = headerLocale;
+    }
+  }
+
+  // Prio 4: Use default locale
+  if (!locale) {
+    locale = domain.defaultLocale;
+  }
+  return {
+    locale,
+    domain
+  };
+}
+function resolveLocale(routing, requestHeaders, requestCookies, pathname) {
+  if (routing.domains) {
+    return resolveLocaleFromDomain(routing, requestHeaders, requestCookies, pathname);
+  } else {
+    return {
+      locale: resolveLocaleFromPrefix(routing, requestHeaders, requestCookies, pathname)
+    };
+  }
+}
+
+export { resolveLocale as default, getAcceptLanguageLocale };

package/dist/esm/development/middleware/syncCookie.js

@@ -0,0 +1,27 @@
+import { getAcceptLanguageLocale } from './resolveLocale.js';
+
+function syncCookie(request, response, locale, routing, domain) {
+  if (!routing.localeCookie) return;
+  const {
+    name,
+    ...rest
+  } = routing.localeCookie;
+  const hasLocaleCookie = request.cookies.has(name);
+  const hasOutdatedCookie = hasLocaleCookie && request.cookies.get(name)?.value !== locale;
+  if (hasOutdatedCookie) {
+    response.cookies.set(name, locale, {
+      path: request.nextUrl.basePath || undefined,
+      ...rest
+    });
+  } else if (!hasLocaleCookie) {
+    const acceptLanguageLocale = getAcceptLanguageLocale(request.headers, domain?.locales || routing.locales, routing.defaultLocale);
+    if (acceptLanguageLocale !== locale) {
+      response.cookies.set(name, locale, {
+        path: request.nextUrl.basePath || undefined,
+        ...rest
+      });
+    }
+  }
+}
+
+export { syncCookie as default };

package/dist/esm/development/middleware/utils.js

@@ -0,0 +1,194 @@
+import { normalizeTrailingSlash, getSortedPathnames, matchesPathname, prefixPathname, getLocalePrefix, templateToRegex, getLocalizedTemplate } from '../shared/utils.js';
+
+function getInternalTemplate(pathnames, pathname, locale) {
+  const sortedPathnames = getSortedPathnames(Object.keys(pathnames));
+
+  // Try to find a localized pathname that matches
+  for (const internalPathname of sortedPathnames) {
+    const localizedPathnamesOrPathname = pathnames[internalPathname];
+    if (typeof localizedPathnamesOrPathname === 'string') {
+      const localizedPathname = localizedPathnamesOrPathname;
+      if (matchesPathname(localizedPathname, pathname)) {
+        return [undefined, internalPathname];
+      }
+    } else {
+      // Prefer the entry with the current locale in case multiple
+      // localized pathnames match the current pathname
+      const sortedEntries = Object.entries(localizedPathnamesOrPathname);
+      const curLocaleIndex = sortedEntries.findIndex(([entryLocale]) => entryLocale === locale);
+      if (curLocaleIndex > 0) {
+        sortedEntries.unshift(sortedEntries.splice(curLocaleIndex, 1)[0]);
+      }
+      for (const [entryLocale] of sortedEntries) {
+        const localizedTemplate = getLocalizedTemplate(pathnames[internalPathname], entryLocale, internalPathname);
+        if (matchesPathname(localizedTemplate, pathname)) {
+          return [entryLocale, internalPathname];
+        }
+      }
+    }
+  }
+
+  // Try to find an internal pathname that matches (this can be the case
+  // if all localized pathnames are different from the internal pathnames)
+  for (const internalPathname of Object.keys(pathnames)) {
+    if (matchesPathname(internalPathname, pathname)) {
+      return [undefined, internalPathname];
+    }
+  }
+
+  // No match
+  return [undefined, undefined];
+}
+function formatTemplatePathname(sourcePathname, sourceTemplate, targetTemplate, prefix) {
+  const params = getRouteParams(sourceTemplate, sourcePathname);
+  let targetPathname = '';
+  targetPathname += formatPathnameTemplate(targetTemplate, params);
+
+  // A pathname with an optional catchall like `/categories/[[...slug]]`
+  // should be normalized to `/categories` if the catchall is not present
+  // and no trailing slash is configured
+  targetPathname = normalizeTrailingSlash(targetPathname);
+  return targetPathname;
+}
+
+/**
+ * Removes potential prefixes from the pathname.
+ */
+function getNormalizedPathname(pathname, locales, localePrefix) {
+  // Add trailing slash for consistent handling
+  // both for the root as well as nested paths
+  if (!pathname.endsWith('/')) {
+    pathname += '/';
+  }
+  const localePrefixes = getLocalePrefixes(locales, localePrefix);
+  const regex = new RegExp(`^(${localePrefixes.map(([, prefix]) => prefix.replaceAll('/', '\\/')).join('|')})/(.*)`, 'i');
+  const match = pathname.match(regex);
+  let result = match ? '/' + match[2] : pathname;
+  if (result !== '/') {
+    result = normalizeTrailingSlash(result);
+  }
+  return result;
+}
+function getLocalePrefixes(locales, localePrefix, sort = true) {
+  const prefixes = locales.map(locale => [locale, getLocalePrefix(locale, localePrefix)]);
+  if (sort) {
+    // More specific ones first
+    prefixes.sort((a, b) => b[1].length - a[1].length);
+  }
+  return prefixes;
+}
+function getPathnameMatch(pathname, locales, localePrefix, domain) {
+  const localePrefixes = getLocalePrefixes(locales, localePrefix);
+
+  // Sort to prioritize domain locales
+  if (domain) {
+    localePrefixes.sort(([localeA], [localeB]) => {
+      if (localeA === domain.defaultLocale) return -1;
+      if (localeB === domain.defaultLocale) return 1;
+      const isLocaleAInDomain = domain.locales.includes(localeA);
+      const isLocaleBInDomain = domain.locales.includes(localeB);
+      if (isLocaleAInDomain && !isLocaleBInDomain) return -1;
+      if (!isLocaleAInDomain && isLocaleBInDomain) return 1;
+      return 0;
+    });
+  }
+  for (const [locale, prefix] of localePrefixes) {
+    let exact, matches;
+    if (pathname === prefix || pathname.startsWith(prefix + '/')) {
+      exact = matches = true;
+    } else {
+      const normalizedPathname = pathname.toLowerCase();
+      const normalizedPrefix = prefix.toLowerCase();
+      if (normalizedPathname === normalizedPrefix || normalizedPathname.startsWith(normalizedPrefix + '/')) {
+        exact = false;
+        matches = true;
+      }
+    }
+    if (matches) {
+      return {
+        locale,
+        prefix,
+        matchedPrefix: pathname.slice(0, prefix.length),
+        exact
+      };
+    }
+  }
+}
+function getRouteParams(template, pathname) {
+  const normalizedPathname = normalizeTrailingSlash(pathname);
+  const normalizedTemplate = normalizeTrailingSlash(template);
+  const regex = templateToRegex(normalizedTemplate);
+  const match = regex.exec(normalizedPathname);
+  if (!match) return undefined;
+  const params = {};
+  const keys = normalizedTemplate.match(/\[([^\]]+)\]/g) ?? [];
+  for (let i = 1; i < match.length; i++) {
+    const rawKey = keys[i - 1];
+    if (!rawKey) continue;
+    const key = rawKey.replace(/[[\]]/g, '');
+    const value = match[i] ?? '';
+    params[key] = value;
+  }
+  return params;
+}
+function formatPathnameTemplate(template, params) {
+  if (!params) return template;
+
+  // Simplify syntax for optional catchall ('[[...slug]]') so
+  // we can replace the value with simple interpolation
+  template = template.replace(/\[\[/g, '[').replace(/\]\]/g, ']');
+  let result = template;
+  Object.entries(params).forEach(([key, value]) => {
+    result = result.replace(`[${key}]`, value);
+  });
+  return result;
+}
+function formatPathname(pathname, prefix, search) {
+  let result = pathname;
+  if (prefix) {
+    result = prefixPathname(prefix, result);
+  }
+  if (search) {
+    result += search;
+  }
+  return result;
+}
+function getHost(requestHeaders) {
+  return requestHeaders.get('x-forwarded-host') ?? requestHeaders.get('host') ?? undefined;
+}
+function isLocaleSupportedOnDomain(locale, domain) {
+  return domain.defaultLocale === locale || domain.locales.includes(locale);
+}
+function getBestMatchingDomain(curHostDomain, locale, domainsConfig) {
+  let domainConfig;
+
+  // Prio 1: Stay on current domain
+  if (curHostDomain && isLocaleSupportedOnDomain(locale, curHostDomain)) {
+    domainConfig = curHostDomain;
+  }
+
+  // Prio 2: Use alternative domain with matching default locale
+  if (!domainConfig) {
+    domainConfig = domainsConfig.find(cur => cur.defaultLocale === locale);
+  }
+
+  // Prio 3: Use alternative domain that supports the locale
+  if (!domainConfig) {
+    domainConfig = domainsConfig.find(cur => cur.locales.includes(locale));
+  }
+  return domainConfig;
+}
+function applyBasePath(pathname, basePath) {
+  return normalizeTrailingSlash(basePath + pathname);
+}
+function getLocaleAsPrefix(locale) {
+  return `/${locale}`;
+}
+function sanitizePathname(pathname) {
+  // Sanitize malicious URIs, e.g.:
+  // '/en/\\example.org → /en/%5C%5Cexample.org'
+  // '/en////example.org → /en/example.org'
+  return pathname.replace(/\\/g, '%5C').replace(/\/+/g, '/');
+}
+
+export { applyBasePath, formatPathname, formatPathnameTemplate, formatTemplatePathname, getBestMatchingDomain, getHost, getInternalTemplate, getLocaleAsPrefix, getLocalePrefixes, getNormalizedPathname, getPathnameMatch, getRouteParams, isLocaleSupportedOnDomain, sanitizePathname };

package/dist/esm/development/middleware.js

@@ -0,0 +1 @@
+export { default } from './middleware/middleware.js';