@common.js/intl-messageformat 11.2.9

package/index.js

@@ -0,0 +1,697 @@
+"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, {
+    ErrorCode: function() {
+        return ErrorCode;
+    },
+    FormatError: function() {
+        return FormatError;
+    },
+    IntlMessageFormat: function() {
+        return IntlMessageFormat;
+    },
+    InvalidValueError: function() {
+        return InvalidValueError;
+    },
+    InvalidValueTypeError: function() {
+        return InvalidValueTypeError;
+    },
+    MissingValueError: function() {
+        return MissingValueError;
+    },
+    PART_TYPE: function() {
+        return PART_TYPE;
+    },
+    default: function() {
+        return intl_messageformat_default;
+    },
+    formatToParts: function() {
+        return formatToParts;
+    },
+    isFormatXMLElementFn: function() {
+        return isFormatXMLElementFn;
+    }
+});
+var _fastMemoize = require("@formatjs/fast-memoize");
+var _icuMessageformatParser = require("@formatjs/icu-messageformat-parser");
+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 _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _assertThisInitialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Date.prototype.toString.call(Reflect.construct(Date, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _construct(Parent, args, Class) {
+    if (isNativeReflectConstruct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function _construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _setPrototypeOf(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+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 _extends() {
+    _extends = Object.assign || 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);
+}
+function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+}
+function _isNativeFunction(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread 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 _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assertThisInitialized(self);
+}
+function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _setPrototypeOf(o, p);
+}
+function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+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 _wrapNativeSuper(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrapNativeSuper = function _wrapNativeSuper(Class) {
+        if (Class === null || !_isNativeFunction(Class)) return Class;
+        if (typeof Class !== "function") {
+            throw new TypeError("Super expression must either be null or a function");
+        }
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _setPrototypeOf(Wrapper, Class);
+    };
+    return _wrapNativeSuper(Class);
+}
+function _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+        var Super = _getPrototypeOf(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _getPrototypeOf(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possibleConstructorReturn(this, result);
+    };
+}
+var _IntlMessageFormat, __, __1, __2, __3;
+//#region packages/intl-messageformat/error.ts
+var ErrorCode = /* @__PURE__ */ function(ErrorCode) {
+    ErrorCode["MISSING_VALUE"] = "MISSING_VALUE";
+    ErrorCode["INVALID_VALUE"] = "INVALID_VALUE";
+    ErrorCode["MISSING_INTL_API"] = "MISSING_INTL_API";
+    return ErrorCode;
+}({});
+var FormatError = /*#__PURE__*/ function(Error1) {
+    "use strict";
+    _inherits(FormatError, Error1);
+    var _super = _createSuper(FormatError);
+    function FormatError(msg, code, originalMessage) {
+        _classCallCheck(this, FormatError);
+        var _this;
+        _this = _super.call(this, msg);
+        _this.code = code;
+        _this.originalMessage = originalMessage;
+        return _this;
+    }
+    _createClass(FormatError, [
+        {
+            key: "toString",
+            value: function toString() {
+                return "[formatjs Error: ".concat(this.code, "] ").concat(this.message);
+            }
+        }
+    ]);
+    return FormatError;
+}(_wrapNativeSuper(Error));
+var InvalidValueError = /*#__PURE__*/ function(FormatError) {
+    "use strict";
+    _inherits(InvalidValueError, FormatError);
+    var _super = _createSuper(InvalidValueError);
+    function InvalidValueError(variableId, value, options, originalMessage) {
+        _classCallCheck(this, InvalidValueError);
+        return _super.call(this, 'Invalid values for "'.concat(variableId, '": "').concat(value, '". Options are "').concat(Object.keys(options).join('", "'), '"'), "INVALID_VALUE", originalMessage);
+    }
+    return InvalidValueError;
+}(FormatError);
+var InvalidValueTypeError = /*#__PURE__*/ function(FormatError) {
+    "use strict";
+    _inherits(InvalidValueTypeError, FormatError);
+    var _super = _createSuper(InvalidValueTypeError);
+    function InvalidValueTypeError(value, type, originalMessage) {
+        _classCallCheck(this, InvalidValueTypeError);
+        return _super.call(this, 'Value for "'.concat(value, '" must be of type ').concat(type), "INVALID_VALUE", originalMessage);
+    }
+    return InvalidValueTypeError;
+}(FormatError);
+var MissingValueError = /*#__PURE__*/ function(FormatError) {
+    "use strict";
+    _inherits(MissingValueError, FormatError);
+    var _super = _createSuper(MissingValueError);
+    function MissingValueError(variableId, originalMessage) {
+        _classCallCheck(this, MissingValueError);
+        return _super.call(this, 'The intl string context variable "'.concat(variableId, '" was not provided to the string "').concat(originalMessage, '"'), "MISSING_VALUE", originalMessage);
+    }
+    return MissingValueError;
+}(FormatError);
+//#endregion
+//#region packages/intl-messageformat/formatters.ts
+var PART_TYPE = /* @__PURE__ */ function(PART_TYPE) {
+    PART_TYPE[PART_TYPE["literal"] = 0] = "literal";
+    PART_TYPE[PART_TYPE["object"] = 1] = "object";
+    return PART_TYPE;
+}({});
+function mergeLiteral(parts) {
+    if (parts.length < 2) return parts;
+    return parts.reduce(function(all, part) {
+        var lastPart = all[all.length - 1];
+        if (!lastPart || lastPart.type !== 0 || part.type !== 0) all.push(part);
+        else lastPart.value += part.value;
+        return all;
+    }, []);
+}
+function isFormatXMLElementFn(el) {
+    return typeof el === "function";
+}
+function formatToParts(els, locales, formatters, formats, values, currentPluralValue, originalMessage) {
+    if (els.length === 1 && (0, _icuMessageformatParser.isLiteralElement)(els[0])) return [
+        {
+            type: 0,
+            value: els[0].value
+        }
+    ];
+    var result = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = els[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var el = _step.value;
+            if ((0, _icuMessageformatParser.isLiteralElement)(el)) {
+                result.push({
+                    type: 0,
+                    value: el.value
+                });
+                continue;
+            }
+            if ((0, _icuMessageformatParser.isPoundElement)(el)) {
+                if (typeof currentPluralValue === "number") result.push({
+                    type: 0,
+                    value: formatters.getNumberFormat(locales).format(currentPluralValue)
+                });
+                continue;
+            }
+            var varName = el.value;
+            if (!(values && varName in values)) throw new MissingValueError(varName, originalMessage);
+            var value = values[varName];
+            if ((0, _icuMessageformatParser.isArgumentElement)(el)) {
+                if (!value || typeof value === "string" || typeof value === "number" || (typeof value === "undefined" ? "undefined" : _typeof(value)) === "bigint") value = typeof value === "string" || typeof value === "number" || (typeof value === "undefined" ? "undefined" : _typeof(value)) === "bigint" ? String(value) : "";
+                result.push({
+                    type: typeof value === "string" ? 0 : 1,
+                    value: value
+                });
+                continue;
+            }
+            if ((0, _icuMessageformatParser.isDateElement)(el)) {
+                var style = typeof el.style === "string" ? formats.date[el.style] : (0, _icuMessageformatParser.isDateTimeSkeleton)(el.style) ? el.style.parsedOptions : void 0;
+                result.push({
+                    type: 0,
+                    value: formatters.getDateTimeFormat(locales, style).format(value)
+                });
+                continue;
+            }
+            if ((0, _icuMessageformatParser.isTimeElement)(el)) {
+                var style1 = typeof el.style === "string" ? formats.time[el.style] : (0, _icuMessageformatParser.isDateTimeSkeleton)(el.style) ? el.style.parsedOptions : formats.time.medium;
+                result.push({
+                    type: 0,
+                    value: formatters.getDateTimeFormat(locales, style1).format(value)
+                });
+                continue;
+            }
+            if ((0, _icuMessageformatParser.isNumberElement)(el)) {
+                var style2 = typeof el.style === "string" ? formats.number[el.style] : (0, _icuMessageformatParser.isNumberSkeleton)(el.style) ? el.style.parsedOptions : void 0;
+                if (style2 && style2.scale) {
+                    var scale = style2.scale || 1;
+                    if ((typeof value === "undefined" ? "undefined" : _typeof(value)) === "bigint") {
+                        if (!Number.isInteger(scale)) throw new TypeError("Cannot apply fractional scale ".concat(scale, " to bigint value. Scale must be an integer when formatting bigint."));
+                        value = value * BigInt(scale);
+                    } else value = value * scale;
+                }
+                result.push({
+                    type: 0,
+                    value: formatters.getNumberFormat(locales, style2).format(value)
+                });
+                continue;
+            }
+            if ((0, _icuMessageformatParser.isTagElement)(el)) {
+                var _result;
+                var children = el.children, value1 = el.value;
+                var formatFn = values[value1];
+                if (!isFormatXMLElementFn(formatFn)) throw new InvalidValueTypeError(value1, "function", originalMessage);
+                var chunks = formatFn(formatToParts(children, locales, formatters, formats, values, currentPluralValue).map(function(p) {
+                    return p.value;
+                }));
+                if (!Array.isArray(chunks)) chunks = [
+                    chunks
+                ];
+                (_result = result).push.apply(_result, _toConsumableArray(chunks.map(function(c) {
+                    return {
+                        type: typeof c === "string" ? 0 : 1,
+                        value: c
+                    };
+                })));
+            }
+            if ((0, _icuMessageformatParser.isSelectElement)(el)) {
+                var _result1;
+                var key = value;
+                var opt = (Object.prototype.hasOwnProperty.call(el.options, key) ? el.options[key] : void 0) || el.options.other;
+                if (!opt) throw new InvalidValueError(el.value, value, Object.keys(el.options), originalMessage);
+                (_result1 = result).push.apply(_result1, _toConsumableArray(formatToParts(opt.value, locales, formatters, formats, values)));
+                continue;
+            }
+            if ((0, _icuMessageformatParser.isPluralElement)(el)) {
+                var _result2;
+                var exactKey = "=".concat(value);
+                var opt1 = Object.prototype.hasOwnProperty.call(el.options, exactKey) ? el.options[exactKey] : void 0;
+                if (!opt1) {
+                    if (!Intl.PluralRules) throw new FormatError('Intl.PluralRules is not available in this environment.\nTry polyfilling it using "@formatjs/intl-pluralrules"\n', "MISSING_INTL_API", originalMessage);
+                    var numericValue = (typeof value === "undefined" ? "undefined" : _typeof(value)) === "bigint" ? Number(value) : value;
+                    var rule = formatters.getPluralRules(locales, {
+                        type: el.pluralType
+                    }).select(numericValue - (el.offset || 0));
+                    opt1 = (Object.prototype.hasOwnProperty.call(el.options, rule) ? el.options[rule] : void 0) || el.options.other;
+                }
+                if (!opt1) throw new InvalidValueError(el.value, value, Object.keys(el.options), originalMessage);
+                var numericValue1 = (typeof value === "undefined" ? "undefined" : _typeof(value)) === "bigint" ? Number(value) : value;
+                (_result2 = result).push.apply(_result2, _toConsumableArray(formatToParts(opt1.value, locales, formatters, formats, values, numericValue1 - (el.offset || 0))));
+                continue;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return mergeLiteral(result);
+}
+//#endregion
+//#region packages/intl-messageformat/core.ts
+function mergeConfig(c1, c2) {
+    if (!c2) return c1;
+    return _objectSpread({}, c1, c2, Object.keys(c1).reduce(function(all, k) {
+        all[k] = _objectSpread({}, c1[k], c2[k]);
+        return all;
+    }, {}));
+}
+function mergeConfigs(defaultConfig, configs) {
+    if (!configs) return defaultConfig;
+    return Object.keys(defaultConfig).reduce(function(all, k) {
+        all[k] = mergeConfig(defaultConfig[k], configs[k]);
+        return all;
+    }, _objectSpread({}, defaultConfig));
+}
+function createFastMemoizeCache(store) {
+    return {
+        create: function create() {
+            return {
+                get: function get(key) {
+                    return store[key];
+                },
+                set: function set(key, value) {
+                    store[key] = value;
+                }
+            };
+        }
+    };
+}
+function createDefaultFormatters() {
+    var cache = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
+        number: {},
+        dateTime: {},
+        pluralRules: {}
+    };
+    return {
+        getNumberFormat: (0, _fastMemoize.memoize)(function() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            return _construct(Intl.NumberFormat, _toConsumableArray(args));
+        }, {
+            cache: createFastMemoizeCache(cache.number),
+            strategy: _fastMemoize.strategies.variadic
+        }),
+        getDateTimeFormat: (0, _fastMemoize.memoize)(function() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            return _construct(Intl.DateTimeFormat, _toConsumableArray(args));
+        }, {
+            cache: createFastMemoizeCache(cache.dateTime),
+            strategy: _fastMemoize.strategies.variadic
+        }),
+        getPluralRules: (0, _fastMemoize.memoize)(function() {
+            for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+                args[_key] = arguments[_key];
+            }
+            return _construct(Intl.PluralRules, _toConsumableArray(args));
+        }, {
+            cache: createFastMemoizeCache(cache.pluralRules),
+            strategy: _fastMemoize.strategies.variadic
+        })
+    };
+}
+var /*#__PURE__*/ _IntlMessageFormat1;
+var IntlMessageFormat = ((_IntlMessageFormat1 = function() {
+    "use strict";
+    function IntlMessageFormat(message) {
+        var locales = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : IntlMessageFormat.defaultLocale, overrideFormats = arguments.length > 2 ? arguments[2] : void 0, opts = arguments.length > 3 ? arguments[3] : void 0;
+        var _this = this;
+        _classCallCheck(this, IntlMessageFormat);
+        this.formatterCache = {
+            number: {},
+            dateTime: {},
+            pluralRules: {}
+        };
+        this.format = function(values) {
+            var parts = _this.formatToParts(values);
+            if (parts.length === 1) return parts[0].value;
+            var result = parts.reduce(function(all, part) {
+                if (!all.length || part.type !== 0 || typeof all[all.length - 1] !== "string") all.push(part.value);
+                else all[all.length - 1] += part.value;
+                return all;
+            }, []);
+            if (result.length <= 1) return result[0] || "";
+            return result;
+        };
+        this.formatToParts = function(values) {
+            return formatToParts(_this.ast, _this.locales, _this.formatters, _this.formats, values, void 0, _this.message);
+        };
+        this.resolvedOptions = function() {
+            var ref;
+            return {
+                locale: ((ref = _this.resolvedLocale) === null || ref === void 0 ? void 0 : ref.toString()) || Intl.NumberFormat.supportedLocalesOf(_this.locales)[0]
+            };
+        };
+        this.getAst = function() {
+            return _this.ast;
+        };
+        this.locales = locales;
+        this.resolvedLocale = IntlMessageFormat.resolveLocale(locales);
+        if (typeof message === "string") {
+            this.message = message;
+            if (!IntlMessageFormat.__parse) throw new TypeError("IntlMessageFormat.__parse must be set to process `message` of type `string`");
+            var parseOpts = _extends({}, opts || {});
+            this.ast = IntlMessageFormat.__parse(message, _objectSpreadProps(_objectSpread({}, parseOpts), {
+                locale: this.resolvedLocale
+            }));
+        } else this.ast = message;
+        if (!Array.isArray(this.ast)) throw new TypeError("A message must be provided as a String or AST.");
+        this.formats = mergeConfigs(IntlMessageFormat.formats, overrideFormats);
+        this.formatters = opts && opts.formatters || createDefaultFormatters(this.formatterCache);
+    }
+    _createClass(IntlMessageFormat, null, [
+        {
+            key: "defaultLocale",
+            get: function get() {
+                if (!IntlMessageFormat.memoizedDefaultLocale) IntlMessageFormat.memoizedDefaultLocale = new Intl.NumberFormat().resolvedOptions().locale;
+                return IntlMessageFormat.memoizedDefaultLocale;
+            }
+        }
+    ]);
+    return IntlMessageFormat;
+}(), _IntlMessageFormat = _IntlMessageFormat1, _IntlMessageFormat1), __ = {
+    writable: true,
+    value: function() {
+        _IntlMessageFormat.memoizedDefaultLocale = null;
+    }()
+}, __1 = {
+    writable: true,
+    value: function() {
+        _IntlMessageFormat.resolveLocale = function(locales) {
+            if (typeof Intl.Locale === "undefined") return;
+            var supportedLocales = Intl.NumberFormat.supportedLocalesOf(locales);
+            if (supportedLocales.length > 0) return new Intl.Locale(supportedLocales[0]);
+            return new Intl.Locale(typeof locales === "string" ? locales : locales[0]);
+        };
+    }()
+}, __2 = {
+    writable: true,
+    value: function() {
+        _IntlMessageFormat.__parse = _icuMessageformatParser.parse;
+    }()
+}, __3 = {
+    writable: true,
+    value: function() {
+        _IntlMessageFormat.formats = {
+            number: {
+                integer: {
+                    maximumFractionDigits: 0
+                },
+                currency: {
+                    style: "currency"
+                },
+                percent: {
+                    style: "percent"
+                }
+            },
+            date: {
+                short: {
+                    month: "numeric",
+                    day: "numeric",
+                    year: "2-digit"
+                },
+                medium: {
+                    month: "short",
+                    day: "numeric",
+                    year: "numeric"
+                },
+                long: {
+                    month: "long",
+                    day: "numeric",
+                    year: "numeric"
+                },
+                full: {
+                    weekday: "long",
+                    month: "long",
+                    day: "numeric",
+                    year: "numeric"
+                }
+            },
+            time: {
+                short: {
+                    hour: "numeric",
+                    minute: "numeric"
+                },
+                medium: {
+                    hour: "numeric",
+                    minute: "numeric",
+                    second: "numeric"
+                },
+                long: {
+                    hour: "numeric",
+                    minute: "numeric",
+                    second: "numeric",
+                    timeZoneName: "short"
+                },
+                full: {
+                    hour: "numeric",
+                    minute: "numeric",
+                    second: "numeric",
+                    timeZoneName: "short"
+                }
+            }
+        };
+    }()
+}, _IntlMessageFormat);
+//#endregion
+//#region packages/intl-messageformat/index.ts
+var intl_messageformat_default = IntlMessageFormat;
+ //# sourceMappingURL=index.js.map