next-intl 2.22.1 → 2.22.3

package/README.md

@@ -11,8 +11,6 @@
 
 > Internationalization (i18n) for Next.js that gets out of your way.
 
-![Gzipped size](https://badgen.net/bundlephobia/minzip/next-intl) ![Tree shaking supported](https://badgen.net/bundlephobia/tree-shaking/next-intl) [<img src="https://img.shields.io/npm/dw/next-intl.svg" />](https://www.npmjs.com/package/next-intl)
-
 <hr />
 
 📣 [Support for Next.js 13 and the App Router has arrived →](https://next-intl-docs.vercel.app/docs/next-13)
@@ -51,7 +49,7 @@ export default function UserProfile({user}) {
 }
 ```
 
-```json
+```js
 // en.json
 {
   "UserProfile": {

package/config.d.ts

@@ -0,0 +1,3 @@
+import config from './dist/types/src/config';
+
+export = config;

package/dist/config.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./production/config.js');
+} else {
+  module.exports = require('./development/config.js');
+}

package/dist/development/_virtual/_rollupPluginBabelHelpers.js

@@ -0,0 +1,20 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+exports.extends = _extends;

package/dist/development/config.js

@@ -0,0 +1,9 @@
+'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-server-components");
+}
+
+exports.default = getConfig;

package/dist/development/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('./react-client/index.js');
+var useLocale = require('./react-client/useLocale.js');
+var NextIntlClientProvider = require('./shared/NextIntlClientProvider.js');
+var useIntl = require('use-intl');
+
+
+
+exports.useFormatter = index.useFormatter;
+exports.useTranslations = index.useTranslations;
+exports.useLocale = useLocale.default;
+exports.NextIntlClientProvider = NextIntlClientProvider.default;
+Object.keys(useIntl).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return useIntl[k]; }
+	});
+});

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

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var useLocale = require('./react-server/useLocale.js');
+var useTranslations = require('./react-server/useTranslations.js');
+var useFormatter = require('./react-server/useFormatter.js');
+var useNow = require('./react-server/useNow.js');
+var useTimeZone = require('./react-server/useTimeZone.js');
+var useMessages = require('./react-server/useMessages.js');
+var NextIntlClientProvider = require('./react-server/NextIntlClientProvider.js');
+var core = require('use-intl/core');
+
+
+
+exports.useLocale = useLocale.default;
+exports.useTranslations = useTranslations.default;
+exports.useFormatter = useFormatter.default;
+exports.useNow = useNow.default;
+exports.useTimeZone = useTimeZone.default;
+exports.useMessages = useMessages.default;
+exports.NextIntlClientProvider = NextIntlClientProvider.default;
+Object.keys(core).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return core[k]; }
+	});
+});

package/dist/development/middleware/getAlternateLinksHeaderValue.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('./utils.js');
+
+function getAlternateEntry(url, locale) {
+  return "<".concat(url, ">; rel=\"alternate\"; hreflang=\"").concat(locale, "\"");
+}
+
+/**
+ * See https://developers.google.com/search/docs/specialty/international/localized-versions
+ */
+function getAlternateLinksHeaderValue(_ref) {
+  var _request$headers$get;
+  let {
+    config,
+    localizedPathnames,
+    request,
+    resolvedLocale
+  } = _ref;
+  const normalizedUrl = request.nextUrl.clone();
+  const host = utils.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, config.locales);
+  function getLocalizedPathname(pathname, locale) {
+    if (localizedPathnames && typeof localizedPathnames === 'object') {
+      return utils.formatTemplatePathname(pathname, localizedPathnames[resolvedLocale], localizedPathnames[locale]);
+    } else {
+      return pathname;
+    }
+  }
+  const links = config.locales.flatMap(locale => {
+    function prefixPathname(pathname) {
+      if (pathname === '/') {
+        return "/".concat(locale);
+      } else {
+        return "/".concat(locale).concat(pathname);
+      }
+    }
+    let url;
+    if (config.domains) {
+      const domainConfigs = config.domains.filter(cur => utils.isLocaleSupportedOnDomain(locale, cur)) || [];
+      return domainConfigs.map(domainConfig => {
+        url = new URL(normalizedUrl);
+        url.port = '';
+        url.host = domainConfig.domain;
+        url.pathname = getLocalizedPathname(url.pathname, locale);
+        if (locale !== domainConfig.defaultLocale || config.localePrefix === 'always') {
+          url.pathname = prefixPathname(url.pathname);
+        }
+        return getAlternateEntry(url.toString(), locale);
+      });
+    } else {
+      let pathname;
+      if (localizedPathnames && typeof localizedPathnames === 'object') {
+        pathname = getLocalizedPathname(normalizedUrl.pathname, locale);
+      } else {
+        pathname = normalizedUrl.pathname;
+      }
+      if (locale !== config.defaultLocale || config.localePrefix === 'always') {
+        pathname = prefixPathname(pathname);
+      }
+      url = new URL(pathname, normalizedUrl);
+    }
+    return getAlternateEntry(url.toString(), locale);
+  });
+
+  // Add x-default entry
+  if (!config.domains) {
+    const url = new URL(getLocalizedPathname(normalizedUrl.pathname, config.defaultLocale), normalizedUrl);
+    links.push(getAlternateEntry(url.toString(), 'x-default'));
+  }
+  return links.join(', ');
+}
+
+exports.default = getAlternateLinksHeaderValue;

package/dist/development/middleware/middleware.js

@@ -0,0 +1,146 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var server = require('next/server');
+var constants = require('../shared/constants.js');
+var utils$1 = require('../shared/utils.js');
+var getAlternateLinksHeaderValue = require('./getAlternateLinksHeaderValue.js');
+var resolveLocale = require('./resolveLocale.js');
+var utils = require('./utils.js');
+
+const ROOT_URL = '/';
+function receiveConfig(config) {
+  var _config$alternateLink, _config$localePrefix, _config$localeDetecti;
+  const result = {
+    ...config,
+    alternateLinks: (_config$alternateLink = config.alternateLinks) !== null && _config$alternateLink !== void 0 ? _config$alternateLink : true,
+    localePrefix: (_config$localePrefix = config.localePrefix) !== null && _config$localePrefix !== void 0 ? _config$localePrefix : 'always',
+    localeDetection: (_config$localeDetecti = config.localeDetection) !== null && _config$localeDetecti !== void 0 ? _config$localeDetecti : true
+  };
+  return result;
+}
+function createMiddleware(config) {
+  const configWithDefaults = receiveConfig(config);
+  return function middleware(request) {
+    var _request$cookies$get, _configWithDefaults$d;
+    const {
+      domain,
+      locale
+    } = resolveLocale.default(configWithDefaults, request.headers, request.cookies, request.nextUrl.pathname);
+    const hasOutdatedCookie = ((_request$cookies$get = request.cookies.get(constants.COOKIE_LOCALE_NAME)) === null || _request$cookies$get === void 0 ? void 0 : _request$cookies$get.value) !== locale;
+    const hasMatchedDefaultLocale = domain ? domain.defaultLocale === locale : locale === configWithDefaults.defaultLocale;
+    const domainConfigs = ((_configWithDefaults$d = configWithDefaults.domains) === null || _configWithDefaults$d === void 0 ? void 0 : _configWithDefaults$d.filter(curDomain => utils.isLocaleSupportedOnDomain(locale, curDomain))) || [];
+    const hasUnknownHost = configWithDefaults.domains != null && !domain;
+    function getResponseInit() {
+      const headers = new Headers(request.headers);
+      headers.set(constants.HEADER_LOCALE_NAME, locale);
+      return {
+        request: {
+          headers
+        }
+      };
+    }
+    function rewrite(url) {
+      return server.NextResponse.rewrite(new URL(url, request.url), getResponseInit());
+    }
+    function redirect(url, host) {
+      const urlObj = new URL(url, request.url);
+      if (domainConfigs.length > 0) {
+        if (!host) {
+          const bestMatchingDomain = utils.getBestMatchingDomain(domain, locale, domainConfigs);
+          if (bestMatchingDomain) {
+            host = bestMatchingDomain.domain;
+            if (bestMatchingDomain.defaultLocale === locale && configWithDefaults.localePrefix === 'as-needed') {
+              urlObj.pathname = urlObj.pathname.replace("/".concat(locale), '');
+            }
+          }
+        }
+      }
+      if (host) {
+        urlObj.host = host;
+      }
+      return server.NextResponse.redirect(urlObj.toString());
+    }
+    const normalizedPathname = utils.getNormalizedPathname(request.nextUrl.pathname, configWithDefaults.locales);
+    const pathLocale = utils.getKnownLocaleFromPathname(request.nextUrl.pathname, configWithDefaults.locales);
+    const hasLocalePrefix = pathLocale != null;
+    let response;
+    let internalTemplateName;
+    let pathname = request.nextUrl.pathname;
+    if (configWithDefaults.pathnames) {
+      let resolvedTemplateLocale;
+      [resolvedTemplateLocale = locale, internalTemplateName] = utils.getInternalTemplate(configWithDefaults.pathnames, normalizedPathname);
+      if (internalTemplateName) {
+        const pathnameConfig = configWithDefaults.pathnames[internalTemplateName];
+        const localeTemplate = typeof pathnameConfig === 'string' ? pathnameConfig : pathnameConfig[locale];
+        if (utils$1.matchesPathname(localeTemplate, normalizedPathname)) {
+          pathname = utils.formatTemplatePathname(normalizedPathname, localeTemplate, internalTemplateName, pathLocale);
+        } else {
+          const isDefaultLocale = configWithDefaults.defaultLocale === locale || (domain === null || domain === void 0 ? void 0 : domain.defaultLocale) === locale;
+          response = redirect(utils.getPathWithSearch(utils.formatTemplatePathname(normalizedPathname, typeof pathnameConfig === 'string' ? pathnameConfig : pathnameConfig[resolvedTemplateLocale], localeTemplate, pathLocale || !isDefaultLocale ? locale : undefined), request.nextUrl.search));
+        }
+      }
+    }
+    if (!response) {
+      if (pathname === ROOT_URL) {
+        const pathWithSearch = utils.getPathWithSearch("/".concat(locale), request.nextUrl.search);
+        if (configWithDefaults.localePrefix === 'never' || hasMatchedDefaultLocale && configWithDefaults.localePrefix === 'as-needed') {
+          response = rewrite(pathWithSearch);
+        } else {
+          response = redirect(pathWithSearch);
+        }
+      } else {
+        const pathWithSearch = utils.getPathWithSearch(pathname, request.nextUrl.search);
+        if (hasLocalePrefix) {
+          const basePath = utils.getBasePath(pathWithSearch, pathLocale);
+          if (configWithDefaults.localePrefix === 'never') {
+            response = redirect(basePath);
+          } else if (pathLocale === locale) {
+            if (hasMatchedDefaultLocale && configWithDefaults.localePrefix === 'as-needed') {
+              response = redirect(basePath);
+            } else {
+              if (configWithDefaults.domains) {
+                const pathDomain = utils.getBestMatchingDomain(domain, pathLocale, domainConfigs);
+                if ((domain === null || domain === void 0 ? void 0 : domain.domain) !== (pathDomain === null || pathDomain === void 0 ? void 0 : pathDomain.domain) && !hasUnknownHost) {
+                  response = redirect(basePath, pathDomain === null || pathDomain === void 0 ? void 0 : pathDomain.domain);
+                } else {
+                  response = rewrite(pathWithSearch);
+                }
+              } else {
+                response = rewrite(pathWithSearch);
+              }
+            }
+          } else {
+            response = redirect("/".concat(locale).concat(basePath));
+          }
+        } else {
+          if (configWithDefaults.localePrefix === 'never' || hasMatchedDefaultLocale && (configWithDefaults.localePrefix === 'as-needed' || configWithDefaults.domains)) {
+            response = rewrite("/".concat(locale).concat(pathWithSearch));
+          } else {
+            response = redirect("/".concat(locale).concat(pathWithSearch));
+          }
+        }
+      }
+    }
+    if (hasOutdatedCookie) {
+      response.cookies.set(constants.COOKIE_LOCALE_NAME, locale, {
+        sameSite: 'strict',
+        maxAge: 31536000 // 1 year
+      });
+    }
+
+    if (configWithDefaults.localePrefix !== 'never' && configWithDefaults.alternateLinks && configWithDefaults.locales.length > 1) {
+      var _configWithDefaults$p;
+      response.headers.set('Link', getAlternateLinksHeaderValue.default({
+        config: configWithDefaults,
+        localizedPathnames: internalTemplateName != null ? (_configWithDefaults$p = configWithDefaults.pathnames) === null || _configWithDefaults$p === void 0 ? void 0 : _configWithDefaults$p[internalTemplateName] : undefined,
+        request,
+        resolvedLocale: locale
+      }));
+    }
+    return response;
+  };
+}
+
+exports.default = createMiddleware;

package/dist/development/middleware/resolveLocale.js

@@ -0,0 +1,110 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var intlLocalematcher = require('@formatjs/intl-localematcher');
+var Negotiator = require('negotiator');
+var constants = require('../shared/constants.js');
+var utils = require('./utils.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Negotiator__default = /*#__PURE__*/_interopDefault(Negotiator);
+
+function findDomainFromHost(requestHeaders, domains) {
+  var _host;
+  let host = utils.getHost(requestHeaders);
+
+  // Remove port (easier for local development)
+  host = (_host = host) === null || _host === void 0 ? void 0 : _host.replace(/:\d+$/, '');
+  if (host && domains) {
+    return domains.find(cur => cur.domain === host);
+  }
+  return undefined;
+}
+function getAcceptLanguageLocale(requestHeaders, locales, defaultLocale) {
+  let locale;
+  const languages = new Negotiator__default.default({
+    headers: {
+      'accept-language': requestHeaders.get('accept-language') || undefined
+    }
+  }).languages();
+  try {
+    locale = intlLocalematcher.match(languages, locales, defaultLocale);
+  } catch (e) {
+    // Invalid language
+  }
+  return locale;
+}
+function resolveLocaleFromPrefix(_ref, requestHeaders, requestCookies, pathname) {
+  let {
+    defaultLocale,
+    localeDetection,
+    locales
+  } = _ref;
+  let locale;
+
+  // Prio 1: Use route prefix
+  if (pathname) {
+    const pathLocale = utils.getLocaleFromPathname(pathname);
+    if (locales.includes(pathLocale)) {
+      locale = pathLocale;
+    }
+  }
+
+  // Prio 2: Use existing cookie
+  if (!locale && localeDetection && requestCookies) {
+    if (requestCookies.has(constants.COOKIE_LOCALE_NAME)) {
+      var _requestCookies$get;
+      const value = (_requestCookies$get = requestCookies.get(constants.COOKIE_LOCALE_NAME)) === null || _requestCookies$get === void 0 ? void 0 : _requestCookies$get.value;
+      if (value && locales.includes(value)) {
+        locale = value;
+      }
+    }
+  }
+
+  // Prio 3: Use the `accept-language` header
+  if (!locale && localeDetection && requestHeaders) {
+    locale = getAcceptLanguageLocale(requestHeaders, locales, defaultLocale);
+  }
+
+  // Prio 4: Use default locale
+  if (!locale) {
+    locale = defaultLocale;
+  }
+  return locale;
+}
+function resolveLocaleFromDomain(config, requestHeaders, requestCookies, pathname) {
+  const {
+    domains
+  } = config;
+  const localeFromPrefixStrategy = resolveLocaleFromPrefix(config, requestHeaders, requestCookies, pathname);
+
+  // Prio 1: Use a domain
+  if (domains) {
+    const domain = findDomainFromHost(requestHeaders, domains);
+    const hasLocalePrefix = pathname && pathname.startsWith("/".concat(localeFromPrefixStrategy));
+    if (domain) {
+      return {
+        locale: utils.isLocaleSupportedOnDomain(localeFromPrefixStrategy, domain) || hasLocalePrefix ? localeFromPrefixStrategy : domain.defaultLocale,
+        domain
+      };
+    }
+  }
+
+  // Prio 2: Use prefix strategy
+  return {
+    locale: localeFromPrefixStrategy
+  };
+}
+function resolveLocale(config, requestHeaders, requestCookies, pathname) {
+  if (config.domains) {
+    return resolveLocaleFromDomain(config, requestHeaders, requestCookies, pathname);
+  } else {
+    return {
+      locale: resolveLocaleFromPrefix(config, requestHeaders, requestCookies, pathname)
+    };
+  }
+}
+
+exports.default = resolveLocale;

package/dist/development/middleware/utils.js

@@ -0,0 +1,150 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('../shared/utils.js');
+
+function getLocaleFromPathname(pathname) {
+  return pathname.split('/')[1];
+}
+function getInternalTemplate(pathnames, pathname) {
+  for (const [internalPathname, localizedPathnamesOrPathname] of Object.entries(pathnames)) {
+    if (typeof localizedPathnamesOrPathname === 'string') {
+      const localizedPathname = localizedPathnamesOrPathname;
+      if (utils.matchesPathname(localizedPathname, pathname)) {
+        return [undefined, internalPathname];
+      }
+    } else {
+      for (const [locale, localizedPathname] of Object.entries(localizedPathnamesOrPathname)) {
+        if (utils.matchesPathname(localizedPathname, pathname)) {
+          return [locale, internalPathname];
+        }
+      }
+    }
+  }
+  return [undefined, undefined];
+}
+function formatTemplatePathname(sourcePathname, sourceTemplate, targetTemplate, localePrefix) {
+  const params = getRouteParams(sourceTemplate, sourcePathname);
+  let targetPathname = '';
+  if (localePrefix) {
+    targetPathname = "/".concat(localePrefix);
+  }
+  targetPathname += formatPathname(targetTemplate, params);
+  if (targetPathname.endsWith('/')) {
+    targetPathname = targetPathname.slice(0, -1);
+  }
+  return targetPathname;
+}
+
+/**
+ * Removes potential locales from the pathname.
+ */
+function getNormalizedPathname(pathname, locales) {
+  // Add trailing slash for consistent handling
+  // both for the root as well as nested paths
+  if (!pathname.endsWith('/')) {
+    pathname += '/';
+  }
+  const match = pathname.match("^/(".concat(locales.join('|'), ")(.*)"));
+  let result = match ? match[2] : pathname;
+
+  // Remove trailing slash
+  if (result.endsWith('/') && result !== '/') {
+    result = result.slice(0, -1);
+  }
+  return result;
+}
+function getKnownLocaleFromPathname(pathname, locales) {
+  const pathLocaleCandidate = getLocaleFromPathname(pathname);
+  const pathLocale = locales.includes(pathLocaleCandidate) ? pathLocaleCandidate : undefined;
+  return pathLocale;
+}
+function getBasePath(pathname, pathLocale) {
+  let result = pathname.replace("/".concat(pathLocale), '');
+  if (!result.startsWith('/')) {
+    result = "/".concat(result);
+  }
+  return result;
+}
+function getRouteParams(template, pathname) {
+  const regex = utils.templateToRegex(template);
+  const match = regex.exec(pathname);
+  if (!match) return undefined;
+  const params = {};
+  for (let i = 1; i < match.length; i++) {
+    var _template$match;
+    const key = (_template$match = template.match(/\[([^\]]+)\]/g)) === null || _template$match === void 0 ? void 0 : _template$match[i - 1].replace(/[[\]]/g, '');
+    if (key) params[key] = match[i];
+  }
+  return params;
+}
+function formatPathname(template, params) {
+  if (!params) return template;
+
+  // Simplify syntax for optional catchall ('[[...slug]]') so
+  // we can replace the value with simple interpolation
+  template = template.replaceAll('[[', '[').replaceAll(']]', ']');
+  let result = template;
+  Object.entries(params).forEach(_ref => {
+    let [key, value] = _ref;
+    result = result.replace("[".concat(key, "]"), value);
+  });
+  return result;
+}
+function getPathWithSearch(pathname, search) {
+  let pathWithSearch = pathname;
+  if (search) {
+    pathWithSearch += search;
+  }
+  return pathWithSearch;
+}
+function getHost(requestHeaders) {
+  var _ref2, _requestHeaders$get;
+  return (_ref2 = (_requestHeaders$get = requestHeaders.get('x-forwarded-host')) !== null && _requestHeaders$get !== void 0 ? _requestHeaders$get : requestHeaders.get('host')) !== null && _ref2 !== void 0 ? _ref2 : undefined;
+}
+function isLocaleSupportedOnDomain(locale, domain) {
+  return domain.defaultLocale === locale || !domain.locales || domain.locales.includes(locale);
+}
+function getBestMatchingDomain(curHostDomain, locale, domainConfigs) {
+  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 = domainConfigs.find(cur => cur.defaultLocale === locale);
+  }
+
+  // Prio 3: Use alternative domain with restricted matching locale
+  if (!domainConfig) {
+    domainConfig = domainConfigs.find(cur => cur.locales != null && 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) {
+    domainConfig = curHostDomain;
+  }
+
+  // Prio 5: Use alternative domain that supports all locales
+  if (!domainConfig) {
+    domainConfig = domainConfigs.find(cur => !cur.locales);
+  }
+  return domainConfig;
+}
+
+exports.formatPathname = formatPathname;
+exports.formatTemplatePathname = formatTemplatePathname;
+exports.getBasePath = getBasePath;
+exports.getBestMatchingDomain = getBestMatchingDomain;
+exports.getHost = getHost;
+exports.getInternalTemplate = getInternalTemplate;
+exports.getKnownLocaleFromPathname = getKnownLocaleFromPathname;
+exports.getLocaleFromPathname = getLocaleFromPathname;
+exports.getNormalizedPathname = getNormalizedPathname;
+exports.getPathWithSearch = getPathWithSearch;
+exports.getRouteParams = getRouteParams;
+exports.isLocaleSupportedOnDomain = isLocaleSupportedOnDomain;

package/dist/development/middleware.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var middleware = require('./middleware/middleware.js');
+
+
+
+exports.default = middleware.default;

package/dist/development/navigation/BaseLink.js

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../_virtual/_rollupPluginBabelHelpers.js');
+var React = require('react');
+var useLocale = require('../react-client/useLocale.js');
+var BaseLinkWithLocale = require('../shared/BaseLinkWithLocale.js');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+function BaseLink(_ref, ref) {
+  let {
+    locale,
+    ...rest
+  } = _ref;
+  const defaultLocale = useLocale.default();
+  const linkLocale = locale || defaultLocale;
+  return /*#__PURE__*/React__default.default.createElement(BaseLinkWithLocale.default, _rollupPluginBabelHelpers.extends({
+    ref: ref,
+    hrefLang: linkLocale,
+    locale: linkLocale
+  }, rest));
+}
+
+/**
+ * Wraps `next/link` and prefixes the `href` with the current locale if
+ * necessary.
+ *
+ * @example
+ * ```tsx
+ * import {Link} from 'next-intl';
+ *
+ * // When the user is on `/en`, the link will point to `/en/about`
+ * <Link href="/about">About</Link>
+ *
+ * // You can override the `locale` to switch to another language
+ * <Link href="/" locale="de">Switch to German</Link>
+ * ```
+ *
+ * Note that when a `locale` prop is passed to switch the locale, the `prefetch`
+ * prop is not supported. This is because Next.js would prefetch the page and
+ * the `set-cookie` response header would cause the locale cookie on the current
+ * page to be overwritten before the user even decides to change the locale.
+ */
+const BaseLinkWithRef = /*#__PURE__*/React.forwardRef(BaseLink);
+BaseLinkWithRef.displayName = 'Link';
+var BaseLink$1 = BaseLinkWithRef;
+
+exports.default = BaseLink$1;