@common.js/use-intl 4.13.1

package/dist/esm/development/initializeConfig-CUsOI8u2.js

@@ -0,0 +1,651 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    a: function() {
+        return createBaseTranslator;
+    },
+    b: function() {
+        return defaultOnError;
+    },
+    c: function() {
+        return createFormatter;
+    },
+    d: function() {
+        return defaultGetMessageFallback;
+    },
+    i: function() {
+        return initializeConfig;
+    },
+    r: function() {
+        return resolveNamespace;
+    }
+});
+var _react = require("react");
+var _formatMessage = /*#__PURE__*/ _interopRequireDefault(require("use-intl/format-message"));
+var _formattersR4AAmsMPJs = require("./formatters-r4aAmsMP.js");
+function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _defineProperty(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _iterableToArrayLimit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _defineProperty(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _objectSpreadProps(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _objectWithoutProperties(source, excluded) {
+    if (source == null) return {};
+    var target = _objectWithoutPropertiesLoose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function joinPath() {
+    for(var _len = arguments.length, parts = new Array(_len), _key = 0; _key < _len; _key++){
+        parts[_key] = arguments[_key];
+    }
+    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 prepareTranslationValues(values) {
+    // Related to https://github.com/formatjs/formatjs/issues/1467
+    var transformedValues = {};
+    Object.keys(values).forEach(function(key) {
+        var index = 0;
+        var value = values[key];
+        var transformed;
+        if (typeof value === "function") {
+            transformed = function(chunks) {
+                var result = value(chunks);
+                return /*#__PURE__*/ (0, _react.isValidElement)(result) ? /*#__PURE__*/ (0, _react.cloneElement)(result, {
+                    key: key + index++
+                }) : result;
+            };
+        } else {
+            transformed = value;
+        }
+        transformedValues[key] = transformed;
+    });
+    return transformedValues;
+}
+function resolvePath(locale, messages, key, namespace) {
+    var fullKey = joinPath(namespace, key);
+    if (!messages) {
+        throw new Error("No messages available at `".concat(namespace, "`."));
+    }
+    var message = messages;
+    key.split(".").forEach(function(part) {
+        var next = message[part];
+        // 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, "`."));
+        }
+        message = next;
+    });
+    return message;
+}
+function getMessagesOrError(locale, messages, namespace) {
+    try {
+        if (!messages) {
+            throw new Error("No messages were configured.");
+        }
+        var 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."));
+        }
+        return retrievedMessages;
+    } catch (error) {
+        var intlError = new _formattersR4AAmsMPJs.I(_formattersR4AAmsMPJs.a.MISSING_MESSAGE, error.message);
+        return intlError;
+    }
+}
+function createBaseTranslator(config) {
+    var messagesOrError = getMessagesOrError(config.locale, config.messages, config.namespace);
+    return createBaseTranslatorImpl(_objectSpreadProps(_objectSpread({}, config), {
+        messagesOrError: messagesOrError
+    }));
+}
+function createBaseTranslatorImpl(param) {
+    var cache = param.cache, globalFormats = param.formats, formatters = param.formatters, _getMessageFallback = param.getMessageFallback, getMessageFallback = _getMessageFallback === void 0 ? defaultGetMessageFallback : _getMessageFallback, locale = param.locale, messagesOrError = param.messagesOrError, namespace = param.namespace, onError = param.onError, timeZone = param.timeZone;
+    var getFallbackFromErrorAndNotify = function getFallbackFromErrorAndNotify(key, code, message, fallback) {
+        var error = new _formattersR4AAmsMPJs.I(code, message);
+        onError(error);
+        return fallback !== null && fallback !== void 0 ? fallback : getMessageFallback({
+            error: error,
+            key: key,
+            namespace: namespace
+        });
+    };
+    var translateBaseFn = function translateBaseFn(/** Use a dot to indicate a level of nesting (e.g. `namespace.nestedLabel`). */ key, /** Key value pairs for values to interpolate into the message. */ values, /** Provide custom formats for numbers, dates and times. */ formats, _fallback) {
+        var fallback = _fallback;
+        var message;
+        if (hasMessagesError) {
+            if (fallback) {
+                message = fallback;
+            } else {
+                onError(messagesOrError);
+                return getMessageFallback({
+                    error: messagesOrError,
+                    key: key,
+                    namespace: namespace
+                });
+            }
+        } else {
+            var messages = messagesOrError;
+            try {
+                message = resolvePath(locale, messages, key, namespace);
+            } catch (error) {
+                if (fallback) {
+                    message = fallback;
+                } else {
+                    return getFallbackFromErrorAndNotify(key, _formattersR4AAmsMPJs.a.MISSING_MESSAGE, error.message, fallback);
+                }
+            }
+        }
+        try {
+            var messagePath = joinPath(namespace, key);
+            return (0, _formatMessage.default)(messagePath, // @ts-expect-error -- We have additional validation either in `compile-format.tsx` or in case of `format-only.tsx` in the loader
+            message, values ? prepareTranslationValues(values) : values, {
+                cache: cache,
+                formatters: formatters,
+                globalFormats: globalFormats,
+                formats: formats,
+                locale: locale,
+                timeZone: timeZone
+            });
+        } catch (error1) {
+            var errorCode, errorMessage;
+            if (_instanceof(error1, _formattersR4AAmsMPJs.I)) {
+                errorCode = error1.code;
+                errorMessage = error1.originalMessage;
+            } else {
+                errorCode = _formattersR4AAmsMPJs.a.FORMATTING_ERROR;
+                errorMessage = error1.message;
+            }
+            return getFallbackFromErrorAndNotify(key, errorCode, errorMessage, fallback);
+        }
+    };
+    var translateFn = function translateFn(/** Use a dot to indicate a level of nesting (e.g. `namespace.nestedLabel`). */ key, /** Key value pairs for values to interpolate into the message. */ values, /** Custom formats for numbers, dates and times. */ formats, _fallback) {
+        var result = translateBaseFn(key, values, formats, _fallback);
+        if (typeof result !== "string") {
+            return getFallbackFromErrorAndNotify(key, _formattersR4AAmsMPJs.a.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 result;
+    };
+    var hasMessagesError = _instanceof(messagesOrError, _formattersR4AAmsMPJs.I);
+    translateFn.rich = translateBaseFn;
+    // Augment `translateBaseFn` to return plain strings
+    translateFn.markup = function(key, values, formats, _fallback) {
+        var result = translateBaseFn(key, // @ts-expect-error -- `MarkupTranslationValues` is practically a sub type
+        // of `RichTranslationValues` but TypeScript isn't smart enough here.
+        values, formats, _fallback);
+        if (typeof result !== "string") {
+            var error = new _formattersR4AAmsMPJs.I(_formattersR4AAmsMPJs.a.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: error,
+                key: key,
+                namespace: namespace
+            });
+        }
+        return result;
+    };
+    translateFn.raw = function(key) {
+        {
+            if (!_formatMessage.default.raw) {
+                throw new Error("`t.raw` is not supported when messages are precompiled.");
+            }
+        }
+        if (hasMessagesError) {
+            onError(messagesOrError);
+            return getMessageFallback({
+                error: messagesOrError,
+                key: key,
+                namespace: namespace
+            });
+        }
+        var messages = messagesOrError;
+        try {
+            return resolvePath(locale, messages, key, namespace);
+        } catch (error) {
+            return getFallbackFromErrorAndNotify(key, _formattersR4AAmsMPJs.a.MISSING_MESSAGE, error.message);
+        }
+    };
+    translateFn.has = function(key) {
+        if (hasMessagesError) {
+            return false;
+        }
+        try {
+            resolvePath(locale, messagesOrError, key, namespace);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    };
+    return translateFn;
+}
+/**
+ * For the strictly typed messages to work we have to wrap the namespace into
+ * a mandatory prefix. See https://stackoverflow.com/a/71529575/343045
+ */ function resolveNamespace(namespace, namespacePrefix) {
+    return namespace === namespacePrefix ? undefined : namespace.slice((namespacePrefix + ".").length);
+}
+var SECOND = 1;
+var MINUTE = SECOND * 60;
+var HOUR = MINUTE * 60;
+var DAY = HOUR * 24;
+var WEEK = DAY * 7;
+var MONTH = DAY * (365 / 12); // Approximation
+var QUARTER = MONTH * 3;
+var YEAR = DAY * 365;
+var UNIT_SECONDS = {
+    second: SECOND,
+    seconds: SECOND,
+    minute: MINUTE,
+    minutes: MINUTE,
+    hour: HOUR,
+    hours: HOUR,
+    day: DAY,
+    days: DAY,
+    week: WEEK,
+    weeks: WEEK,
+    month: MONTH,
+    months: MONTH,
+    quarter: QUARTER,
+    quarters: QUARTER,
+    year: YEAR,
+    years: YEAR
+};
+function resolveRelativeTimeUnit(seconds) {
+    var absValue = Math.abs(seconds);
+    if (absValue < MINUTE) {
+        return "second";
+    } else if (absValue < HOUR) {
+        return "minute";
+    } else if (absValue < DAY) {
+        return "hour";
+    } else if (absValue < WEEK) {
+        return "day";
+    } else if (absValue < MONTH) {
+        return "week";
+    } else if (absValue < YEAR) {
+        return "month";
+    }
+    return "year";
+}
+function calculateRelativeTimeValue(seconds, unit) {
+    // We have to round the resulting values, as `Intl.RelativeTimeFormat`
+    // will include fractions like '2.1 hours ago'.
+    return Math.round(seconds / UNIT_SECONDS[unit]);
+}
+function createFormatter(props) {
+    var applyTimeZone = function applyTimeZone(options) {
+        if (!(options === null || options === void 0 ? void 0 : options.timeZone)) {
+            if (globalTimeZone) {
+                options = _objectSpreadProps(_objectSpread({}, options), {
+                    timeZone: globalTimeZone
+                });
+            } else {
+                onError(new _formattersR4AAmsMPJs.I(_formattersR4AAmsMPJs.a.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;
+    };
+    var resolveFormatOrOptions = function resolveFormatOrOptions(typeFormats, formatOrOptions, overrides) {
+        var options;
+        if (typeof formatOrOptions === "string") {
+            var formatName = formatOrOptions;
+            options = typeFormats === null || typeFormats === void 0 ? void 0 : typeFormats[formatName];
+            if (!options) {
+                var error = new _formattersR4AAmsMPJs.I(_formattersR4AAmsMPJs.a.MISSING_FORMAT, "Format `".concat(formatName, "` is not available."));
+                onError(error);
+                throw error;
+            }
+        } else {
+            options = formatOrOptions;
+        }
+        if (overrides) {
+            options = _objectSpread({}, options, overrides);
+        }
+        return options;
+    };
+    var getFormattedValue = function getFormattedValue(formatOrOptions, overrides, typeFormats, formatter, getFallback) {
+        var options;
+        try {
+            options = resolveFormatOrOptions(typeFormats, formatOrOptions, overrides);
+        } catch (e) {
+            return getFallback();
+        }
+        try {
+            return formatter(options);
+        } catch (error) {
+            onError(new _formattersR4AAmsMPJs.I(_formattersR4AAmsMPJs.a.FORMATTING_ERROR, error.message));
+            return getFallback();
+        }
+    };
+    var dateTime = function dateTime(value, formatOrOptions, overrides) {
+        return getFormattedValue(formatOrOptions, overrides, formats === null || formats === void 0 ? void 0 : formats.dateTime, function(options) {
+            options = applyTimeZone(options);
+            return formatters.getDateTimeFormat(locale, options).format(value);
+        }, function() {
+            return String(value);
+        });
+    };
+    var dateTimeRange = function dateTimeRange(start, end, formatOrOptions, overrides) {
+        return getFormattedValue(formatOrOptions, overrides, formats === null || formats === void 0 ? void 0 : formats.dateTime, function(options) {
+            options = applyTimeZone(options);
+            return formatters.getDateTimeFormat(locale, options).formatRange(start, end);
+        }, function() {
+            return [
+                dateTime(start),
+                dateTime(end)
+            ].join(" – ");
+        });
+    };
+    var number = function number(value, formatOrOptions, overrides) {
+        return getFormattedValue(formatOrOptions, overrides, formats === null || formats === void 0 ? void 0 : formats.number, function(options) {
+            return formatters.getNumberFormat(locale, options).format(value);
+        }, function() {
+            return String(value);
+        });
+    };
+    var getGlobalNow = function getGlobalNow() {
+        // 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 _formattersR4AAmsMPJs.I(_formattersR4AAmsMPJs.a.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();
+        }
+    };
+    var relativeTime = function relativeTime(date, nowOrOptions) {
+        try {
+            var nowDate, unit;
+            var opts = {};
+            if (_instanceof(nowOrOptions, Date) || typeof nowOrOptions === "number") {
+                nowDate = new Date(nowOrOptions);
+            } else if (nowOrOptions) {
+                if (nowOrOptions.now != null) {
+                    nowDate = new Date(nowOrOptions.now);
+                } else {
+                    nowDate = getGlobalNow();
+                }
+                unit = nowOrOptions.unit;
+                opts.style = nowOrOptions.style;
+                // @ts-expect-error -- Types are slightly outdated
+                opts.numberingSystem = nowOrOptions.numberingSystem;
+            }
+            if (!nowDate) {
+                nowDate = getGlobalNow();
+            }
+            var dateDate = new Date(date);
+            var seconds = (dateDate.getTime() - nowDate.getTime()) / 1000;
+            if (!unit) {
+                unit = resolveRelativeTimeUnit(seconds);
+            }
+            // `numeric: 'auto'` can theoretically produce output like "yesterday",
+            // but it only works with integers. E.g. -1 day will produce "yesterday",
+            // but -1.1 days will produce "-1.1 days". Rounding before formatting is
+            // not desired, as the given dates might cross a threshold were the
+            // output isn't correct anymore. Example: 2024-01-08T23:00:00.000Z and
+            // 2024-01-08T01:00:00.000Z would produce "yesterday", which is not the
+            // case. By using `always` we can ensure correct output. The only exception
+            // is the formatting of times <1 second as "now".
+            opts.numeric = unit === "second" ? "auto" : "always";
+            var value = calculateRelativeTimeValue(seconds, unit);
+            return formatters.getRelativeTimeFormat(locale, opts).format(value, unit);
+        } catch (error) {
+            onError(new _formattersR4AAmsMPJs.I(_formattersR4AAmsMPJs.a.FORMATTING_ERROR, error.message));
+            return String(date);
+        }
+    };
+    var list = function list(value, formatOrOptions, overrides) {
+        var serializedValue = [];
+        var richValues = new Map();
+        // `formatToParts` only accepts strings, therefore we have to temporarily
+        // replace React elements with a placeholder ID that can be used to retrieve
+        // the original value afterwards.
+        var index = 0;
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = value[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var item = _step.value;
+                var serializedItem = void 0;
+                if (typeof item === "object") {
+                    serializedItem = String(index);
+                    richValues.set(serializedItem, item);
+                } else {
+                    serializedItem = String(item);
+                }
+                serializedValue.push(serializedItem);
+                index++;
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        return getFormattedValue(formatOrOptions, overrides, formats === null || formats === void 0 ? void 0 : formats.list, // @ts-expect-error -- `richValues.size` is used to determine the return type, but TypeScript can't infer the meaning of this correctly
+        function(options) {
+            var result = formatters.getListFormat(locale, options).formatToParts(serializedValue).map(function(part) {
+                return part.type === "literal" ? part.value : richValues.get(part.value) || part.value;
+            });
+            if (richValues.size > 0) {
+                return result;
+            } else {
+                return result.join("");
+            }
+        }, function() {
+            return String(value);
+        });
+    };
+    var displayName = function displayName(value, formatOrOptions, overrides) {
+        return getFormattedValue(formatOrOptions, overrides, formats === null || formats === void 0 ? void 0 : formats.displayName, function(options) {
+            return(// `options` is guaranteed non-null because our overloads require
+            // either inline options or a named format that resolves to options.
+            formatters.getDisplayNames(locale, options).of(value));
+        }, function() {
+            return value;
+        });
+    };
+    var tmp = props._cache, cache = tmp === void 0 ? (0, _formattersR4AAmsMPJs.b)() : tmp, tmp1 = props._formatters, formatters = tmp1 === void 0 ? (0, _formattersR4AAmsMPJs.c)(cache) : tmp1, formats = props.formats, locale = props.locale, _onError = props.onError, onError = _onError === void 0 ? defaultOnError : _onError, globalTimeZone = props.timeZone;
+    return {
+        dateTime: dateTime,
+        number: number,
+        relativeTime: relativeTime,
+        list: list,
+        dateTimeRange: dateTimeRange,
+        displayName: displayName
+    };
+}
+function validateMessagesSegment(messages, invalidKeyLabels, parentPath) {
+    Object.entries(messages).forEach(function(param) {
+        var _param = _slicedToArray(param, 2), key = _param[0], messageOrMessages = _param[1];
+        if (key.includes(".")) {
+            var keyLabel = key;
+            if (parentPath) keyLabel += " (at ".concat(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) {
+    var invalidKeyLabels = [];
+    validateMessagesSegment(messages, invalidKeyLabels);
+    if (invalidKeyLabels.length > 0) {
+        onError(new _formattersR4AAmsMPJs.I(_formattersR4AAmsMPJs.a.INVALID_KEY, 'Namespace keys cannot contain the character "." as this is used to express nesting. Please remove it or replace it with another character.\n\nInvalid '.concat(invalidKeyLabels.length === 1 ? "key" : "keys", ": ").concat(invalidKeyLabels.join(", "), '\n\nIf you\'re migrating from a flat structure, you can convert your messages as follows:\n\nimport {set} from "lodash";\n\nconst input = {\n  "one.one": "1.1",\n  "one.two": "1.2",\n  "two.one.one": "2.1.1"\n};\n\nconst output = Object.entries(input).reduce(\n  (acc, [key, value]) => set(acc, key, value),\n  {}\n);\n\n// Output:\n//\n// {\n//   "one": {\n//     "one": "1.1",\n//     "two": "1.2"\n//   },\n//   "two": {\n//     "one": {\n//       "one": "2.1.1"\n//     }\n//   }\n// }\n')));
+    }
+}
+/**
+ * Enhances the incoming props with defaults.
+ */ function initializeConfig(_param) {
+    var formats = _param.formats, getMessageFallback = _param.getMessageFallback, messages = _param.messages, onError = _param.onError, rest = _objectWithoutProperties(_param, [
+        "formats",
+        "getMessageFallback",
+        "messages",
+        "onError"
+    ]);
+    var finalOnError = onError || defaultOnError;
+    var finalGetMessageFallback = getMessageFallback || defaultGetMessageFallback;
+    {
+        if (messages) {
+            validateMessages(messages, finalOnError);
+        }
+    }
+    return _objectSpreadProps(_objectSpread({}, rest), {
+        formats: formats || undefined,
+        messages: messages || undefined,
+        onError: finalOnError,
+        getMessageFallback: finalGetMessageFallback
+    });
+}