next-intl 3.25.0 → 4.0.0-beta-00a79d4

package/dist/{development → esm/development}/middleware/utils.js

@@ -1,33 +1,26 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var utils = require('../shared/utils.js');
+import { getSortedPathnames, matchesPathname, normalizeTrailingSlash, getLocalePrefix, templateToRegex, prefixPathname } from '../shared/utils.js';
 
 function getInternalTemplate(pathnames, pathname, locale) {
-  const sortedPathnames = utils.getSortedPathnames(Object.keys(pathnames));
+  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 (utils.matchesPathname(localizedPathname, pathname)) {
+      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(_ref => {
-        let [entryLocale] = _ref;
-        return entryLocale === locale;
-      });
+      const curLocaleIndex = sortedEntries.findIndex(([entryLocale]) => entryLocale === locale);
       if (curLocaleIndex > 0) {
         sortedEntries.unshift(sortedEntries.splice(curLocaleIndex, 1)[0]);
       }
       for (const [entryLocale, entryPathname] of sortedEntries) {
-        if (utils.matchesPathname(entryPathname, pathname)) {
+        if (matchesPathname(entryPathname, pathname)) {
           return [entryLocale, internalPathname];
         }
       }
@@ -37,7 +30,7 @@ function getInternalTemplate(pathnames, pathname, locale) {
   // 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 (utils.matchesPathname(internalPathname, pathname)) {
+    if (matchesPathname(internalPathname, pathname)) {
       return [undefined, internalPathname];
     }
   }
@@ -53,7 +46,7 @@ function formatTemplatePathname(sourcePathname, sourceTemplate, targetTemplate,
   // 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 = utils.normalizeTrailingSlash(targetPathname);
+  targetPathname = normalizeTrailingSlash(targetPathname);
   return targetPathname;
 }
 
@@ -67,20 +60,16 @@ function getNormalizedPathname(pathname, locales, localePrefix) {
     pathname += '/';
   }
   const localePrefixes = getLocalePrefixes(locales, localePrefix);
-  const regex = new RegExp("^(".concat(localePrefixes.map(_ref2 => {
-    let [, prefix] = _ref2;
-    return prefix.replaceAll('/', '\\/');
-  }).join('|'), ")/(.*)"), 'i');
+  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 = utils.normalizeTrailingSlash(result);
+    result = normalizeTrailingSlash(result);
   }
   return result;
 }
-function getLocalePrefixes(locales, localePrefix) {
-  let sort = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-  const prefixes = locales.map(locale => [locale, utils.getLocalePrefix(locale, localePrefix)]);
+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);
@@ -112,15 +101,14 @@ function getPathnameMatch(pathname, locales, localePrefix) {
   }
 }
 function getRouteParams(template, pathname) {
-  const normalizedPathname = utils.normalizeTrailingSlash(pathname);
-  const normalizedTemplate = utils.normalizeTrailingSlash(template);
-  const regex = utils.templateToRegex(normalizedTemplate);
+  const normalizedPathname = normalizeTrailingSlash(pathname);
+  const normalizedTemplate = normalizeTrailingSlash(template);
+  const regex = templateToRegex(normalizedTemplate);
   const match = regex.exec(normalizedPathname);
   if (!match) return undefined;
   const params = {};
   for (let i = 1; i < match.length; i++) {
-    var _normalizedTemplate$m;
-    const key = (_normalizedTemplate$m = normalizedTemplate.match(/\[([^\]]+)\]/g)) === null || _normalizedTemplate$m === void 0 ? void 0 : _normalizedTemplate$m[i - 1].replace(/[[\]]/g, '');
+    const key = normalizedTemplate.match(/\[([^\]]+)\]/g)?.[i - 1].replace(/[[\]]/g, '');
     if (key) params[key] = match[i];
   }
   return params;
@@ -132,16 +120,15 @@ function formatPathnameTemplate(template, params) {
   // we can replace the value with simple interpolation
   template = template.replace(/\[\[/g, '[').replace(/\]\]/g, ']');
   let result = template;
-  Object.entries(params).forEach(_ref3 => {
-    let [key, value] = _ref3;
-    result = result.replace("[".concat(key, "]"), value);
+  Object.entries(params).forEach(([key, value]) => {
+    result = result.replace(`[${key}]`, value);
   });
   return result;
 }
 function formatPathname(pathname, prefix, search) {
   let result = pathname;
   if (prefix) {
-    result = utils.prefixPathname(prefix, result);
+    result = prefixPathname(prefix, result);
   }
   if (search) {
     result += search;
@@ -149,8 +136,7 @@ function formatPathname(pathname, prefix, search) {
   return result;
 }
 function getHost(requestHeaders) {
-  var _ref4, _requestHeaders$get;
-  return (_ref4 = (_requestHeaders$get = requestHeaders.get('x-forwarded-host')) !== null && _requestHeaders$get !== void 0 ? _requestHeaders$get : requestHeaders.get('host')) !== null && _ref4 !== void 0 ? _ref4 : undefined;
+  return requestHeaders.get('x-forwarded-host') ?? requestHeaders.get('host') ?? undefined;
 }
 function isLocaleSupportedOnDomain(locale, domain) {
   return domain.defaultLocale === locale || !domain.locales || domain.locales.includes(locale);
@@ -170,14 +156,11 @@ function getBestMatchingDomain(curHostDomain, locale, domainsConfig) {
 
   // Prio 3: Use alternative domain with restricted matching locale
   if (!domainConfig) {
-    domainConfig = domainsConfig.find(cur => {
-      var _cur$locales;
-      return (_cur$locales = cur.locales) === null || _cur$locales === void 0 ? void 0 : _cur$locales.includes(locale);
-    });
+    domainConfig = domainsConfig.find(cur => cur.locales?.includes(locale));
   }
 
   // Prio 4: Stay on the current domain if it supports all locales
-  if (!domainConfig && (curHostDomain === null || curHostDomain === void 0 ? void 0 : curHostDomain.locales) == null) {
+  if (!domainConfig && curHostDomain?.locales == null) {
     domainConfig = curHostDomain;
   }
 
@@ -188,10 +171,10 @@ function getBestMatchingDomain(curHostDomain, locale, domainsConfig) {
   return domainConfig;
 }
 function applyBasePath(pathname, basePath) {
-  return utils.normalizeTrailingSlash(basePath + pathname);
+  return normalizeTrailingSlash(basePath + pathname);
 }
 function getLocaleAsPrefix(locale) {
-  return "/".concat(locale);
+  return `/${locale}`;
 }
 function sanitizePathname(pathname) {
   // Sanitize malicious URIs, e.g.:
@@ -200,17 +183,4 @@ function sanitizePathname(pathname) {
   return pathname.replace(/\\/g, '%5C').replace(/\/+/g, '/');
 }
 
-exports.applyBasePath = applyBasePath;
-exports.formatPathname = formatPathname;
-exports.formatPathnameTemplate = formatPathnameTemplate;
-exports.formatTemplatePathname = formatTemplatePathname;
-exports.getBestMatchingDomain = getBestMatchingDomain;
-exports.getHost = getHost;
-exports.getInternalTemplate = getInternalTemplate;
-exports.getLocaleAsPrefix = getLocaleAsPrefix;
-exports.getLocalePrefixes = getLocalePrefixes;
-exports.getNormalizedPathname = getNormalizedPathname;
-exports.getPathnameMatch = getPathnameMatch;
-exports.getRouteParams = getRouteParams;
-exports.isLocaleSupportedOnDomain = isLocaleSupportedOnDomain;
-exports.sanitizePathname = sanitizePathname;
+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';

package/dist/{development → esm/development}/navigation/react-client/createNavigation.js

@@ -1,43 +1,36 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var navigation = require('next/navigation');
-var React = require('react');
-var useLocale = require('../../react-client/useLocale.js');
-var createSharedNavigationFns = require('../shared/createSharedNavigationFns.js');
-var syncLocaleCookie = require('../shared/syncLocaleCookie.js');
-var utils = require('../shared/utils.js');
-var useBasePathname = require('./useBasePathname.js');
+import { useRouter, usePathname } from 'next/navigation.js';
+import { useMemo } from 'react';
+import { useLocale } from 'use-intl';
+import createSharedNavigationFns from '../shared/createSharedNavigationFns.js';
+import syncLocaleCookie from '../shared/syncLocaleCookie.js';
+import { getRoute } from '../shared/utils.js';
+import useBasePathname from './useBasePathname.js';
 
 function createNavigation(routing) {
-  function useTypedLocale() {
-    return useLocale.default();
-  }
   const {
     Link,
     config,
     getPathname,
     ...redirects
-  } = createSharedNavigationFns.default(useTypedLocale, routing);
+  } = createSharedNavigationFns(useLocale, routing);
 
   /** @see https://next-intl-docs.vercel.app/docs/routing/navigation#usepathname */
-  function usePathname() {
-    const pathname = useBasePathname.default(config.localePrefix);
-    const locale = useTypedLocale();
+  function usePathname$1() {
+    const pathname = useBasePathname(config.localePrefix);
+    const locale = useLocale();
 
     // @ts-expect-error -- Mirror the behavior from Next.js, where `null` is returned when `usePathname` is used outside of Next, but the types indicate that a string is always returned.
-    return React.useMemo(() => pathname &&
+    return useMemo(() => pathname &&
     // @ts-expect-error -- This is fine
-    config.pathnames ? utils.getRoute(locale, pathname,
+    config.pathnames ? getRoute(locale, pathname,
     // @ts-expect-error -- This is fine
     config.pathnames) : pathname, [locale, pathname]);
   }
-  function useRouter() {
-    const router = navigation.useRouter();
-    const curLocale = useTypedLocale();
-    const nextPathname = navigation.usePathname();
-    return React.useMemo(() => {
+  function useRouter$1() {
+    const router = useRouter();
+    const curLocale = useLocale();
+    const nextPathname = usePathname();
+    return useMemo(() => {
       function createHandler(fn) {
         return function handler(href, options) {
           const {
@@ -57,7 +50,7 @@ function createNavigation(routing) {
             args.push(rest);
           }
           fn(...args);
-          syncLocaleCookie.default(config.localeCookie, nextPathname, curLocale, nextLocale);
+          syncLocaleCookie(config.localeCookie, nextPathname, curLocale, nextLocale);
         };
       }
       return {
@@ -74,10 +67,10 @@ function createNavigation(routing) {
   return {
     ...redirects,
     Link,
-    usePathname,
-    useRouter,
+    usePathname: usePathname$1,
+    useRouter: useRouter$1,
     getPathname
   };
 }
 
-exports.default = createNavigation;
+export { createNavigation as default };

package/dist/esm/development/navigation/react-client/useBasePathname.js

@@ -0,0 +1,27 @@
+import { usePathname } from 'next/navigation.js';
+import { useMemo } from 'react';
+import { useLocale } from 'use-intl';
+import { hasPathnamePrefixed, unprefixPathname, getLocalePrefix } from '../../shared/utils.js';
+
+function useBasePathname(localePrefix) {
+  // The types aren't entirely correct here. Outside of Next.js
+  // `useParams` can be called, but the return type is `null`.
+
+  // Notes on `useNextPathname`:
+  // - Types aren't entirely correct. Outside of Next.js the
+  //   hook will return `null` (e.g. unit tests)
+  // - A base path is stripped from the result
+  // - Rewrites *are* taken into account (i.e. the pathname
+  //   that the user sees in the browser is returned)
+  const pathname = usePathname();
+  const locale = useLocale();
+  return useMemo(() => {
+    if (!pathname) return pathname;
+    const prefix = getLocalePrefix(locale, localePrefix);
+    const isPathnamePrefixed = hasPathnamePrefixed(prefix, pathname);
+    const unlocalizedPathname = isPathnamePrefixed ? unprefixPathname(pathname, prefix) : pathname;
+    return unlocalizedPathname;
+  }, [locale, localePrefix, pathname]);
+}
+
+export { useBasePathname as default };

package/dist/esm/development/navigation/react-server/createNavigation.js

@@ -0,0 +1,22 @@
+import createSharedNavigationFns from '../shared/createSharedNavigationFns.js';
+import getServerLocale from './getServerLocale.js';
+
+function createNavigation(routing) {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const {
+    config,
+    ...fns
+  } = createSharedNavigationFns(getServerLocale, routing);
+  function notSupported(hookName) {
+    return () => {
+      throw new Error(`\`${hookName}\` is not supported in Server Components. You can use this hook if you convert the calling component to a Client Component.`);
+    };
+  }
+  return {
+    ...fns,
+    usePathname: notSupported('usePathname'),
+    useRouter: notSupported('useRouter')
+  };
+}
+
+export { createNavigation as default };

package/dist/esm/development/navigation/react-server/getServerLocale.js

@@ -0,0 +1,12 @@
+import getConfig from '../../server/react-server/getConfig.js';
+
+/**
+ * This is only moved to a separate module for easier mocking in
+ * `../createNavigatoin.test.tsx` in order to avoid suspending.
+ */
+async function getServerLocale() {
+  const config = await getConfig();
+  return config.locale;
+}
+
+export { getServerLocale as default };

package/dist/{development → esm/development}/navigation/shared/BaseLink.js

@@ -1,32 +1,22 @@
 "use client";
-'use strict';
+import NextLink from 'next/link.js';
+import { usePathname } from 'next/navigation.js';
+import { forwardRef, useState, useEffect } from 'react';
+import { useLocale } from 'use-intl';
+import syncLocaleCookie from './syncLocaleCookie.js';
+import { jsx } from 'react/jsx-runtime';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelpers.js');
-var NextLink = require('next/link');
-var navigation = require('next/navigation');
-var React = require('react');
-var useLocale = require('../../react-client/useLocale.js');
-var syncLocaleCookie = require('./syncLocaleCookie.js');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var NextLink__default = /*#__PURE__*/_interopDefault(NextLink);
-var React__default = /*#__PURE__*/_interopDefault(React);
-
-function BaseLink(_ref, ref) {
-  let {
-    defaultLocale,
-    href,
-    locale,
-    localeCookie,
-    onClick,
-    prefetch,
-    unprefixed,
-    ...rest
-  } = _ref;
-  const curLocale = useLocale.default();
+function BaseLink({
+  defaultLocale,
+  href,
+  locale,
+  localeCookie,
+  onClick,
+  prefetch,
+  unprefixed,
+  ...rest
+}, ref) {
+  const curLocale = useLocale();
   const isChangingLocale = locale != null && locale !== curLocale;
   const linkLocale = locale || curLocale;
   const host = useHost();
@@ -44,9 +34,9 @@ function BaseLink(_ref, ref) {
 
   // The types aren't entirely correct here. Outside of Next.js
   // `useParams` can be called, but the return type is `null`.
-  const pathname = navigation.usePathname();
+  const pathname = usePathname();
   function onLinkClick(event) {
-    syncLocaleCookie.default(localeCookie, pathname, curLocale, locale);
+    syncLocaleCookie(localeCookie, pathname, curLocale, locale);
     if (onClick) onClick(event);
   }
   if (isChangingLocale) {
@@ -55,21 +45,26 @@ function BaseLink(_ref, ref) {
     }
     prefetch = false;
   }
-  return /*#__PURE__*/React__default.default.createElement(NextLink__default.default, _rollupPluginBabelHelpers.extends({
+
+  // Somehow the types for `next/link` don't work as expected
+  // when `moduleResolution: "nodenext"` is used.
+  const Link = NextLink;
+  return /*#__PURE__*/jsx(Link, {
     ref: ref,
     href: finalHref,
     hrefLang: isChangingLocale ? locale : undefined,
     onClick: onLinkClick,
-    prefetch: prefetch
-  }, rest));
+    prefetch: prefetch,
+    ...rest
+  });
 }
 function useHost() {
-  const [host, setHost] = React.useState();
-  React.useEffect(() => {
+  const [host, setHost] = useState();
+  useEffect(() => {
     setHost(window.location.host);
   }, []);
   return host;
 }
-var BaseLink$1 = /*#__PURE__*/React.forwardRef(BaseLink);
+var BaseLink$1 = /*#__PURE__*/forwardRef(BaseLink);
 
-exports.default = BaseLink$1;
+export { BaseLink$1 as default };

package/dist/{development → esm/development}/navigation/shared/createSharedNavigationFns.js

@@ -1,28 +1,21 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelpers.js');
-var navigation = require('next/navigation');
-var React = require('react');
-var config = require('../../routing/config.js');
-var utils$1 = require('../../shared/utils.js');
-var BaseLink = require('./BaseLink.js');
-var utils = require('./utils.js');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var React__default = /*#__PURE__*/_interopDefault(React);
+import { redirect, permanentRedirect } from 'next/navigation.js';
+import { forwardRef } from 'react';
+import { receiveRoutingConfig } from '../../routing/config.js';
+import use from '../../shared/use.js';
+import { isLocalizableHref } from '../../shared/utils.js';
+import BaseLink from './BaseLink.js';
+import { validateReceivedConfig, serializeSearchParams, compileLocalizedPathname, applyPathnamePrefix, normalizeNameOrNameWithParams } from './utils.js';
+import { jsx } from 'react/jsx-runtime';
 
 /**
  * Shared implementations for `react-server` and `react-client`
  */
 function createSharedNavigationFns(getLocale, routing) {
-  const config$1 = config.receiveRoutingConfig(routing || {});
+  const config = receiveRoutingConfig(routing || {});
   {
-    utils.validateReceivedConfig(config$1);
+    validateReceivedConfig(config);
   }
-  const pathnames = config$1.pathnames;
+  const pathnames = config.pathnames;
 
   // This combination requires that the current host is known in order to
   // compute a correct pathname. Since that can only be achieved by reading from
@@ -30,13 +23,12 @@ function createSharedNavigationFns(getLocale, routing) {
   // always add a prefix in this case to be on the safe side. The downside is
   // that the user might get redirected again if the middleware detects that the
   // prefix is not needed.
-  const forcePrefixSsr = config$1.localePrefix.mode === 'as-needed' && config$1.domains || undefined;
-  function Link(_ref, ref) {
-    let {
-      href,
-      locale,
-      ...rest
-    } = _ref;
+  const forcePrefixSsr = config.localePrefix.mode === 'as-needed' && config.domains || undefined;
+  function Link({
+    href,
+    locale,
+    ...rest
+  }, ref) {
     let pathname, params;
     if (typeof href === 'object') {
       pathname = href.pathname;
@@ -47,9 +39,9 @@ function createSharedNavigationFns(getLocale, routing) {
     }
 
     // @ts-expect-error -- This is ok
-    const isLocalizable = utils$1.isLocalizableHref(href);
+    const isLocalizable = isLocalizableHref(href);
     const localePromiseOrValue = getLocale();
-    const curLocale = localePromiseOrValue instanceof Promise ? React.use(localePromiseOrValue) : localePromiseOrValue;
+    const curLocale = localePromiseOrValue instanceof Promise ? use(localePromiseOrValue) : localePromiseOrValue;
     const finalPathname = isLocalizable ? getPathname(
     // @ts-expect-error -- This is ok
     {
@@ -59,11 +51,11 @@ function createSharedNavigationFns(getLocale, routing) {
         params
       }
     }, locale != null || forcePrefixSsr || undefined) : pathname;
-    return /*#__PURE__*/React__default.default.createElement(BaseLink.default, _rollupPluginBabelHelpers.extends({
+    return /*#__PURE__*/jsx(BaseLink, {
       ref: ref
       // @ts-expect-error -- Available after the validation
       ,
-      defaultLocale: config$1.defaultLocale
+      defaultLocale: config.defaultLocale
       // @ts-expect-error -- This is ok
       ,
       href: typeof href === 'object' ? {
@@ -71,13 +63,12 @@ function createSharedNavigationFns(getLocale, routing) {
         pathname: finalPathname
       } : finalPathname,
       locale: locale,
-      localeCookie: config$1.localeCookie
+      localeCookie: config.localeCookie
       // Provide the minimal relevant information to the client side in order
       // to potentially remove the prefix in case of the `forcePrefixSsr` case
       ,
       unprefixed: forcePrefixSsr && isLocalizable ? {
-        domains: config$1.domains.reduce((acc, domain) => {
-          // @ts-expect-error -- This is ok
+        domains: config.domains.reduce((acc, domain) => {
           acc[domain.domain] = domain.defaultLocale;
           return acc;
         }, {}),
@@ -90,10 +81,11 @@ function createSharedNavigationFns(getLocale, routing) {
             params
           }
         }, false)
-      } : undefined
-    }, rest));
+      } : undefined,
+      ...rest
+    });
   }
-  const LinkWithRef = /*#__PURE__*/React.forwardRef(Link);
+  const LinkWithRef = /*#__PURE__*/forwardRef(Link);
   function getPathname(args, /** @private Removed in types returned below */
   _forcePrefix) {
     const {
@@ -105,45 +97,42 @@ function createSharedNavigationFns(getLocale, routing) {
       if (typeof href === 'object') {
         pathname = href.pathname;
         if (href.query) {
-          pathname += utils.serializeSearchParams(href.query);
+          pathname += serializeSearchParams(href.query);
         }
       } else {
         pathname = href;
       }
     } else {
-      pathname = utils.compileLocalizedPathname({
+      pathname = compileLocalizedPathname({
         locale,
         // @ts-expect-error -- This is ok
-        ...utils.normalizeNameOrNameWithParams(href),
+        ...normalizeNameOrNameWithParams(href),
         // @ts-expect-error -- This is ok
-        pathnames: config$1.pathnames
+        pathnames: config.pathnames
       });
     }
-    return utils.applyPathnamePrefix(pathname, locale, config$1,
+    return applyPathnamePrefix(pathname, locale, config,
     // @ts-expect-error -- This is ok
     args.domain, _forcePrefix);
   }
   function getRedirectFn(fn) {
     /** @see https://next-intl-docs.vercel.app/docs/routing/navigation#redirect */
-    return function redirectFn(args) {
-      for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-        rest[_key - 1] = arguments[_key];
-      }
+    return function redirectFn(args, ...rest) {
       return fn(
       // @ts-expect-error -- We're forcing the prefix when no domain is provided
       getPathname(args, args.domain ? undefined : forcePrefixSsr), ...rest);
     };
   }
-  const redirect = getRedirectFn(navigation.redirect);
-  const permanentRedirect = getRedirectFn(navigation.permanentRedirect);
+  const redirect$1 = getRedirectFn(redirect);
+  const permanentRedirect$1 = getRedirectFn(permanentRedirect);
   return {
-    config: config$1,
+    config,
     Link: LinkWithRef,
-    redirect,
-    permanentRedirect,
+    redirect: redirect$1,
+    permanentRedirect: permanentRedirect$1,
     // Remove `_forcePrefix` from public API
     getPathname: getPathname
   };
 }
 
-exports.default = createSharedNavigationFns;
+export { createSharedNavigationFns as default };

package/dist/{development → esm/development}/navigation/shared/syncLocaleCookie.js

@@ -1,8 +1,4 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var utils = require('./utils.js');
+import { getBasePath } from './utils.js';
 
 /**
  * We have to keep the cookie value in sync as Next.js might
@@ -17,7 +13,7 @@ function syncLocaleCookie(localeCookie, pathname, locale, nextLocale) {
   !pathname) {
     return;
   }
-  const basePath = utils.getBasePath(pathname);
+  const basePath = getBasePath(pathname);
   const hasBasePath = basePath !== '';
   const defaultPath = hasBasePath ? basePath : '/';
   const {
@@ -27,14 +23,14 @@ function syncLocaleCookie(localeCookie, pathname, locale, nextLocale) {
   if (!rest.path) {
     rest.path = defaultPath;
   }
-  let localeCookieString = "".concat(name, "=").concat(nextLocale, ";");
+  let localeCookieString = `${name}=${nextLocale};`;
   for (const [key, value] of Object.entries(rest)) {
     // Map object properties to cookie properties.
     // Interestingly, `maxAge` corresponds to `max-age`,
     // while `sameSite` corresponds to `SameSite`.
     // Also, keys are case-insensitive.
     const targetKey = key === 'maxAge' ? 'max-age' : key;
-    localeCookieString += "".concat(targetKey);
+    localeCookieString += `${targetKey}`;
     if (typeof value !== 'boolean') {
       localeCookieString += '=' + value;
     }
@@ -48,4 +44,4 @@ function syncLocaleCookie(localeCookie, pathname, locale, nextLocale) {
   document.cookie = localeCookieString;
 }
 
-exports.default = syncLocaleCookie;
+export { syncLocaleCookie as default };