next-intl 3.25.0 → 4.0.0-beta-00a79d4

package/config.d.ts

@@ -1,3 +1,4 @@
-import config from './dist/types/src/config';
+// Needed for projects with `moduleResolution: 'node'`
+import config from './dist/types/config';
 
 export = config;

package/dist/cjs/development/plugin.cjs

@@ -0,0 +1,167 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var chokidar = require('chokidar');
+
+function formatMessage(message) {
+  return `\n[next-intl] ${message}\n`;
+}
+function throwError(message) {
+  throw new Error(formatMessage(message));
+}
+function warn(message) {
+  console.warn(formatMessage(message));
+}
+
+function runOnce(fn) {
+  if (process.env._NEXT_INTL_COMPILE_MESSAGES === '1') {
+    return;
+  }
+  process.env._NEXT_INTL_COMPILE_MESSAGES = '1';
+  fn();
+}
+function createMessagesDeclaration(messagesPath) {
+  const fullPath = path.resolve(messagesPath);
+  if (!fs.existsSync(fullPath)) {
+    throwError(`\`createMessagesDeclaration\` points to a non-existent file: ${fullPath}`);
+  }
+  if (!fullPath.endsWith('.json')) {
+    throwError(`\`createMessagesDeclaration\` needs to point to a JSON file. Received: ${fullPath}`);
+  }
+  const isDev = process.argv.includes('dev');
+  const isBuild = process.argv.includes('build');
+  if (!isDev && !isBuild) {
+    return;
+  }
+
+  // Next.js can call the Next.js config multiple
+  // times - ensure we only run once.
+  runOnce(() => {
+    compileDeclaration(messagesPath);
+    if (isDev) {
+      startWatching(messagesPath);
+    }
+  });
+}
+function startWatching(messagesPath) {
+  const watcher = chokidar.watch(messagesPath);
+  watcher.on('change', () => {
+    compileDeclaration(messagesPath, true);
+  });
+  process.on('exit', () => {
+    void watcher.close();
+  });
+}
+function compileDeclaration(messagesPath, async = false) {
+  const declarationPath = messagesPath.replace(/\.json$/, '.d.json.ts');
+  function createDeclaration(content) {
+    return `// This file is auto-generated by next-intl, do not edit directly.
+// See: https://next-intl-docs.vercel.app/docs/workflows/typescript#messages-arguments
+
+declare const messages: ${content.trim()};
+export default messages;`;
+  }
+  if (async) {
+    return fs.promises.readFile(messagesPath, 'utf-8').then(content => fs.promises.writeFile(declarationPath, createDeclaration(content)));
+  }
+  const content = fs.readFileSync(messagesPath, 'utf-8');
+  fs.writeFileSync(declarationPath, createDeclaration(content));
+}
+
+function withExtensions(localPath) {
+  return [`${localPath}.ts`, `${localPath}.tsx`, `${localPath}.js`, `${localPath}.jsx`];
+}
+function resolveI18nPath(providedPath, cwd) {
+  function resolvePath(pathname) {
+    const parts = [];
+    if (cwd) parts.push(cwd);
+    parts.push(pathname);
+    return path.resolve(...parts);
+  }
+  function pathExists(pathname) {
+    return fs.existsSync(resolvePath(pathname));
+  }
+  if (providedPath) {
+    if (!pathExists(providedPath)) {
+      throwError(`Could not find i18n config at ${providedPath}, please provide a valid path.`);
+    }
+    return providedPath;
+  } else {
+    for (const candidate of [...withExtensions('./i18n/request'), ...withExtensions('./src/i18n/request')]) {
+      if (pathExists(candidate)) {
+        return candidate;
+      }
+    }
+    throwError(`Could not locate request configuration module.\n\nThis path is supported by default: ./(src/)i18n/request.{js,jsx,ts,tsx}\n\nAlternatively, you can specify a custom location in your Next.js config:\n\nconst withNextIntl = createNextIntlPlugin(
+
+Alternatively, you can specify a custom location in your Next.js config:
+
+const withNextIntl = createNextIntlPlugin(
+  './path/to/i18n/request.tsx'
+);`);
+  }
+}
+function getNextConfig(pluginConfig, nextConfig) {
+  const useTurbo = process.env.TURBOPACK != null;
+  const nextIntlConfig = {};
+
+  // Assign alias for `next-intl/config`
+  if (useTurbo) {
+    if (pluginConfig.requestConfig?.startsWith('/')) {
+      throwError("Turbopack support for next-intl currently does not support absolute paths, please provide a relative one (e.g. './src/i18n/config.ts').\n\nFound: " + pluginConfig.requestConfig);
+    }
+
+    // `NextConfig['turbo']` is stable in Next.js 15. In case the
+    // experimental feature is removed in the future, we should
+    // replace this accordingly in a future major version.
+    nextIntlConfig.experimental = {
+      ...nextConfig?.experimental,
+      turbo: {
+        ...nextConfig?.experimental?.turbo,
+        resolveAlias: {
+          ...nextConfig?.experimental?.turbo?.resolveAlias,
+          // Turbo aliases don't work with absolute
+          // paths (see error handling above)
+          'next-intl/config': resolveI18nPath(pluginConfig.requestConfig)
+        }
+      }
+    };
+  } else {
+    nextIntlConfig.webpack = function webpack(...[config, options]) {
+      // Webpack requires absolute paths
+      config.resolve.alias['next-intl/config'] = path.resolve(config.context, resolveI18nPath(pluginConfig.requestConfig, config.context));
+      if (typeof nextConfig?.webpack === 'function') {
+        return nextConfig.webpack(config, options);
+      }
+      return config;
+    };
+  }
+
+  // Forward config
+  nextIntlConfig.env = {
+    ...nextConfig?.env,
+    _next_intl_trailing_slash: nextConfig?.trailingSlash ? 'true' : undefined
+  };
+  return Object.assign({}, nextConfig, nextIntlConfig);
+}
+
+function initPlugin(pluginConfig, nextConfig) {
+  if (nextConfig?.i18n != null) {
+    warn("\n[next-intl] An `i18n` property was found in your Next.js config. This likely causes conflicts and should therefore be removed if you use the App Router.\n\nIf you're in progress of migrating from the Pages Router, you can refer to this example: https://next-intl-docs.vercel.app/examples#app-router-migration\n");
+  }
+  if (pluginConfig.experimental?.createMessagesDeclaration) {
+    createMessagesDeclaration(pluginConfig.experimental.createMessagesDeclaration);
+  }
+  return getNextConfig(pluginConfig, nextConfig);
+}
+function createNextIntlPlugin(i18nPathOrConfig = {}) {
+  const config = typeof i18nPathOrConfig === 'string' ? {
+    requestConfig: i18nPathOrConfig
+  } : i18nPathOrConfig;
+  return function withNextIntl(nextConfig) {
+    return initPlugin(config, nextConfig);
+  };
+}
+
+module.exports = createNextIntlPlugin;

package/dist/{development → esm/development}/config.js

@@ -1,9 +1,5 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
 function getConfig() {
   throw new Error("Couldn't find next-intl config file. Please follow the instructions at https://next-intl-docs.vercel.app/docs/getting-started/app-router");
 }
 
-exports.default = getConfig;
+export { getConfig as default };

package/dist/esm/development/index.react-client.js

@@ -0,0 +1,3 @@
+export { useFormatter, useTranslations } from './react-client/index.js';
+export { default as NextIntlClientProvider } from './shared/NextIntlClientProvider.js';
+export * from 'use-intl';

package/dist/esm/development/index.react-server.js

@@ -0,0 +1,8 @@
+export { default as useLocale } from './react-server/useLocale.js';
+export { default as useTranslations } from './react-server/useTranslations.js';
+export { default as useFormatter } from './react-server/useFormatter.js';
+export { default as useNow } from './react-server/useNow.js';
+export { default as useTimeZone } from './react-server/useTimeZone.js';
+export { default as useMessages } from './react-server/useMessages.js';
+export { default as NextIntlClientProvider } from './react-server/NextIntlClientProviderServer.js';
+export * from 'use-intl/core';

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

@@ -1,46 +1,39 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var utils$1 = require('../shared/utils.js');
-var utils = require('./utils.js');
+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(_ref) {
-  var _request$headers$get;
-  let {
-    localizedPathnames,
-    request,
-    resolvedLocale,
-    routing
-  } = _ref;
+function getAlternateLinksHeaderValue({
+  localizedPathnames,
+  request,
+  resolvedLocale,
+  routing
+}) {
   const normalizedUrl = request.nextUrl.clone();
-  const host = utils.getHost(request.headers);
+  const host = getHost(request.headers);
   if (host) {
     normalizedUrl.port = '';
     normalizedUrl.host = host;
   }
-  normalizedUrl.protocol = (_request$headers$get = request.headers.get('x-forwarded-proto')) !== null && _request$headers$get !== void 0 ? _request$headers$get : normalizedUrl.protocol;
-  normalizedUrl.pathname = utils.getNormalizedPathname(normalizedUrl.pathname, routing.locales, routing.localePrefix);
+  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 = utils$1.normalizeTrailingSlash(url.pathname);
+    url.pathname = normalizeTrailingSlash(url.pathname);
     if (request.nextUrl.basePath) {
       url = new URL(url);
-      url.pathname = utils.applyBasePath(url.pathname, request.nextUrl.basePath);
+      url.pathname = applyBasePath(url.pathname, request.nextUrl.basePath);
     }
-    return "<".concat(url.toString(), ">; rel=\"alternate\"; hreflang=\"").concat(locale, "\"");
+    return `<${url.toString()}>; rel="alternate"; hreflang="${locale}"`;
   }
   function getLocalizedPathname(pathname, locale) {
     if (localizedPathnames && typeof localizedPathnames === 'object') {
-      return utils.formatTemplatePathname(pathname, localizedPathnames[resolvedLocale], localizedPathnames[locale]);
+      return formatTemplatePathname(pathname, localizedPathnames[resolvedLocale], localizedPathnames[locale]);
     } else {
       return pathname;
     }
   }
-  const links = utils.getLocalePrefixes(routing.locales, routing.localePrefix, false).flatMap(_ref2 => {
-    let [locale, prefix] = _ref2;
+  const links = getLocalePrefixes(routing.locales, routing.localePrefix, false).flatMap(([locale, prefix]) => {
     function prefixPathname(pathname) {
       if (pathname === '/') {
         return prefix;
@@ -50,7 +43,7 @@ function getAlternateLinksHeaderValue(_ref) {
     }
     let url;
     if (routing.domains) {
-      const domainConfigs = routing.domains.filter(cur => utils.isLocaleSupportedOnDomain(locale, cur));
+      const domainConfigs = routing.domains.filter(cur => isLocaleSupportedOnDomain(locale, cur));
       return domainConfigs.map(domainConfig => {
         url = new URL(normalizedUrl);
         url.port = '';
@@ -90,4 +83,4 @@ function getAlternateLinksHeaderValue(_ref) {
   return links.join(', ');
 }
 
-exports.default = getAlternateLinksHeaderValue;
+export { getAlternateLinksHeaderValue as default };

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

@@ -0,0 +1,155 @@
+import { NextResponse } from 'next/server.js';
+import { receiveRoutingConfig } from '../routing/config.js';
+import { HEADER_LOCALE_NAME } from '../shared/constants.js';
+import { matchesPathname, normalizeTrailingSlash, getLocalePrefix } 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 rewrite(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);
+      return NextResponse.rewrite(urlObj, {
+        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;
+          urlObj.port = request.headers.get('x-forwarded-port') ?? '';
+        }
+      }
+      if (request.nextUrl.basePath) {
+        urlObj.pathname = applyBasePath(urlObj.pathname, request.nextUrl.basePath);
+      }
+      return NextResponse.redirect(urlObj.toString());
+    }
+    const unprefixedExternalPathname = getNormalizedPathname(externalPathname, resolvedRouting.locales, resolvedRouting.localePrefix);
+    const pathnameMatch = getPathnameMatch(externalPathname, resolvedRouting.locales, resolvedRouting.localePrefix);
+    const hasLocalePrefix = pathnameMatch != null;
+    const isUnprefixedRouting = resolvedRouting.localePrefix.mode === 'never' || hasMatchedDefaultLocale && resolvedRouting.localePrefix.mode === 'as-needed';
+    let response;
+    let internalTemplateName;
+    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 = typeof pathnameConfig === 'string' ? pathnameConfig : pathnameConfig[locale];
+        if (matchesPathname(localeTemplate, unprefixedExternalPathname)) {
+          unprefixedInternalPathname = formatTemplatePathname(unprefixedExternalPathname, localeTemplate, internalTemplateName);
+        } else {
+          let sourceTemplate;
+          if (resolvedTemplateLocale) {
+            // A localized pathname from another locale has matched
+            sourceTemplate = typeof pathnameConfig === 'string' ? pathnameConfig : pathnameConfig[resolvedTemplateLocale];
+          } 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 = rewrite(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 = rewrite(internalHref);
+                }
+              } else {
+                response = rewrite(internalHref);
+              }
+            }
+          } else {
+            response = redirect(externalHref);
+          }
+        } else {
+          if (isUnprefixedRouting) {
+            response = rewrite(internalHref);
+          } else {
+            response = redirect(formatPathname(unprefixedExternalPathname, getLocalePrefix(locale, resolvedRouting.localePrefix), request.nextUrl.search));
+          }
+        }
+      }
+    }
+    syncCookie(request, response, locale, resolvedRouting, domain);
+    if (resolvedRouting.localePrefix.mode !== 'never' && resolvedRouting.alternateLinks && resolvedRouting.locales.length > 1) {
+      response.headers.set('Link', getAlternateLinksHeaderValue({
+        routing: resolvedRouting,
+        localizedPathnames: internalTemplateName != null && pathnames ? pathnames[internalTemplateName] : undefined,
+        request,
+        resolvedLocale: locale
+      }));
+    }
+    return response;
+  };
+}
+
+export { createMiddleware as default };

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

@@ -1,17 +1,9 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var intlLocalematcher = require('@formatjs/intl-localematcher');
-var Negotiator = require('negotiator');
-var utils = require('./utils.js');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var Negotiator__default = /*#__PURE__*/_interopDefault(Negotiator);
+import { match } from '@formatjs/intl-localematcher';
+import Negotiator from 'negotiator';
+import { getPathnameMatch, isLocaleSupportedOnDomain, getHost } from './utils.js';
 
 function findDomainFromHost(requestHeaders, domains) {
-  const host = utils.getHost(requestHeaders);
+  const host = getHost(requestHeaders);
   if (host) {
     return domains.find(cur => cur.domain === host);
   }
@@ -23,23 +15,22 @@ function orderLocales(locales) {
 }
 function getAcceptLanguageLocale(requestHeaders, locales, defaultLocale) {
   let locale;
-  const languages = new Negotiator__default.default({
+  const languages = new Negotiator({
     headers: {
       'accept-language': requestHeaders.get('accept-language') || undefined
     }
   }).languages();
   try {
     const orderedLocales = orderLocales(locales);
-    locale = intlLocalematcher.match(languages, orderedLocales, defaultLocale);
-  } catch (_unused) {
+    locale = match(languages, orderedLocales, defaultLocale);
+  } catch {
     // Invalid language
   }
   return locale;
 }
 function getLocaleFromCookie(routing, requestCookies) {
   if (routing.localeCookie && requestCookies.has(routing.localeCookie.name)) {
-    var _requestCookies$get;
-    const value = (_requestCookies$get = requestCookies.get(routing.localeCookie.name)) === null || _requestCookies$get === void 0 ? void 0 : _requestCookies$get.value;
+    const value = requestCookies.get(routing.localeCookie.name)?.value;
     if (value && routing.locales.includes(value)) {
       return value;
     }
@@ -50,8 +41,7 @@ function resolveLocaleFromPrefix(routing, requestHeaders, requestCookies, pathna
 
   // Prio 1: Use route prefix
   if (pathname) {
-    var _getPathnameMatch;
-    locale = (_getPathnameMatch = utils.getPathnameMatch(pathname, routing.locales, routing.localePrefix)) === null || _getPathnameMatch === void 0 ? void 0 : _getPathnameMatch.locale;
+    locale = getPathnameMatch(pathname, routing.locales, routing.localePrefix)?.locale;
   }
 
   // Prio 2: Use existing cookie
@@ -82,10 +72,9 @@ function resolveLocaleFromDomain(routing, requestHeaders, requestCookies, pathna
 
   // Prio 1: Use route prefix
   if (pathname) {
-    var _getPathnameMatch2;
-    const prefixLocale = (_getPathnameMatch2 = utils.getPathnameMatch(pathname, routing.locales, routing.localePrefix)) === null || _getPathnameMatch2 === void 0 ? void 0 : _getPathnameMatch2.locale;
+    const prefixLocale = getPathnameMatch(pathname, routing.locales, routing.localePrefix)?.locale;
     if (prefixLocale) {
-      if (utils.isLocaleSupportedOnDomain(prefixLocale, domain)) {
+      if (isLocaleSupportedOnDomain(prefixLocale, domain)) {
         locale = prefixLocale;
       } else {
         // Causes a redirect to a domain that supports the locale
@@ -101,7 +90,7 @@ function resolveLocaleFromDomain(routing, requestHeaders, requestCookies, pathna
   if (!locale && routing.localeDetection) {
     const cookieLocale = getLocaleFromCookie(routing, requestCookies);
     if (cookieLocale) {
-      if (utils.isLocaleSupportedOnDomain(cookieLocale, domain)) {
+      if (isLocaleSupportedOnDomain(cookieLocale, domain)) {
         locale = cookieLocale;
       }
     }
@@ -134,5 +123,4 @@ function resolveLocale(routing, requestHeaders, requestCookies, pathname) {
   }
 }
 
-exports.default = resolveLocale;
-exports.getAcceptLanguageLocale = getAcceptLanguageLocale;
+export { resolveLocale as default, getAcceptLanguageLocale };

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

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