react-intl 5.20.2 → 5.20.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-intl",
-  "version": "5.20.2",
+  "version": "5.20.6",
   "description": "Internationalize React apps. This library provides React components and an API to format dates, numbers, and strings, including pluralization and handling translations.",
   "keywords": [
     "intl",
@@ -128,14 +128,14 @@
   "types": "index.d.ts",
   "sideEffects": false,
   "dependencies": {
-    "@formatjs/ecma402-abstract": "1.9.3",
-    "@formatjs/icu-messageformat-parser": "2.0.6",
-    "@formatjs/intl": "1.13.0",
-    "@formatjs/intl-displaynames": "5.1.5",
-    "@formatjs/intl-listformat": "6.2.5",
+    "@formatjs/ecma402-abstract": "1.9.5",
+    "@formatjs/icu-messageformat-parser": "2.0.8",
+    "@formatjs/intl": "1.13.4",
+    "@formatjs/intl-displaynames": "5.2.0",
+    "@formatjs/intl-listformat": "6.3.0",
     "@types/hoist-non-react-statics": "^3.3.1",
     "hoist-non-react-statics": "^3.3.2",
-    "intl-messageformat": "9.6.18",
+    "intl-messageformat": "9.8.1",
     "tslib": "^2.1.0"
   },
   "peerDependencies": {

package/react-intl.iife.js

@@ -288,6 +288,309 @@ var ReactIntl = (function() {
     }
   });
 
+  // bazel-out/darwin-fastbuild/bin/packages/intl-localematcher/abstract/utils.js
+  var require_utils = __commonJS({
+    "bazel-out/darwin-fastbuild/bin/packages/intl-localematcher/abstract/utils.js": function(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", {value: true});
+      exports.invariant = exports.UNICODE_EXTENSION_SEQUENCE_REGEX = void 0;
+      exports.UNICODE_EXTENSION_SEQUENCE_REGEX = /-u(?:-[0-9a-z]{2,8})+/gi;
+      function invariant2(condition, message, Err) {
+        if (Err === void 0) {
+          Err = Error;
+        }
+        if (!condition) {
+          throw new Err(message);
+        }
+      }
+      exports.invariant = invariant2;
+    }
+  });
+
+  // bazel-out/darwin-fastbuild/bin/packages/intl-localematcher/abstract/BestAvailableLocale.js
+  var require_BestAvailableLocale = __commonJS({
+    "bazel-out/darwin-fastbuild/bin/packages/intl-localematcher/abstract/BestAvailableLocale.js": function(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", {value: true});
+      exports.BestAvailableLocale = void 0;
+      function BestAvailableLocale(availableLocales, locale) {
+        var candidate = locale;
+        while (true) {
+          if (availableLocales.has(candidate)) {
+            return candidate;
+          }
+          var pos = candidate.lastIndexOf("-");
+          if (!~pos) {
+            return void 0;
+          }
+          if (pos >= 2 && candidate[pos - 2] === "-") {
+            pos -= 2;
+          }
+          candidate = candidate.slice(0, pos);
+        }
+      }
+      exports.BestAvailableLocale = BestAvailableLocale;
+    }
+  });
+
+  // bazel-out/darwin-fastbuild/bin/packages/intl-localematcher/abstract/LookupMatcher.js
+  var require_LookupMatcher = __commonJS({
+    "bazel-out/darwin-fastbuild/bin/packages/intl-localematcher/abstract/LookupMatcher.js": function(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", {value: true});
+      exports.LookupMatcher = void 0;
+      var utils_1 = require_utils();
+      var BestAvailableLocale_1 = require_BestAvailableLocale();
+      function LookupMatcher(availableLocales, requestedLocales, getDefaultLocale) {
+        var result = {locale: ""};
+        for (var _i = 0, requestedLocales_1 = requestedLocales; _i < requestedLocales_1.length; _i++) {
+          var locale = requestedLocales_1[_i];
+          var noExtensionLocale = locale.replace(utils_1.UNICODE_EXTENSION_SEQUENCE_REGEX, "");
+          var availableLocale = BestAvailableLocale_1.BestAvailableLocale(availableLocales, noExtensionLocale);
+          if (availableLocale) {
+            result.locale = availableLocale;
+            if (locale !== noExtensionLocale) {
+              result.extension = locale.slice(noExtensionLocale.length + 1, locale.length);
+            }
+            return result;
+          }
+        }
+        result.locale = getDefaultLocale();
+        return result;
+      }
+      exports.LookupMatcher = LookupMatcher;
+    }
+  });
+
+  // bazel-out/darwin-fastbuild/bin/packages/intl-localematcher/abstract/BestFitMatcher.js
+  var require_BestFitMatcher = __commonJS({
+    "bazel-out/darwin-fastbuild/bin/packages/intl-localematcher/abstract/BestFitMatcher.js": function(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", {value: true});
+      exports.BestFitMatcher = void 0;
+      var BestAvailableLocale_1 = require_BestAvailableLocale();
+      var utils_1 = require_utils();
+      function BestFitMatcher(availableLocales, requestedLocales, getDefaultLocale) {
+        var minimizedAvailableLocaleMap = Array.from(availableLocales).reduce(function(all, l2) {
+          all[l2] = l2;
+          return all;
+        }, {});
+        var minimizedAvailableLocales = new Set();
+        availableLocales.forEach(function(locale2) {
+          var minimizedLocale = new Intl.Locale(locale2).minimize().toString();
+          minimizedAvailableLocaleMap[minimizedLocale] = locale2;
+          minimizedAvailableLocales.add(minimizedLocale);
+        });
+        var foundLocale;
+        for (var _i = 0, requestedLocales_1 = requestedLocales; _i < requestedLocales_1.length; _i++) {
+          var l = requestedLocales_1[_i];
+          if (foundLocale) {
+            break;
+          }
+          var noExtensionLocale = l.replace(utils_1.UNICODE_EXTENSION_SEQUENCE_REGEX, "");
+          if (availableLocales.has(noExtensionLocale)) {
+            foundLocale = noExtensionLocale;
+            break;
+          }
+          if (minimizedAvailableLocales.has(noExtensionLocale)) {
+            foundLocale = noExtensionLocale;
+            break;
+          }
+          var locale = new Intl.Locale(noExtensionLocale);
+          var maximizedRequestedLocale = locale.maximize().toString();
+          var minimizedRequestedLocale = locale.minimize().toString();
+          if (minimizedAvailableLocales.has(minimizedRequestedLocale)) {
+            foundLocale = minimizedRequestedLocale;
+            break;
+          }
+          foundLocale = BestAvailableLocale_1.BestAvailableLocale(minimizedAvailableLocales, maximizedRequestedLocale);
+        }
+        return {
+          locale: foundLocale && minimizedAvailableLocaleMap[foundLocale] || getDefaultLocale()
+        };
+      }
+      exports.BestFitMatcher = BestFitMatcher;
+    }
+  });
+
+  // bazel-out/darwin-fastbuild/bin/packages/intl-localematcher/abstract/UnicodeExtensionValue.js
+  var require_UnicodeExtensionValue = __commonJS({
+    "bazel-out/darwin-fastbuild/bin/packages/intl-localematcher/abstract/UnicodeExtensionValue.js": function(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", {value: true});
+      exports.UnicodeExtensionValue = void 0;
+      var utils_1 = require_utils();
+      function UnicodeExtensionValue(extension, key) {
+        utils_1.invariant(key.length === 2, "key must have 2 elements");
+        var size = extension.length;
+        var searchValue = "-" + key + "-";
+        var pos = extension.indexOf(searchValue);
+        if (pos !== -1) {
+          var start = pos + 4;
+          var end = start;
+          var k = start;
+          var done = false;
+          while (!done) {
+            var e = extension.indexOf("-", k);
+            var len = void 0;
+            if (e === -1) {
+              len = size - k;
+            } else {
+              len = e - k;
+            }
+            if (len === 2) {
+              done = true;
+            } else if (e === -1) {
+              end = size;
+              done = true;
+            } else {
+              end = e;
+              k = e + 1;
+            }
+          }
+          return extension.slice(start, end);
+        }
+        searchValue = "-" + key;
+        pos = extension.indexOf(searchValue);
+        if (pos !== -1 && pos + 3 === size) {
+          return "";
+        }
+        return void 0;
+      }
+      exports.UnicodeExtensionValue = UnicodeExtensionValue;
+    }
+  });
+
+  // bazel-out/darwin-fastbuild/bin/packages/intl-localematcher/abstract/ResolveLocale.js
+  var require_ResolveLocale = __commonJS({
+    "bazel-out/darwin-fastbuild/bin/packages/intl-localematcher/abstract/ResolveLocale.js": function(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", {value: true});
+      exports.ResolveLocale = void 0;
+      var LookupMatcher_1 = require_LookupMatcher();
+      var BestFitMatcher_1 = require_BestFitMatcher();
+      var utils_1 = require_utils();
+      var UnicodeExtensionValue_1 = require_UnicodeExtensionValue();
+      function ResolveLocale2(availableLocales, requestedLocales, options, relevantExtensionKeys, localeData, getDefaultLocale) {
+        var matcher = options.localeMatcher;
+        var r;
+        if (matcher === "lookup") {
+          r = LookupMatcher_1.LookupMatcher(availableLocales, requestedLocales, getDefaultLocale);
+        } else {
+          r = BestFitMatcher_1.BestFitMatcher(availableLocales, requestedLocales, getDefaultLocale);
+        }
+        var foundLocale = r.locale;
+        var result = {locale: "", dataLocale: foundLocale};
+        var supportedExtension = "-u";
+        for (var _i = 0, relevantExtensionKeys_1 = relevantExtensionKeys; _i < relevantExtensionKeys_1.length; _i++) {
+          var key = relevantExtensionKeys_1[_i];
+          utils_1.invariant(foundLocale in localeData, "Missing locale data for " + foundLocale);
+          var foundLocaleData = localeData[foundLocale];
+          utils_1.invariant(typeof foundLocaleData === "object" && foundLocaleData !== null, "locale data " + key + " must be an object");
+          var keyLocaleData = foundLocaleData[key];
+          utils_1.invariant(Array.isArray(keyLocaleData), "keyLocaleData for " + key + " must be an array");
+          var value = keyLocaleData[0];
+          utils_1.invariant(typeof value === "string" || value === null, "value must be string or null but got " + typeof value + " in key " + key);
+          var supportedExtensionAddition = "";
+          if (r.extension) {
+            var requestedValue = UnicodeExtensionValue_1.UnicodeExtensionValue(r.extension, key);
+            if (requestedValue !== void 0) {
+              if (requestedValue !== "") {
+                if (~keyLocaleData.indexOf(requestedValue)) {
+                  value = requestedValue;
+                  supportedExtensionAddition = "-" + key + "-" + value;
+                }
+              } else if (~requestedValue.indexOf("true")) {
+                value = "true";
+                supportedExtensionAddition = "-" + key;
+              }
+            }
+          }
+          if (key in options) {
+            var optionsValue = options[key];
+            utils_1.invariant(typeof optionsValue === "string" || typeof optionsValue === "undefined" || optionsValue === null, "optionsValue must be String, Undefined or Null");
+            if (~keyLocaleData.indexOf(optionsValue)) {
+              if (optionsValue !== value) {
+                value = optionsValue;
+                supportedExtensionAddition = "";
+              }
+            }
+          }
+          result[key] = value;
+          supportedExtension += supportedExtensionAddition;
+        }
+        if (supportedExtension.length > 2) {
+          var privateIndex = foundLocale.indexOf("-x-");
+          if (privateIndex === -1) {
+            foundLocale = foundLocale + supportedExtension;
+          } else {
+            var preExtension = foundLocale.slice(0, privateIndex);
+            var postExtension = foundLocale.slice(privateIndex, foundLocale.length);
+            foundLocale = preExtension + supportedExtension + postExtension;
+          }
+          foundLocale = Intl.getCanonicalLocales(foundLocale)[0];
+        }
+        result.locale = foundLocale;
+        return result;
+      }
+      exports.ResolveLocale = ResolveLocale2;
+    }
+  });
+
+  // bazel-out/darwin-fastbuild/bin/packages/intl-localematcher/abstract/LookupSupportedLocales.js
+  var require_LookupSupportedLocales = __commonJS({
+    "bazel-out/darwin-fastbuild/bin/packages/intl-localematcher/abstract/LookupSupportedLocales.js": function(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", {value: true});
+      exports.LookupSupportedLocales = void 0;
+      var utils_1 = require_utils();
+      var BestAvailableLocale_1 = require_BestAvailableLocale();
+      function LookupSupportedLocales2(availableLocales, requestedLocales) {
+        var subset = [];
+        for (var _i = 0, requestedLocales_1 = requestedLocales; _i < requestedLocales_1.length; _i++) {
+          var locale = requestedLocales_1[_i];
+          var noExtensionLocale = locale.replace(utils_1.UNICODE_EXTENSION_SEQUENCE_REGEX, "");
+          var availableLocale = BestAvailableLocale_1.BestAvailableLocale(availableLocales, noExtensionLocale);
+          if (availableLocale) {
+            subset.push(availableLocale);
+          }
+        }
+        return subset;
+      }
+      exports.LookupSupportedLocales = LookupSupportedLocales2;
+    }
+  });
+
+  // bazel-out/darwin-fastbuild/bin/packages/intl-localematcher/index.js
+  var require_intl_localematcher = __commonJS({
+    "bazel-out/darwin-fastbuild/bin/packages/intl-localematcher/index.js": function(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", {value: true});
+      exports.ResolveLocale = exports.LookupSupportedLocales = exports.match = void 0;
+      var ResolveLocale_1 = require_ResolveLocale();
+      function match(requestedLocales, availableLocales, defaultLocale, opts) {
+        var locales = availableLocales.reduce(function(all, l) {
+          all.add(l);
+          return all;
+        }, new Set());
+        return ResolveLocale_1.ResolveLocale(locales, requestedLocales, {
+          localeMatcher: (opts === null || opts === void 0 ? void 0 : opts.algorithm) || "best fit"
+        }, [], {}, function() {
+          return defaultLocale;
+        }).locale;
+      }
+      exports.match = match;
+      var LookupSupportedLocales_1 = require_LookupSupportedLocales();
+      Object.defineProperty(exports, "LookupSupportedLocales", {enumerable: true, get: function() {
+        return LookupSupportedLocales_1.LookupSupportedLocales;
+      }});
+      var ResolveLocale_2 = require_ResolveLocale();
+      Object.defineProperty(exports, "ResolveLocale", {enumerable: true, get: function() {
+        return ResolveLocale_2.ResolveLocale;
+      }});
+    }
+  });
+
   // bazel-out/darwin-fastbuild/bin/packages/react-intl/lib/index.js
   var lib_exports = {};
   __export(lib_exports, {
@@ -424,10 +727,16 @@ var ReactIntl = (function() {
       }
     return t;
   }
-  function __spreadArray(to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-      to[j] = from[i];
-    return to;
+  function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2)
+      for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar)
+            ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+    return to.concat(ar || from);
   }
 
   // bazel-out/darwin-fastbuild/bin/packages/react-intl/lib/src/components/createFormattedComponent.js
@@ -518,6 +827,12 @@ var ReactIntl = (function() {
   var CARET_S_UNICODE_REGEX = new RegExp("^" + S_UNICODE_REGEX.source);
   var S_DOLLAR_UNICODE_REGEX = new RegExp(S_UNICODE_REGEX.source + "$");
 
+  // bazel-out/darwin-fastbuild/bin/packages/ecma402-abstract/lib/NumberFormat/InitializeNumberFormat.js
+  var import_intl_localematcher = __toModule(require_intl_localematcher());
+
+  // bazel-out/darwin-fastbuild/bin/packages/ecma402-abstract/lib/SupportedLocales.js
+  var import_intl_localematcher2 = __toModule(require_intl_localematcher());
+
   // bazel-out/darwin-fastbuild/bin/packages/ecma402-abstract/lib/data.js
   var MissingLocaleDataError = function(_super) {
     __extends(MissingLocaleDataError2, _super);
@@ -2187,6 +2502,9 @@ var ReactIntl = (function() {
     IntlMessageFormat2.__parse = parse;
     IntlMessageFormat2.formats = {
       number: {
+        integer: {
+          maximumFractionDigits: 0
+        },
         currency: {
           style: "currency"
         },