use-intl 0.0.0-canary-255c5c2 → 0.0.0-canary-fdaddc5

package/dist/{development/createFormatter-QqAaZwGD.js → esm/development/initializeConfig-CRD6euuK.js}

@@ -1,27 +1,32 @@
-'use strict';
+import { IntlMessageFormat } from 'intl-messageformat';
+import { isValidElement, cloneElement } from 'react';
+import { memoize, strategies } from '@formatjs/fast-memoize';
 
-var IntlMessageFormat = require('intl-messageformat');
-var React = require('react');
-var initializeConfig = require('./initializeConfig-BhfMSHP7.js');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var IntlMessageFormat__default = /*#__PURE__*/_interopDefault(IntlMessageFormat);
-
-function setTimeZoneInFormats(formats, timeZone) {
-  if (!formats) return formats;
-
-  // The only way to set a time zone with `intl-messageformat` is to merge it into the formats
-  // https://github.com/formatjs/formatjs/blob/8256c5271505cf2606e48e3c97ecdd16ede4f1b5/packages/intl/src/message.ts#L15
-  return Object.keys(formats).reduce((acc, key) => {
-    acc[key] = {
-      timeZone,
-      ...formats[key]
-    };
-    return acc;
-  }, {});
+class IntlError extends Error {
+  constructor(code, originalMessage) {
+    let message = code;
+    if (originalMessage) {
+      message += ': ' + originalMessage;
+    }
+    super(message);
+    this.code = code;
+    if (originalMessage) {
+      this.originalMessage = originalMessage;
+    }
+  }
 }
 
+var IntlErrorCode = /*#__PURE__*/function (IntlErrorCode) {
+  IntlErrorCode["MISSING_MESSAGE"] = "MISSING_MESSAGE";
+  IntlErrorCode["MISSING_FORMAT"] = "MISSING_FORMAT";
+  IntlErrorCode["ENVIRONMENT_FALLBACK"] = "ENVIRONMENT_FALLBACK";
+  IntlErrorCode["INSUFFICIENT_PATH"] = "INSUFFICIENT_PATH";
+  IntlErrorCode["INVALID_MESSAGE"] = "INVALID_MESSAGE";
+  IntlErrorCode["INVALID_KEY"] = "INVALID_KEY";
+  IntlErrorCode["FORMATTING_ERROR"] = "FORMATTING_ERROR";
+  return IntlErrorCode;
+}(IntlErrorCode || {});
+
 /**
  * `intl-messageformat` uses separate keys for `date` and `time`, but there's
  * only one native API: `Intl.DateTimeFormat`. Additionally you might want to
@@ -29,43 +34,124 @@ function setTimeZoneInFormats(formats, timeZone) {
  * seem so useful. We offer a single `dateTime` namespace instead, but we have
  * to convert the format before `intl-messageformat` can be used.
  */
-function convertFormatsToIntlMessageFormat(formats, timeZone) {
-  const formatsWithTimeZone = timeZone ? {
-    ...formats,
-    dateTime: setTimeZoneInFormats(formats.dateTime, timeZone)
-  } : formats;
-  const mfDateDefaults = IntlMessageFormat__default.default.formats.date;
-  const defaultDateFormats = timeZone ? setTimeZoneInFormats(mfDateDefaults, timeZone) : mfDateDefaults;
-  const mfTimeDefaults = IntlMessageFormat__default.default.formats.time;
-  const defaultTimeFormats = timeZone ? setTimeZoneInFormats(mfTimeDefaults, timeZone) : mfTimeDefaults;
-  return {
-    ...formatsWithTimeZone,
+function convertFormatsToIntlMessageFormat(globalFormats, inlineFormats, timeZone) {
+  const mfDateDefaults = IntlMessageFormat.formats.date;
+  const mfTimeDefaults = IntlMessageFormat.formats.time;
+  const dateTimeFormats = {
+    ...globalFormats?.dateTime,
+    ...inlineFormats?.dateTime
+  };
+  const allFormats = {
     date: {
-      ...defaultDateFormats,
-      ...formatsWithTimeZone.dateTime
+      ...mfDateDefaults,
+      ...dateTimeFormats
     },
     time: {
-      ...defaultTimeFormats,
-      ...formatsWithTimeZone.dateTime
+      ...mfTimeDefaults,
+      ...dateTimeFormats
+    },
+    number: {
+      ...globalFormats?.number,
+      ...inlineFormats?.number
     }
+    // (list is not supported in ICU messages)
+  };
+  if (timeZone) {
+    // The only way to set a time zone with `intl-messageformat` is to merge it into the formats
+    // https://github.com/formatjs/formatjs/blob/8256c5271505cf2606e48e3c97ecdd16ede4f1b5/packages/intl/src/message.ts#L15
+    ['date', 'time'].forEach(property => {
+      const formats = allFormats[property];
+      for (const [key, value] of Object.entries(formats)) {
+        formats[key] = {
+          timeZone,
+          ...value
+        };
+      }
+    });
+  }
+  return allFormats;
+}
+
+function joinPath(...parts) {
+  return parts.filter(Boolean).join('.');
+}
+
+/**
+ * Contains defaults that are used for all entry points into the core.
+ * See also `InitializedIntlConfiguration`.
+ */
+
+function defaultGetMessageFallback(props) {
+  return joinPath(props.namespace, props.key);
+}
+function defaultOnError(error) {
+  console.error(error);
+}
+
+function createCache() {
+  return {
+    dateTime: {},
+    number: {},
+    message: {},
+    relativeTime: {},
+    pluralRules: {},
+    list: {},
+    displayNames: {}
+  };
+}
+function createMemoCache(store) {
+  return {
+    create() {
+      return {
+        get(key) {
+          return store[key];
+        },
+        set(key, value) {
+          store[key] = value;
+        }
+      };
+    }
+  };
+}
+function memoFn(fn, cache) {
+  return memoize(fn, {
+    cache: createMemoCache(cache),
+    strategy: strategies.variadic
+  });
+}
+function memoConstructor(ConstructorFn, cache) {
+  return memoFn((...args) => new ConstructorFn(...args), cache);
+}
+function createIntlFormatters(cache) {
+  const getDateTimeFormat = memoConstructor(Intl.DateTimeFormat, cache.dateTime);
+  const getNumberFormat = memoConstructor(Intl.NumberFormat, cache.number);
+  const getPluralRules = memoConstructor(Intl.PluralRules, cache.pluralRules);
+  const getRelativeTimeFormat = memoConstructor(Intl.RelativeTimeFormat, cache.relativeTime);
+  const getListFormat = memoConstructor(Intl.ListFormat, cache.list);
+  const getDisplayNames = memoConstructor(Intl.DisplayNames, cache.displayNames);
+  return {
+    getDateTimeFormat,
+    getNumberFormat,
+    getPluralRules,
+    getRelativeTimeFormat,
+    getListFormat,
+    getDisplayNames
   };
 }
 
 // Placed here for improved tree shaking. Somehow when this is placed in
 // `formatters.tsx`, then it can't be shaken off from `next-intl`.
 function createMessageFormatter(cache, intlFormatters) {
-  const getMessageFormat = initializeConfig.memoFn(function () {
-    return new IntlMessageFormat__default.default(arguments.length <= 0 ? undefined : arguments[0], arguments.length <= 1 ? undefined : arguments[1], arguments.length <= 2 ? undefined : arguments[2], {
-      formatters: intlFormatters,
-      ...(arguments.length <= 3 ? undefined : arguments[3])
-    });
-  }, cache.message);
+  const getMessageFormat = memoFn((...args) => new IntlMessageFormat(args[0], args[1], args[2], {
+    formatters: intlFormatters,
+    ...args[3]
+  }), cache.message);
   return getMessageFormat;
 }
 function resolvePath(locale, messages, key, namespace) {
-  const fullKey = initializeConfig.joinPath(namespace, key);
+  const fullKey = joinPath(namespace, key);
   if (!messages) {
-    throw new Error("No messages available at `".concat(namespace, "`.") );
+    throw new Error(`No messages available at \`${namespace}\`.` );
   }
   let message = messages;
   key.split('.').forEach(part => {
@@ -73,15 +159,13 @@ function resolvePath(locale, messages, key, namespace) {
 
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (part == null || next == null) {
-      throw new Error("Could not resolve `".concat(fullKey, "` in messages for locale `").concat(locale, "`.") );
+      throw new Error(`Could not resolve \`${fullKey}\` in messages for locale \`${locale}\`.` );
     }
     message = next;
   });
   return message;
 }
 function prepareTranslationValues(values) {
-  if (Object.keys(values).length === 0) return undefined;
-
   // Workaround for https://github.com/formatjs/formatjs/issues/1467
   const transformedValues = {};
   Object.keys(values).forEach(key => {
@@ -91,7 +175,7 @@ function prepareTranslationValues(values) {
     if (typeof value === 'function') {
       transformed = chunks => {
         const result = value(chunks);
-        return /*#__PURE__*/React.isValidElement(result) ? /*#__PURE__*/React.cloneElement(result, {
+        return /*#__PURE__*/isValidElement(result) ? /*#__PURE__*/cloneElement(result, {
           key: key + index++
         }) : result;
       };
@@ -102,37 +186,38 @@ function prepareTranslationValues(values) {
   });
   return transformedValues;
 }
-function getMessagesOrError(locale, messages, namespace) {
-  let onError = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : initializeConfig.defaultOnError;
+function getMessagesOrError(locale, messages, namespace, onError = defaultOnError) {
   try {
     if (!messages) {
-      throw new Error("No messages were configured on the provider." );
+      throw new Error(`No messages were configured.` );
     }
     const retrievedMessages = namespace ? resolvePath(locale, messages, namespace) : messages;
 
     // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (!retrievedMessages) {
-      throw new Error("No messages for namespace `".concat(namespace, "` found.") );
+      throw new Error(`No messages for namespace \`${namespace}\` found.` );
     }
     return retrievedMessages;
   } catch (error) {
-    const intlError = new initializeConfig.IntlError(initializeConfig.IntlErrorCode.MISSING_MESSAGE, error.message);
+    const intlError = new IntlError(IntlErrorCode.MISSING_MESSAGE, error.message);
     onError(intlError);
     return intlError;
   }
 }
 function getPlainMessage(candidate, values) {
-  if (values) return undefined;
-  const unescapedMessage = candidate.replace(/'([{}])/gi, '$1');
+  {
+    // Keep fast path in development
+    if (values) return undefined;
 
-  // Placeholders can be in the message if there are default values,
-  // or if the user has forgotten to provide values. In the latter
-  // case we need to compile the message to receive an error.
-  const hasPlaceholders = /<|{/.test(unescapedMessage);
-  if (!hasPlaceholders) {
-    return unescapedMessage;
+    // Despite potentially no values being available, there can still be
+    // placeholders in the message if the user has forgotten to provide
+    // values. In this case we compile the message to receive an error.
+    const unescapedMessage = candidate.replace(/'([{}])/gi, '$1');
+    const hasPlaceholders = /<|{/.test(unescapedMessage);
+    if (!hasPlaceholders) {
+      return unescapedMessage;
+    }
   }
-  return undefined;
 }
 function createBaseTranslator(config) {
   const messagesOrError = getMessagesOrError(config.locale, config.messages, config.namespace, config.onError);
@@ -141,22 +226,20 @@ function createBaseTranslator(config) {
     messagesOrError
   });
 }
-function createBaseTranslatorImpl(_ref) {
-  let {
-    cache,
-    defaultTranslationValues,
-    formats: globalFormats,
-    formatters,
-    getMessageFallback = initializeConfig.defaultGetMessageFallback,
-    locale,
-    messagesOrError,
-    namespace,
-    onError,
-    timeZone
-  } = _ref;
-  const hasMessagesError = messagesOrError instanceof initializeConfig.IntlError;
+function createBaseTranslatorImpl({
+  cache,
+  formats: globalFormats,
+  formatters,
+  getMessageFallback = defaultGetMessageFallback,
+  locale,
+  messagesOrError,
+  namespace,
+  onError,
+  timeZone
+}) {
+  const hasMessagesError = messagesOrError instanceof IntlError;
   function getFallbackFromErrorAndNotify(key, code, message) {
-    const error = new initializeConfig.IntlError(code, message);
+    const error = new IntlError(code, message);
     onError(error);
     return getMessageFallback({
       error,
@@ -181,19 +264,19 @@ function createBaseTranslatorImpl(_ref) {
     try {
       message = resolvePath(locale, messages, key, namespace);
     } catch (error) {
-      return getFallbackFromErrorAndNotify(key, initializeConfig.IntlErrorCode.MISSING_MESSAGE, error.message);
+      return getFallbackFromErrorAndNotify(key, IntlErrorCode.MISSING_MESSAGE, error.message);
     }
     if (typeof message === 'object') {
       let code, errorMessage;
       if (Array.isArray(message)) {
-        code = initializeConfig.IntlErrorCode.INVALID_MESSAGE;
+        code = IntlErrorCode.INVALID_MESSAGE;
         {
-          errorMessage = "Message at `".concat(initializeConfig.joinPath(namespace, key), "` resolved to an array, but only strings are supported. See https://next-intl.dev/docs/usage/messages#arrays-of-messages");
+          errorMessage = `Message at \`${joinPath(namespace, key)}\` resolved to an array, but only strings are supported. See https://next-intl.dev/docs/usage/messages#arrays-of-messages`;
         }
       } else {
-        code = initializeConfig.IntlErrorCode.INSUFFICIENT_PATH;
+        code = IntlErrorCode.INSUFFICIENT_PATH;
         {
-          errorMessage = "Message at `".concat(initializeConfig.joinPath(namespace, key), "` resolved to an object, but only strings are supported. Use a `.` to retrieve nested messages. See https://next-intl.dev/docs/usage/messages#structuring-messages");
+          errorMessage = `Message at \`${joinPath(namespace, key)}\` resolved to an object, but only strings are supported. Use a \`.\` to retrieve nested messages. See https://next-intl.dev/docs/usage/messages#structuring-messages`;
         }
       }
       return getFallbackFromErrorAndNotify(key, code, errorMessage);
@@ -210,10 +293,7 @@ function createBaseTranslatorImpl(_ref) {
       formatters.getMessageFormat = createMessageFormatter(cache, formatters);
     }
     try {
-      messageFormat = formatters.getMessageFormat(message, locale, convertFormatsToIntlMessageFormat({
-        ...globalFormats,
-        ...formats
-      }, timeZone), {
+      messageFormat = formatters.getMessageFormat(message, locale, convertFormatsToIntlMessageFormat(globalFormats, formats, timeZone), {
         formatters: {
           ...formatters,
           getDateTimeFormat(locales, options) {
@@ -227,7 +307,7 @@ function createBaseTranslatorImpl(_ref) {
       });
     } catch (error) {
       const thrownError = error;
-      return getFallbackFromErrorAndNotify(key, initializeConfig.IntlErrorCode.INVALID_MESSAGE, thrownError.message + ('originalMessage' in thrownError ? " (".concat(thrownError.originalMessage, ")") : '') );
+      return getFallbackFromErrorAndNotify(key, IntlErrorCode.INVALID_MESSAGE, thrownError.message + ('originalMessage' in thrownError ? ` (${thrownError.originalMessage})` : '') );
     }
     try {
       const formattedMessage = messageFormat.format(
@@ -235,20 +315,17 @@ function createBaseTranslatorImpl(_ref) {
       // for rich text elements since a recent minor update. This
       // needs to be evaluated in detail, possibly also in regards
       // to be able to format to parts.
-      prepareTranslationValues({
-        ...defaultTranslationValues,
-        ...values
-      }));
+      values ? prepareTranslationValues(values) : values);
       if (formattedMessage == null) {
-        throw new Error("Unable to format `".concat(key, "` in ").concat(namespace ? "namespace `".concat(namespace, "`") : 'messages') );
+        throw new Error(`Unable to format \`${key}\` in ${namespace ? `namespace \`${namespace}\`` : 'messages'}` );
       }
 
       // Limit the function signature to return strings or React elements
-      return /*#__PURE__*/React.isValidElement(formattedMessage) ||
+      return /*#__PURE__*/isValidElement(formattedMessage) ||
       // Arrays of React elements
       Array.isArray(formattedMessage) || typeof formattedMessage === 'string' ? formattedMessage : String(formattedMessage);
     } catch (error) {
-      return getFallbackFromErrorAndNotify(key, initializeConfig.IntlErrorCode.FORMATTING_ERROR, error.message);
+      return getFallbackFromErrorAndNotify(key, IntlErrorCode.FORMATTING_ERROR, error.message);
     }
   }
   function translateFn(/** Use a dot to indicate a level of nesting (e.g. `namespace.nestedLabel`). */
@@ -257,7 +334,7 @@ function createBaseTranslatorImpl(_ref) {
   formats) {
     const result = translateBaseFn(key, values, formats);
     if (typeof result !== 'string') {
-      return getFallbackFromErrorAndNotify(key, initializeConfig.IntlErrorCode.INVALID_MESSAGE, "The message `".concat(key, "` in ").concat(namespace ? "namespace `".concat(namespace, "`") : 'messages', " didn't resolve to a string. If you want to format rich text, use `t.rich` instead.") );
+      return getFallbackFromErrorAndNotify(key, IntlErrorCode.INVALID_MESSAGE, `The message \`${key}\` in ${namespace ? `namespace \`${namespace}\`` : 'messages'} didn't resolve to a string. If you want to format rich text, use \`t.rich\` instead.` );
     }
     return result;
   }
@@ -269,13 +346,8 @@ function createBaseTranslatorImpl(_ref) {
     // @ts-expect-error -- `MarkupTranslationValues` is practically a sub type
     // of `RichTranslationValues` but TypeScript isn't smart enough here.
     values, formats);
-
-    // When only string chunks are provided to the parser, only
-    // strings should be returned here. Note that we need a runtime
-    // check for this since rich text values could be accidentally
-    // inherited from `defaultTranslationValues`.
     if (typeof result !== 'string') {
-      const error = new initializeConfig.IntlError(initializeConfig.IntlErrorCode.FORMATTING_ERROR, "`t.markup` only accepts functions for formatting that receive and return strings.\n\nE.g. t.markup('markup', {b: (chunks) => `<b>${chunks}</b>`})" );
+      const error = new IntlError(IntlErrorCode.FORMATTING_ERROR, "`t.markup` only accepts functions for formatting that receive and return strings.\n\nE.g. t.markup('markup', {b: (chunks) => `<b>${chunks}</b>`})");
       onError(error);
       return getMessageFallback({
         error,
@@ -298,7 +370,7 @@ function createBaseTranslatorImpl(_ref) {
     try {
       return resolvePath(locale, messages, key, namespace);
     } catch (error) {
-      return getFallbackFromErrorAndNotify(key, initializeConfig.IntlErrorCode.MISSING_MESSAGE, error.message);
+      return getFallbackFromErrorAndNotify(key, IntlErrorCode.MISSING_MESSAGE, error.message);
     }
   };
   translateFn.has = key => {
@@ -308,7 +380,7 @@ function createBaseTranslatorImpl(_ref) {
     try {
       resolvePath(locale, messagesOrError, key, namespace);
       return true;
-    } catch (_unused) {
+    } catch {
       return false;
     }
   };
@@ -371,94 +443,89 @@ function calculateRelativeTimeValue(seconds, unit) {
   // will include fractions like '2.1 hours ago'.
   return Math.round(seconds / UNIT_SECONDS[unit]);
 }
-function createFormatter(_ref) {
-  let {
-    _cache: cache = initializeConfig.createCache(),
-    _formatters: formatters = initializeConfig.createIntlFormatters(cache),
+function createFormatter(props) {
+  const {
+    _cache: cache = createCache(),
+    _formatters: formatters = createIntlFormatters(cache),
     formats,
     locale,
-    now: globalNow,
-    onError = initializeConfig.defaultOnError,
+    onError = defaultOnError,
     timeZone: globalTimeZone
-  } = _ref;
+  } = props;
   function applyTimeZone(options) {
-    var _options;
-    if (!((_options = options) !== null && _options !== void 0 && _options.timeZone)) {
+    if (!options?.timeZone) {
       if (globalTimeZone) {
         options = {
           ...options,
           timeZone: globalTimeZone
         };
       } else {
-        onError(new initializeConfig.IntlError(initializeConfig.IntlErrorCode.ENVIRONMENT_FALLBACK, "The `timeZone` parameter wasn't provided and there is no global default configured. Consider adding a global default to avoid markup mismatches caused by environment differences. Learn more: https://next-intl.dev/docs/configuration#time-zone" ));
+        onError(new IntlError(IntlErrorCode.ENVIRONMENT_FALLBACK, `The \`timeZone\` parameter wasn't provided and there is no global default configured. Consider adding a global default to avoid markup mismatches caused by environment differences. Learn more: https://next-intl.dev/docs/configuration#time-zone` ));
       }
     }
     return options;
   }
-  function resolveFormatOrOptions(typeFormats, formatOrOptions) {
+  function resolveFormatOrOptions(typeFormats, formatOrOptions, overrides) {
     let options;
     if (typeof formatOrOptions === 'string') {
       const formatName = formatOrOptions;
-      options = typeFormats === null || typeFormats === void 0 ? void 0 : typeFormats[formatName];
+      options = typeFormats?.[formatName];
       if (!options) {
-        const error = new initializeConfig.IntlError(initializeConfig.IntlErrorCode.MISSING_FORMAT, "Format `".concat(formatName, "` is not available. You can configure it on the provider or provide custom options.") );
+        const error = new IntlError(IntlErrorCode.MISSING_FORMAT, `Format \`${formatName}\` is not available.` );
         onError(error);
         throw error;
       }
     } else {
       options = formatOrOptions;
     }
+    if (overrides) {
+      options = {
+        ...options,
+        ...overrides
+      };
+    }
     return options;
   }
-  function getFormattedValue(formatOrOptions, typeFormats, formatter, getFallback) {
+  function getFormattedValue(formatOrOptions, overrides, typeFormats, formatter, getFallback) {
     let options;
     try {
-      options = resolveFormatOrOptions(typeFormats, formatOrOptions);
-    } catch (_unused) {
+      options = resolveFormatOrOptions(typeFormats, formatOrOptions, overrides);
+    } catch {
       return getFallback();
     }
     try {
       return formatter(options);
     } catch (error) {
-      onError(new initializeConfig.IntlError(initializeConfig.IntlErrorCode.FORMATTING_ERROR, error.message));
+      onError(new IntlError(IntlErrorCode.FORMATTING_ERROR, error.message));
       return getFallback();
     }
   }
-  function dateTime(/** If a number is supplied, this is interpreted as a UTC timestamp. */
-  value,
-  /** If a time zone is supplied, the `value` is converted to that time zone.
-   * Otherwise the user time zone will be used. */
-  formatOrOptions) {
-    return getFormattedValue(formatOrOptions, formats === null || formats === void 0 ? void 0 : formats.dateTime, options => {
+  function dateTime(value, formatOrOptions, overrides) {
+    return getFormattedValue(formatOrOptions, overrides, formats?.dateTime, options => {
       options = applyTimeZone(options);
       return formatters.getDateTimeFormat(locale, options).format(value);
     }, () => String(value));
   }
-  function dateTimeRange(/** If a number is supplied, this is interpreted as a UTC timestamp. */
-  start, /** If a number is supplied, this is interpreted as a UTC timestamp. */
-  end,
-  /** If a time zone is supplied, the values are converted to that time zone.
-   * Otherwise the user time zone will be used. */
-  formatOrOptions) {
-    return getFormattedValue(formatOrOptions, formats === null || formats === void 0 ? void 0 : formats.dateTime, options => {
+  function dateTimeRange(start, end, formatOrOptions, overrides) {
+    return getFormattedValue(formatOrOptions, overrides, formats?.dateTime, options => {
       options = applyTimeZone(options);
       return formatters.getDateTimeFormat(locale, options).formatRange(start, end);
     }, () => [dateTime(start), dateTime(end)].join(' – '));
   }
-  function number(value, formatOrOptions) {
-    return getFormattedValue(formatOrOptions, formats === null || formats === void 0 ? void 0 : formats.number, options => formatters.getNumberFormat(locale, options).format(value), () => String(value));
+  function number(value, formatOrOptions, overrides) {
+    return getFormattedValue(formatOrOptions, overrides, formats?.number, options => formatters.getNumberFormat(locale, options).format(value), () => String(value));
   }
   function getGlobalNow() {
-    if (globalNow) {
-      return globalNow;
+    // Only read when necessary to avoid triggering a `dynamicIO` error
+    // unnecessarily (`now` is only needed for `format.relativeTime`)
+    if (props.now) {
+      return props.now;
     } else {
-      onError(new initializeConfig.IntlError(initializeConfig.IntlErrorCode.ENVIRONMENT_FALLBACK, "The `now` parameter wasn't provided and there is no global default configured. Consider adding a global default to avoid markup mismatches caused by environment differences. Learn more: https://next-intl.dev/docs/configuration#now" ));
+      onError(new IntlError(IntlErrorCode.ENVIRONMENT_FALLBACK, `The \`now\` parameter wasn't provided to \`relativeTime\` and there is no global default configured, therefore the current time will be used as a fallback. See https://next-intl.dev/docs/usage/dates-times#relative-times-usenow` ));
       return new Date();
     }
   }
-  function relativeTime(/** The date time that needs to be formatted. */
-  date, /** The reference point in time to which `date` will be formatted in relation to.  */
-  nowOrOptions) {
+  function relativeTime(date, nowOrOptions) {
     try {
       let nowDate, unit;
       const opts = {};
@@ -496,11 +563,11 @@ function createFormatter(_ref) {
       const value = calculateRelativeTimeValue(seconds, unit);
       return formatters.getRelativeTimeFormat(locale, opts).format(value, unit);
     } catch (error) {
-      onError(new initializeConfig.IntlError(initializeConfig.IntlErrorCode.FORMATTING_ERROR, error.message));
+      onError(new IntlError(IntlErrorCode.FORMATTING_ERROR, error.message));
       return String(date);
     }
   }
-  function list(value, formatOrOptions) {
+  function list(value, formatOrOptions, overrides) {
     const serializedValue = [];
     const richValues = new Map();
 
@@ -519,7 +586,7 @@ function createFormatter(_ref) {
       serializedValue.push(serializedItem);
       index++;
     }
-    return getFormattedValue(formatOrOptions, formats === null || formats === void 0 ? void 0 : formats.list,
+    return getFormattedValue(formatOrOptions, overrides, formats?.list,
     // @ts-expect-error -- `richValues.size` is used to determine the return type, but TypeScript can't infer the meaning of this correctly
     options => {
       const result = formatters.getListFormat(locale, options).formatToParts(serializedValue).map(part => part.type === 'literal' ? part.value : richValues.get(part.value) || part.value);
@@ -539,6 +606,84 @@ function createFormatter(_ref) {
   };
 }
 
-exports.createBaseTranslator = createBaseTranslator;
-exports.createFormatter = createFormatter;
-exports.resolveNamespace = resolveNamespace;
+function validateMessagesSegment(messages, invalidKeyLabels, parentPath) {
+  Object.entries(messages).forEach(([key, messageOrMessages]) => {
+    if (key.includes('.')) {
+      let keyLabel = key;
+      if (parentPath) keyLabel += ` (at ${parentPath})`;
+      invalidKeyLabels.push(keyLabel);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (messageOrMessages != null && typeof messageOrMessages === 'object') {
+      validateMessagesSegment(messageOrMessages, invalidKeyLabels, joinPath(parentPath, key));
+    }
+  });
+}
+function validateMessages(messages, onError) {
+  const invalidKeyLabels = [];
+  validateMessagesSegment(messages, invalidKeyLabels);
+  if (invalidKeyLabels.length > 0) {
+    onError(new IntlError(IntlErrorCode.INVALID_KEY, `Namespace keys can not contain the character "." as this is used to express nesting. Please remove it or replace it with another character.
+
+Invalid ${invalidKeyLabels.length === 1 ? 'key' : 'keys'}: ${invalidKeyLabels.join(', ')}
+
+If you're migrating from a flat structure, you can convert your messages as follows:
+
+import {set} from "lodash";
+
+const input = {
+  "one.one": "1.1",
+  "one.two": "1.2",
+  "two.one.one": "2.1.1"
+};
+
+const output = Object.entries(input).reduce(
+  (acc, [key, value]) => set(acc, key, value),
+  {}
+);
+
+// Output:
+//
+// {
+//   "one": {
+//     "one": "1.1",
+//     "two": "1.2"
+//   },
+//   "two": {
+//     "one": {
+//       "one": "2.1.1"
+//     }
+//   }
+// }
+` ));
+  }
+}
+
+/**
+ * Enhances the incoming props with defaults.
+ */
+function initializeConfig({
+  formats,
+  getMessageFallback,
+  messages,
+  onError,
+  ...rest
+}) {
+  const finalOnError = onError || defaultOnError;
+  const finalGetMessageFallback = getMessageFallback || defaultGetMessageFallback;
+  {
+    if (messages) {
+      validateMessages(messages, finalOnError);
+    }
+  }
+  return {
+    ...rest,
+    formats: formats || undefined,
+    messages: messages || undefined,
+    onError: finalOnError,
+    getMessageFallback: finalGetMessageFallback
+  };
+}
+
+export { IntlError as I, IntlErrorCode as a, createIntlFormatters as b, createFormatter as c, createCache as d, createBaseTranslator as e, defaultGetMessageFallback as f, defaultOnError as g, initializeConfig as i, resolveNamespace as r };