@depup/next-intl 4.8.3-depup.0

package/dist/esm/development/plugin/extractor/initExtractionCompiler.js

@@ -0,0 +1,59 @@
+import ExtractionCompiler from '../../extractor/ExtractionCompiler.js';
+import { isDevelopment, isNextBuild } from '../config.js';
+import { once } from '../utils.js';
+
+// Single compiler instance, initialized once per process
+let compiler;
+const runOnce = once('_NEXT_INTL_EXTRACT');
+function initExtractionCompiler(pluginConfig) {
+  const experimental = pluginConfig.experimental;
+  if (!experimental?.extract) {
+    return;
+  }
+
+  // Avoid running for:
+  // - info
+  // - start
+  // - typegen
+  //
+  // Doesn't consult Next.js config anyway:
+  // - telemetry
+  // - lint
+  //
+  // What remains are:
+  // - dev (NODE_ENV=development)
+  // - build (NODE_ENV=production)
+  const shouldRun = isDevelopment || isNextBuild;
+  if (!shouldRun) return;
+  runOnce(() => {
+    const extractorConfig = {
+      srcPath: experimental.srcPath,
+      sourceLocale: experimental.extract.sourceLocale,
+      messages: experimental.messages
+    };
+    compiler = new ExtractionCompiler(extractorConfig, {
+      isDevelopment,
+      projectRoot: process.cwd()
+    });
+
+    // Fire-and-forget: Start extraction, don't block config return.
+    // In dev mode, this also starts the file watcher.
+    // In prod, ideally we would wait until the extraction is complete,
+    // but we can't `await` anywhere (at least for Turbopack).
+    // The result is ok though, as if we encounter untranslated messages,
+    // we'll simply add empty messages to the catalog. So for actually
+    // running the app, there is no difference.
+    compiler.extractAll();
+    function cleanup() {
+      if (compiler) {
+        compiler[Symbol.dispose]();
+        compiler = undefined;
+      }
+    }
+    process.on('exit', cleanup);
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+  });
+}
+
+export { initExtractionCompiler as default };

package/dist/esm/development/plugin/getNextConfig.js

@@ -0,0 +1,267 @@
+import fs from 'fs';
+import { createRequire } from 'module';
+import path from 'path';
+import { getFormatExtension } from '../extractor/format/index.js';
+import SourceFileFilter from '../extractor/source/SourceFileFilter.js';
+import { isDevelopmentOrNextBuild } from './config.js';
+import { isNextJs16OrHigher, hasStableTurboConfig } from './nextFlags.js';
+import { throwError } from './utils.js';
+
+const require$1 = createRequire(import.meta.url);
+function withExtensions(localPath) {
+  return [`${localPath}.ts`, `${localPath}.tsx`, `${localPath}.js`, `${localPath}.jsx`];
+}
+function normalizeTurbopackAliasPath(pathname) {
+  // Turbopack alias targets should use forward slashes; Windows backslashes can
+  // break resolution in dev (see `next-intl/config` alias path style).
+  return pathname.replace(/\\/g, '/');
+}
+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) {
+    // We use the `isNextDevOrBuild` condition to avoid throwing errors
+    // if `next.config.ts` is read by a non-Next.js process.
+    // https://github.com/amannn/next-intl/discussions/2209#discussioncomment-15650927
+    if (isDevelopmentOrNextBuild && !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;
+      }
+    }
+    if (isDevelopmentOrNextBuild) {
+      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(\n  './path/to/i18n/request.tsx'\n);`);
+    }
+
+    // Default as fallback
+    if (pathExists('./src')) {
+      return './src/i18n/request.ts';
+    } else {
+      return './i18n/request.ts';
+    }
+  }
+}
+function getNextConfig(pluginConfig, nextConfig) {
+  const useTurbo = process.env.TURBOPACK != null;
+
+  // `experimental-analyze` doesn’t set the TURBOPACK env param. Since Next.js
+  // 16 doesn't print a warning when we configure both Turbo- and Webpack, just
+  // always configure Turbopack just in case.
+  const shouldConfigureTurbo = useTurbo || isNextJs16OrHigher();
+  const nextIntlConfig = {};
+  function getExtractMessagesLoaderConfig() {
+    const experimental = pluginConfig.experimental;
+    if (!experimental.srcPath || !pluginConfig.experimental?.messages) {
+      throwError('`srcPath` and `messages` are required when using `extractor`.');
+    }
+    return {
+      loader: 'next-intl/extractor/extractionLoader',
+      options: {
+        srcPath: experimental.srcPath,
+        sourceLocale: experimental.extract.sourceLocale,
+        messages: pluginConfig.experimental.messages
+      }
+    };
+  }
+  function getCatalogLoaderConfig() {
+    return {
+      loader: 'next-intl/extractor/catalogLoader',
+      options: {
+        messages: pluginConfig.experimental.messages
+      }
+    };
+  }
+  function getTurboRules() {
+    return nextConfig?.turbopack?.rules ||
+    // @ts-expect-error -- For Next.js <16
+    nextConfig?.experimental?.turbo?.rules || {};
+  }
+  function addTurboRule(rules, glob, rule) {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (rules[glob]) {
+      if (Array.isArray(rules[glob])) {
+        rules[glob].push(rule);
+      } else {
+        rules[glob] = [rules[glob], rule];
+      }
+    } else {
+      rules[glob] = rule;
+    }
+  }
+
+  // Validate messages config
+  if (pluginConfig.experimental?.messages) {
+    const messages = pluginConfig.experimental.messages;
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- For non-TS consumers
+    if (!messages.format) {
+      throwError('`format` is required when using `messages`.');
+    }
+    if (!messages.path) {
+      throwError('`path` is required when using `messages`.');
+    }
+  }
+  if (shouldConfigureTurbo) {
+    if (pluginConfig.requestConfig && path.isAbsolute(pluginConfig.requestConfig)) {
+      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);
+    }
+
+    // Assign alias for `next-intl/config`
+    const resolveAlias = {
+      // Turbo aliases don't work with absolute
+      // paths (see error handling above)
+      'next-intl/config': resolveI18nPath(pluginConfig.requestConfig)
+    };
+
+    // Add alias for precompiled message formatting
+    if (pluginConfig.experimental?.messages?.precompile) {
+      // Workaround for https://github.com/vercel/next.js/issues/88540
+      let formatOnlyPath = path.relative(process.cwd(), require$1.resolve('use-intl/format-message/format-only'));
+
+      // Turbopack seems to require this, otherwise `use-intl/format-message` is
+      // still bundled (despite the code correctly calling into `format-only`).
+      // Note that in this monorepo this is not necessary, because we'll end
+      // up with a path like `../…` — but for actual consumers this is required.
+      if (!formatOnlyPath.startsWith('.')) {
+        formatOnlyPath = `./${formatOnlyPath}`;
+      }
+      resolveAlias['use-intl/format-message'] = normalizeTurbopackAliasPath(formatOnlyPath);
+    }
+
+    // Add loaders
+    let rules;
+
+    // Add loader for extractor
+    if (pluginConfig.experimental?.extract) {
+      if (!isNextJs16OrHigher()) {
+        throwError('Message extraction requires Next.js 16 or higher.');
+      }
+      rules ??= getTurboRules();
+      const srcPaths = (Array.isArray(pluginConfig.experimental.srcPath) ? pluginConfig.experimental.srcPath : [pluginConfig.experimental.srcPath]).map(srcPath => srcPath.endsWith('/') ? srcPath.slice(0, -1) : srcPath);
+      addTurboRule(rules, `*.{${SourceFileFilter.EXTENSIONS.join(',')}}`, {
+        loaders: [getExtractMessagesLoaderConfig()],
+        condition: {
+          // Note: We don't need `not: 'foreign'`, because this is
+          // implied by the filter based on `srcPath`.
+          path: `{${srcPaths.join(',')}}` + '/**/*',
+          content: /(useExtracted|getExtracted)/
+        }
+      });
+    }
+
+    // Add loader for catalog
+    if (pluginConfig.experimental?.messages) {
+      if (!isNextJs16OrHigher()) {
+        throwError('Message catalog loading requires Next.js 16 or higher.');
+      }
+      rules ??= getTurboRules();
+      const extension = getFormatExtension(pluginConfig.experimental.messages.format);
+      addTurboRule(rules, `*${extension}`, {
+        loaders: [getCatalogLoaderConfig()],
+        condition: {
+          path: `${pluginConfig.experimental.messages.path}/**/*`
+        },
+        as: '*.js'
+      });
+    }
+    if (hasStableTurboConfig() &&
+    // @ts-expect-error -- For Next.js <16
+    !nextConfig?.experimental?.turbo) {
+      nextIntlConfig.turbopack = {
+        ...nextConfig?.turbopack,
+        ...(rules && {
+          rules
+        }),
+        resolveAlias: {
+          ...nextConfig?.turbopack?.resolveAlias,
+          ...resolveAlias
+        }
+      };
+    } else {
+      nextIntlConfig.experimental = {
+        ...nextConfig?.experimental,
+        // @ts-expect-error -- For Next.js <16
+        turbo: {
+          // @ts-expect-error -- For Next.js <16
+          ...nextConfig?.experimental?.turbo,
+          ...(rules && {
+            rules
+          }),
+          resolveAlias: {
+            // @ts-expect-error -- For Next.js <16
+            ...nextConfig?.experimental?.turbo?.resolveAlias,
+            ...resolveAlias
+          }
+        }
+      };
+    }
+  }
+  if (!useTurbo) {
+    nextIntlConfig.webpack = function webpack(config, context) {
+      if (!config.resolve) config.resolve = {};
+      if (!config.resolve.alias) config.resolve.alias = {};
+
+      // Assign alias for `next-intl/config`
+      // (Webpack requires absolute paths)
+      config.resolve.alias['next-intl/config'] = path.resolve(config.context, resolveI18nPath(pluginConfig.requestConfig, config.context));
+
+      // Add alias for precompiled message formatting
+      if (pluginConfig.experimental?.messages?.precompile) {
+        // Use require.resolve to get the actual file path, since
+        // bundlers don't properly resolve package subpath exports
+        // when used as alias targets
+        config.resolve.alias['use-intl/format-message'] = require$1.resolve('use-intl/format-message/format-only');
+      }
+
+      // Add loader for extractor
+      if (pluginConfig.experimental?.extract) {
+        if (!config.module) config.module = {};
+        if (!config.module.rules) config.module.rules = [];
+        const srcPath = pluginConfig.experimental.srcPath;
+        config.module.rules.push({
+          test: new RegExp(`\\.(${SourceFileFilter.EXTENSIONS.join('|')})$`),
+          include: Array.isArray(srcPath) ? srcPath.map(cur => path.resolve(config.context, cur)) : path.resolve(config.context, srcPath || ''),
+          use: [getExtractMessagesLoaderConfig()]
+        });
+      }
+
+      // Add loader for catalog
+      if (pluginConfig.experimental?.messages) {
+        if (!config.module) config.module = {};
+        if (!config.module.rules) config.module.rules = [];
+        const extension = getFormatExtension(pluginConfig.experimental.messages.format);
+        config.module.rules.push({
+          test: new RegExp(`${extension.replace(/\./g, '\\.')}$`),
+          include: path.resolve(config.context, pluginConfig.experimental.messages.path),
+          use: [getCatalogLoaderConfig()],
+          type: 'javascript/auto'
+        });
+      }
+      if (typeof nextConfig?.webpack === 'function') {
+        return nextConfig.webpack(config, context);
+      }
+      return config;
+    };
+  }
+
+  // Forward config
+  if (nextConfig?.trailingSlash) {
+    nextIntlConfig.env = {
+      ...nextConfig.env,
+      _next_intl_trailing_slash: 'true'
+    };
+  }
+  return Object.assign({}, nextConfig, nextIntlConfig);
+}
+
+export { getNextConfig as default };

package/dist/esm/development/plugin/nextFlags.js

@@ -0,0 +1,32 @@
+import { createRequire } from 'module';
+
+function getCurrentVersion() {
+  try {
+    const require = createRequire(import.meta.url);
+    const pkg = require('next/package.json');
+    return pkg.version;
+  } catch (error) {
+    throw new Error('Failed to get current Next.js version. This can happen if next-intl/plugin is imported into your app code outside of your next.config.js.', {
+      cause: error
+    });
+  }
+}
+function compareVersions(version1, version2) {
+  const v1Parts = version1.split('.').map(Number);
+  const v2Parts = version2.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    const v1 = v1Parts[i] || 0;
+    const v2 = v2Parts[i] || 0;
+    if (v1 > v2) return 1;
+    if (v1 < v2) return -1;
+  }
+  return 0;
+}
+function hasStableTurboConfig() {
+  return compareVersions(getCurrentVersion(), '15.3.0') >= 0;
+}
+function isNextJs16OrHigher() {
+  return compareVersions(getCurrentVersion(), '16.0.0') >= 0;
+}
+
+export { hasStableTurboConfig, isNextJs16OrHigher };

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

@@ -0,0 +1,26 @@
+function formatMessage(message) {
+  return `\n[next-intl] ${message}\n`;
+}
+function throwError(message) {
+  throw new Error(formatMessage(message));
+}
+function warn(message) {
+  console.warn(formatMessage(message));
+}
+
+/**
+ * Returns a function that runs the provided callback only once per process.
+ * Next.js can call the config multiple times - this ensures we only run once.
+ * Uses an environment variable to track execution across config loads.
+ */
+function once(namespace) {
+  return function runOnce(fn) {
+    if (process.env[namespace] === '1') {
+      return;
+    }
+    process.env[namespace] = '1';
+    fn();
+  };
+}
+
+export { once, throwError, warn };

package/dist/esm/development/plugin/watchFile.js

@@ -0,0 +1,21 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Wrapper around `fs.watch` that provides a workaround
+ * for https://github.com/nodejs/node/issues/5039.
+ */
+function watchFile(filepath, callback) {
+  const directory = path.dirname(filepath);
+  const filename = path.basename(filepath);
+  return fs.watch(directory, {
+    persistent: false,
+    recursive: false
+  }, (event, changedFilename) => {
+    if (changedFilename === filename) {
+      callback();
+    }
+  });
+}
+
+export { watchFile as default };

package/dist/esm/development/plugin.js

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

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

@@ -0,0 +1,34 @@
+import { useFormatter as useFormatter$1, useTranslations as useTranslations$1 } from 'use-intl';
+
+/**
+ * This is the main entry file when non-'react-server'
+ * environments import from 'next-intl'.
+ *
+ * Maintainer notes:
+ * - Make sure this mirrors the API from 'react-server'.
+ * - Make sure everything exported from this module is
+ *   supported in all Next.js versions that are supported.
+ */
+
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+function callHook(name, hook) {
+  return (...args) => {
+    try {
+      return hook(...args);
+    } catch {
+      throw new Error(`Failed to call \`${name}\` because the context from \`NextIntlClientProvider\` was not found.
+
+This can happen because:
+1) You intended to render this component as a Server Component, the render
+   failed, and therefore React attempted to render the component on the client
+   instead. If this is the case, check the console for server errors.
+2) You intended to render this component on the client side, but no context was found.
+   Learn more about this error here: https://next-intl.dev/docs/environments/server-client-components#missing-context` );
+    }
+  };
+}
+const useTranslations = callHook('useTranslations', useTranslations$1);
+const useFormatter = callHook('useFormatter', useFormatter$1);
+
+export { useFormatter, useTranslations };

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

@@ -0,0 +1,34 @@
+import getConfigNow from '../server/react-server/getConfigNow.js';
+import getFormats from '../server/react-server/getFormats.js';
+import NextIntlClientProvider from '../shared/NextIntlClientProvider.js';
+import { jsx } from 'react/jsx-runtime';
+import getTimeZone from '../server/react-server/getTimeZone.js';
+import getMessages from '../server/react-server/getMessages.js';
+import getLocaleCached from '../server/react-server/getLocale.js';
+
+async function NextIntlClientProviderServer({
+  formats,
+  locale,
+  messages,
+  now,
+  timeZone,
+  ...rest
+}) {
+  return /*#__PURE__*/jsx(NextIntlClientProvider
+  // We need to be careful about potentially reading from headers here.
+  // See https://github.com/amannn/next-intl/issues/631
+  , {
+    formats: formats === undefined ? await getFormats() : formats,
+    locale: locale ?? (await getLocaleCached()),
+    messages: messages === undefined ? await getMessages() : messages
+    // Note that we don't assign a default for `now` here,
+    // we only read one from the request config - if any.
+    // Otherwise this would cause a `dynamicIO` error.
+    ,
+    now: now ?? (await getConfigNow()),
+    timeZone: timeZone ?? (await getTimeZone()),
+    ...rest
+  });
+}
+
+export { NextIntlClientProviderServer as default };

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

@@ -0,0 +1,21 @@
+import getConfig from '../server/react-server/getConfig.js';
+import use from '../shared/use.js';
+
+function useHook(hookName, promise) {
+  try {
+    return use(promise);
+  } catch (error) {
+    if (error instanceof TypeError && error.message.includes("Cannot read properties of null (reading 'use')")) {
+      throw new Error(`\`${hookName}\` is not callable within an async component. Please refer to https://next-intl.dev/docs/environments/server-client-components#async-components`, {
+        cause: error
+      });
+    } else {
+      throw error;
+    }
+  }
+}
+function useConfig(hookName) {
+  return useHook(hookName, getConfig());
+}
+
+export { useConfig as default };

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

@@ -0,0 +1,9 @@
+import getServerExtractor from '../server/react-server/getServerExtractor.js';
+import useConfig from './useConfig.js';
+
+function useExtracted(namespace) {
+  const config = useConfig('useExtracted');
+  return getServerExtractor(config, namespace);
+}
+
+export { useExtracted as default };

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

@@ -0,0 +1,9 @@
+import getFormatterCached from '../server/react-server/getServerFormatter.js';
+import useConfig from './useConfig.js';
+
+function useFormatter() {
+  const config = useConfig('useFormatter');
+  return getFormatterCached(config);
+}
+
+export { useFormatter as default };

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

@@ -0,0 +1,8 @@
+import useConfig from './useConfig.js';
+
+function useLocale() {
+  const config = useConfig('useLocale');
+  return config.locale;
+}
+
+export { useLocale as default };

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

@@ -0,0 +1,9 @@
+import { getMessagesFromConfig } from '../server/react-server/getMessages.js';
+import useConfig from './useConfig.js';
+
+function useMessages() {
+  const config = useConfig('useMessages');
+  return getMessagesFromConfig(config);
+}
+
+export { useMessages as default };

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

@@ -0,0 +1,12 @@
+import getDefaultNow from '../server/react-server/getDefaultNow.js';
+import useConfig from './useConfig.js';
+
+function useNow(options) {
+  if (options?.updateInterval != null) {
+    console.error("`useNow` doesn't support the `updateInterval` option in Server Components, the value will be ignored. If you need the value to update, you can convert the component to a Client Component.");
+  }
+  const config = useConfig('useNow');
+  return config.now ?? getDefaultNow();
+}
+
+export { useNow as default };

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

@@ -0,0 +1,8 @@
+import useConfig from './useConfig.js';
+
+function useTimeZone() {
+  const config = useConfig('useTimeZone');
+  return config.timeZone;
+}
+
+export { useTimeZone as default };

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

@@ -0,0 +1,9 @@
+import getServerTranslator from '../server/react-server/getServerTranslator.js';
+import useConfig from './useConfig.js';
+
+function useTranslations(...[namespace]) {
+  const config = useConfig('useTranslations');
+  return getServerTranslator(config, namespace);
+}
+
+export { useTranslations as default };

package/dist/esm/development/routing/config.js

@@ -0,0 +1,26 @@
+function receiveRoutingConfig(input) {
+  return {
+    ...input,
+    localePrefix: receiveLocalePrefixConfig(input.localePrefix),
+    localeCookie: receiveLocaleCookie(input.localeCookie),
+    localeDetection: input.localeDetection ?? true,
+    alternateLinks: input.alternateLinks ?? true
+  };
+}
+function receiveLocaleCookie(localeCookie) {
+  return localeCookie ?? true ? {
+    name: 'NEXT_LOCALE',
+    sameSite: 'lax',
+    ...(typeof localeCookie === 'object' && localeCookie)
+
+    // `path` needs to be provided based on a detected base path
+    // that depends on the environment when setting a cookie
+  } : false;
+}
+function receiveLocalePrefixConfig(localePrefix) {
+  return typeof localePrefix === 'object' ? localePrefix : {
+    mode: localePrefix || 'always'
+  };
+}
+
+export { receiveRoutingConfig };

package/dist/esm/development/routing/defineRouting.js

@@ -0,0 +1,25 @@
+function defineRouting(config) {
+  if (config.domains) {
+    validateUniqueLocalesPerDomain(config.domains);
+  }
+  return config;
+}
+function validateUniqueLocalesPerDomain(domains) {
+  const domainsByLocale = new Map();
+  for (const {
+    domain,
+    locales
+  } of domains) {
+    for (const locale of locales) {
+      const localeDomains = domainsByLocale.get(locale) || new Set();
+      localeDomains.add(domain);
+      domainsByLocale.set(locale, localeDomains);
+    }
+  }
+  const duplicateLocaleMessages = Array.from(domainsByLocale.entries()).filter(([, localeDomains]) => localeDomains.size > 1).map(([locale, localeDomains]) => `- "${locale}" is used by: ${Array.from(localeDomains).join(', ')}`);
+  if (duplicateLocaleMessages.length > 0) {
+    console.warn('Locales are expected to be unique per domain, but found overlap:\n' + duplicateLocaleMessages.join('\n') + '\nPlease see https://next-intl.dev/docs/routing/configuration#domains');
+  }
+}
+
+export { defineRouting as default };

package/dist/esm/development/routing.js

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

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

@@ -0,0 +1,32 @@
+/**
+ * Allows to import `next-intl/server` in non-RSC environments.
+ *
+ * This is mostly relevant for testing, since e.g. a `generateMetadata`
+ * export from a page might use `next-intl/server`, but the test
+ * only uses the default export for a page.
+ */
+
+function notSupported(message) {
+  return () => {
+    throw new Error(`\`${message}\` is not supported in Client Components.`);
+  };
+}
+function getRequestConfig(
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+...args) {
+  return notSupported('getRequestConfig');
+}
+const getFormatter = notSupported('getFormatter');
+const getNow = notSupported('getNow');
+const getTimeZone = notSupported('getTimeZone');
+const getMessages = notSupported('getMessages');
+const getLocale = notSupported('getLocale');
+const getExtracted = notSupported('getExtracted');
+
+// The type of `getTranslations` is not assigned here because it
+// causes a type error. The types use the `react-server` entry
+// anyway, therefore this is irrelevant.
+const getTranslations = notSupported('getTranslations');
+const setRequestLocale = notSupported('setRequestLocale');
+
+export { getExtracted, getFormatter, getLocale, getMessages, getNow, getRequestConfig, getTimeZone, getTranslations, setRequestLocale };