@formatjs/intl-locale 4.2.4 → 4.2.6

package/polyfill.iife.js

@@ -1416,15 +1416,21 @@
       var serializerDefault2 = function() {
         return JSON.stringify(arguments);
       };
-      function ObjectWithoutPrototypeCache2() {
-        this.cache = /* @__PURE__ */ Object.create(null);
-      }
-      ObjectWithoutPrototypeCache2.prototype.get = function(key) {
-        return this.cache[key];
-      };
-      ObjectWithoutPrototypeCache2.prototype.set = function(key, value) {
-        this.cache[key] = value;
-      };
+      var ObjectWithoutPrototypeCache2 = (
+        /** @class */
+        function() {
+          function ObjectWithoutPrototypeCache3() {
+            this.cache = /* @__PURE__ */ Object.create(null);
+          }
+          ObjectWithoutPrototypeCache3.prototype.get = function(key) {
+            return this.cache[key];
+          };
+          ObjectWithoutPrototypeCache3.prototype.set = function(key, value) {
+            this.cache[key] = value;
+          };
+          return ObjectWithoutPrototypeCache3;
+        }()
+      );
       var cacheDefault2 = {
         create: function create2() {
           return new ObjectWithoutPrototypeCache2();
@@ -7379,6 +7385,74 @@
     }
   });
 
+  // node_modules/.aspect_rules_js/@formatjs+intl-localematcher@0.0.0/node_modules/@formatjs/intl-localematcher/abstract/CanonicalizeUValue.js
+  var require_CanonicalizeUValue = __commonJS({
+    "node_modules/.aspect_rules_js/@formatjs+intl-localematcher@0.0.0/node_modules/@formatjs/intl-localematcher/abstract/CanonicalizeUValue.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.CanonicalizeUValue = CanonicalizeUValue2;
+      var utils_1 = require_utils2();
+      function CanonicalizeUValue2(ukey, uvalue) {
+        var lowerValue = uvalue.toLowerCase();
+        (0, utils_1.invariant)(ukey !== void 0, "ukey must be defined");
+        var canonicalized = lowerValue;
+        return canonicalized;
+      }
+    }
+  });
+
+  // node_modules/.aspect_rules_js/@formatjs+intl-localematcher@0.0.0/node_modules/@formatjs/intl-localematcher/abstract/CanonicalizeUnicodeLocaleId.js
+  var require_CanonicalizeUnicodeLocaleId = __commonJS({
+    "node_modules/.aspect_rules_js/@formatjs+intl-localematcher@0.0.0/node_modules/@formatjs/intl-localematcher/abstract/CanonicalizeUnicodeLocaleId.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.CanonicalizeUnicodeLocaleId = CanonicalizeUnicodeLocaleId2;
+      function CanonicalizeUnicodeLocaleId2(locale) {
+        return Intl.getCanonicalLocales(locale)[0];
+      }
+    }
+  });
+
+  // node_modules/.aspect_rules_js/@formatjs+intl-localematcher@0.0.0/node_modules/@formatjs/intl-localematcher/abstract/InsertUnicodeExtensionAndCanonicalize.js
+  var require_InsertUnicodeExtensionAndCanonicalize = __commonJS({
+    "node_modules/.aspect_rules_js/@formatjs+intl-localematcher@0.0.0/node_modules/@formatjs/intl-localematcher/abstract/InsertUnicodeExtensionAndCanonicalize.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.InsertUnicodeExtensionAndCanonicalize = InsertUnicodeExtensionAndCanonicalize2;
+      var CanonicalizeUnicodeLocaleId_1 = require_CanonicalizeUnicodeLocaleId();
+      var utils_1 = require_utils2();
+      function InsertUnicodeExtensionAndCanonicalize2(locale, attributes, keywords) {
+        (0, utils_1.invariant)(locale.indexOf("-u-") === -1, "Expected locale to not have a Unicode locale extension");
+        var extension = "-u";
+        for (var _i = 0, attributes_1 = attributes; _i < attributes_1.length; _i++) {
+          var attr = attributes_1[_i];
+          extension += "-".concat(attr);
+        }
+        for (var _a = 0, keywords_1 = keywords; _a < keywords_1.length; _a++) {
+          var kw = keywords_1[_a];
+          var key = kw.key, value = kw.value;
+          extension += "-".concat(key);
+          if (value !== "") {
+            extension += "-".concat(value);
+          }
+        }
+        if (extension === "-u") {
+          return (0, CanonicalizeUnicodeLocaleId_1.CanonicalizeUnicodeLocaleId)(locale);
+        }
+        var privateIndex = locale.indexOf("-x-");
+        var newLocale;
+        if (privateIndex === -1) {
+          newLocale = locale + extension;
+        } else {
+          var preExtension = locale.slice(0, privateIndex);
+          var postExtension = locale.slice(privateIndex);
+          newLocale = preExtension + extension + postExtension;
+        }
+        return (0, CanonicalizeUnicodeLocaleId_1.CanonicalizeUnicodeLocaleId)(newLocale);
+      }
+    }
+  });
+
   // node_modules/.aspect_rules_js/@formatjs+intl-localematcher@0.0.0/node_modules/@formatjs/intl-localematcher/abstract/BestAvailableLocale.js
   var require_BestAvailableLocale = __commonJS({
     "node_modules/.aspect_rules_js/@formatjs+intl-localematcher@0.0.0/node_modules/@formatjs/intl-localematcher/abstract/BestAvailableLocale.js"(exports) {
@@ -7432,49 +7506,51 @@
     }
   });
 
-  // node_modules/.aspect_rules_js/@formatjs+intl-localematcher@0.0.0/node_modules/@formatjs/intl-localematcher/abstract/UnicodeExtensionValue.js
-  var require_UnicodeExtensionValue = __commonJS({
-    "node_modules/.aspect_rules_js/@formatjs+intl-localematcher@0.0.0/node_modules/@formatjs/intl-localematcher/abstract/UnicodeExtensionValue.js"(exports) {
+  // node_modules/.aspect_rules_js/@formatjs+intl-localematcher@0.0.0/node_modules/@formatjs/intl-localematcher/abstract/UnicodeExtensionComponents.js
+  var require_UnicodeExtensionComponents = __commonJS({
+    "node_modules/.aspect_rules_js/@formatjs+intl-localematcher@0.0.0/node_modules/@formatjs/intl-localematcher/abstract/UnicodeExtensionComponents.js"(exports) {
       "use strict";
       Object.defineProperty(exports, "__esModule", { value: true });
-      exports.UnicodeExtensionValue = UnicodeExtensionValue2;
+      exports.UnicodeExtensionComponents = UnicodeExtensionComponents2;
       var utils_1 = require_utils2();
-      function UnicodeExtensionValue2(extension, key) {
-        (0, utils_1.invariant)(key.length === 2, "key must have 2 elements");
+      function UnicodeExtensionComponents2(extension) {
+        (0, utils_1.invariant)(extension === extension.toLowerCase(), "Expected extension to be lowercase");
+        (0, utils_1.invariant)(extension.slice(0, 3) === "-u-", "Expected extension to be a Unicode locale extension");
+        var attributes = [];
+        var keywords = [];
+        var keyword;
         var size = extension.length;
-        var searchValue = "-".concat(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;
+        var k = 3;
+        while (k < size) {
+          var e = extension.indexOf("-", k);
+          var len = void 0;
+          if (e === -1) {
+            len = size - k;
+          } else {
+            len = e - k;
+          }
+          var subtag = extension.slice(k, k + len);
+          (0, utils_1.invariant)(len >= 2, "Expected a subtag to have at least 2 characters");
+          if (keyword === void 0 && len != 2) {
+            if (attributes.indexOf(subtag) === -1) {
+              attributes.push(subtag);
             }
-            if (len === 2) {
-              done = true;
-            } else if (e === -1) {
-              end = size;
-              done = true;
-            } else {
-              end = e;
-              k = e + 1;
+          } else if (len === 2) {
+            keyword = { key: subtag, value: "" };
+            if (keywords.find(function(k2) {
+              return k2.key === (keyword === null || keyword === void 0 ? void 0 : keyword.key);
+            }) === void 0) {
+              keywords.push(keyword);
             }
+          } else if ((keyword === null || keyword === void 0 ? void 0 : keyword.value) === "") {
+            keyword.value = subtag;
+          } else {
+            (0, utils_1.invariant)(keyword !== void 0, "Expected keyword to be defined");
+            keyword.value += "-" + subtag;
           }
-          return extension.slice(start, end);
+          k += len + 1;
         }
-        searchValue = "-".concat(key);
-        pos = extension.indexOf(searchValue);
-        if (pos !== -1 && pos + 3 === size) {
-          return "";
-        }
-        return void 0;
+        return { attributes, keywords };
       }
     }
   });
@@ -7486,10 +7562,13 @@
       Object.defineProperty(exports, "__esModule", { value: true });
       exports.ResolveLocale = ResolveLocale2;
       var BestFitMatcher_1 = require_BestFitMatcher();
+      var CanonicalizeUValue_1 = require_CanonicalizeUValue();
+      var InsertUnicodeExtensionAndCanonicalize_1 = require_InsertUnicodeExtensionAndCanonicalize();
       var LookupMatcher_1 = require_LookupMatcher();
-      var UnicodeExtensionValue_1 = require_UnicodeExtensionValue();
+      var UnicodeExtensionComponents_1 = require_UnicodeExtensionComponents();
       var utils_1 = require_utils2();
       function ResolveLocale2(availableLocales, requestedLocales, options, relevantExtensionKeys, localeData, getDefaultLocale) {
+        var _a;
         var matcher = options.localeMatcher;
         var r;
         if (matcher === "lookup") {
@@ -7497,56 +7576,77 @@
         } else {
           r = (0, BestFitMatcher_1.BestFitMatcher)(Array.from(availableLocales), requestedLocales, getDefaultLocale);
         }
+        if (r == null) {
+          r = {
+            locale: getDefaultLocale(),
+            extension: ""
+          };
+        }
         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];
-          (0, utils_1.invariant)(foundLocale in localeData, "Missing locale data for ".concat(foundLocale));
-          var foundLocaleData = localeData[foundLocale];
-          (0, utils_1.invariant)(typeof foundLocaleData === "object" && foundLocaleData !== null, "locale data ".concat(key, " must be an object"));
-          var keyLocaleData = foundLocaleData[key];
-          (0, utils_1.invariant)(Array.isArray(keyLocaleData), "keyLocaleData for ".concat(key, " must be an array"));
+        var foundLocaleData = localeData[foundLocale];
+        var result = { locale: "en", dataLocale: foundLocale };
+        var components;
+        var keywords;
+        if (r.extension) {
+          components = (0, UnicodeExtensionComponents_1.UnicodeExtensionComponents)(r.extension);
+          keywords = components.keywords;
+        } else {
+          keywords = [];
+        }
+        var supportedKeywords = [];
+        var _loop_1 = function(key2) {
+          var keyLocaleData = (_a = foundLocaleData === null || foundLocaleData === void 0 ? void 0 : foundLocaleData[key2]) !== null && _a !== void 0 ? _a : [];
+          (0, utils_1.invariant)(Array.isArray(keyLocaleData), "keyLocaleData for ".concat(key2, " must be an array"));
           var value = keyLocaleData[0];
-          (0, utils_1.invariant)(typeof value === "string" || value === null, "value must be string or null but got ".concat(typeof value, " in key ").concat(key));
-          var supportedExtensionAddition = "";
-          if (r.extension) {
-            var requestedValue = (0, UnicodeExtensionValue_1.UnicodeExtensionValue)(r.extension, key);
-            if (requestedValue !== void 0) {
-              if (requestedValue !== "") {
-                if (~keyLocaleData.indexOf(requestedValue)) {
-                  value = requestedValue;
-                  supportedExtensionAddition = "-".concat(key, "-").concat(value);
-                }
-              } else if (~requestedValue.indexOf("true")) {
-                value = "true";
-                supportedExtensionAddition = "-".concat(key);
+          (0, utils_1.invariant)(value === void 0 || typeof value === "string", "value must be a string or undefined");
+          var supportedKeyword = void 0;
+          var entry = keywords.find(function(k) {
+            return k.key === key2;
+          });
+          if (entry) {
+            var requestedValue = entry.value;
+            if (requestedValue !== "") {
+              if (keyLocaleData.indexOf(requestedValue) > -1) {
+                value = requestedValue;
+                supportedKeyword = {
+                  key: key2,
+                  value
+                };
               }
+            } else if (keyLocaleData.indexOf("true") > -1) {
+              value = "true";
+              supportedKeyword = {
+                key: key2,
+                value
+              };
             }
           }
-          if (key in options) {
-            var optionsValue = options[key];
-            (0, 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 = "";
-              }
+          var optionsValue = options[key2];
+          (0, utils_1.invariant)(optionsValue == null || typeof optionsValue === "string", "optionsValue must be a string or undefined");
+          if (typeof optionsValue === "string") {
+            var ukey = key2.toLowerCase();
+            optionsValue = (0, CanonicalizeUValue_1.CanonicalizeUValue)(ukey, optionsValue);
+            if (optionsValue === "") {
+              optionsValue = "true";
             }
           }
-          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;
+          if (optionsValue !== value && keyLocaleData.indexOf(optionsValue) > -1) {
+            value = optionsValue;
+            supportedKeyword = void 0;
           }
-          foundLocale = Intl.getCanonicalLocales(foundLocale)[0];
+          if (supportedKeyword) {
+            supportedKeywords.push(supportedKeyword);
+          }
+          result[key2] = value;
+        };
+        for (var _i = 0, relevantExtensionKeys_1 = relevantExtensionKeys; _i < relevantExtensionKeys_1.length; _i++) {
+          var key = relevantExtensionKeys_1[_i];
+          _loop_1(key);
+        }
+        var supportedAttributes = [];
+        if (supportedKeywords.length > 0) {
+          supportedAttributes = [];
+          foundLocale = (0, InsertUnicodeExtensionAndCanonicalize_1.InsertUnicodeExtensionAndCanonicalize)(foundLocale, supportedAttributes, supportedKeywords);
         }
         result.locale = foundLocale;
         return result;
@@ -8382,290 +8482,9 @@
     }
   });
 
-  // node_modules/.aspect_rules_js/@formatjs+intl-getcanonicallocales@0.0.0/node_modules/@formatjs/intl-getcanonicallocales/src/parser.js
-  var require_parser = __commonJS({
-    "node_modules/.aspect_rules_js/@formatjs+intl-getcanonicallocales@0.0.0/node_modules/@formatjs/intl-getcanonicallocales/src/parser.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.SEPARATOR = void 0;
-      exports.isUnicodeLanguageSubtag = isUnicodeLanguageSubtag2;
-      exports.isStructurallyValidLanguageTag = isStructurallyValidLanguageTag2;
-      exports.isUnicodeRegionSubtag = isUnicodeRegionSubtag2;
-      exports.isUnicodeScriptSubtag = isUnicodeScriptSubtag2;
-      exports.isUnicodeVariantSubtag = isUnicodeVariantSubtag;
-      exports.parseUnicodeLanguageId = parseUnicodeLanguageId2;
-      exports.parseUnicodeLocaleId = parseUnicodeLocaleId2;
-      var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
-      var ALPHANUM_1_8 = /^[a-z0-9]{1,8}$/i;
-      var ALPHANUM_2_8 = /^[a-z0-9]{2,8}$/i;
-      var ALPHANUM_3_82 = /^[a-z0-9]{3,8}$/i;
-      var KEY_REGEX = /^[a-z0-9][a-z]$/i;
-      var TYPE_REGEX = /^[a-z0-9]{3,8}$/i;
-      var ALPHA_4 = /^[a-z]{4}$/i;
-      var OTHER_EXTENSION_TYPE = /^[0-9a-svwyz]$/i;
-      var UNICODE_REGION_SUBTAG_REGEX = /^([a-z]{2}|[0-9]{3})$/i;
-      var UNICODE_VARIANT_SUBTAG_REGEX = /^([a-z0-9]{5,8}|[0-9][a-z0-9]{3})$/i;
-      var UNICODE_LANGUAGE_SUBTAG_REGEX = /^([a-z]{2,3}|[a-z]{5,8})$/i;
-      var TKEY_REGEX = /^[a-z][0-9]$/i;
-      exports.SEPARATOR = "-";
-      function isUnicodeLanguageSubtag2(lang) {
-        return UNICODE_LANGUAGE_SUBTAG_REGEX.test(lang);
-      }
-      function isStructurallyValidLanguageTag2(tag) {
-        try {
-          parseUnicodeLanguageId2(tag.split(exports.SEPARATOR));
-        } catch (e) {
-          return false;
-        }
-        return true;
-      }
-      function isUnicodeRegionSubtag2(region) {
-        return UNICODE_REGION_SUBTAG_REGEX.test(region);
-      }
-      function isUnicodeScriptSubtag2(script) {
-        return ALPHA_4.test(script);
-      }
-      function isUnicodeVariantSubtag(variant) {
-        return UNICODE_VARIANT_SUBTAG_REGEX.test(variant);
-      }
-      function parseUnicodeLanguageId2(chunks) {
-        if (typeof chunks === "string") {
-          chunks = chunks.split(exports.SEPARATOR);
-        }
-        var lang = chunks.shift();
-        if (!lang) {
-          throw new RangeError("Missing unicode_language_subtag");
-        }
-        if (lang === "root") {
-          return { lang: "root", variants: [] };
-        }
-        if (!isUnicodeLanguageSubtag2(lang)) {
-          throw new RangeError("Malformed unicode_language_subtag");
-        }
-        var script;
-        if (chunks.length && isUnicodeScriptSubtag2(chunks[0])) {
-          script = chunks.shift();
-        }
-        var region;
-        if (chunks.length && isUnicodeRegionSubtag2(chunks[0])) {
-          region = chunks.shift();
-        }
-        var variants = {};
-        while (chunks.length && isUnicodeVariantSubtag(chunks[0])) {
-          var variant = chunks.shift();
-          if (variant in variants) {
-            throw new RangeError('Duplicate variant "'.concat(variant, '"'));
-          }
-          variants[variant] = 1;
-        }
-        return {
-          lang,
-          script,
-          region,
-          variants: Object.keys(variants)
-        };
-      }
-      function parseUnicodeExtension(chunks) {
-        var keywords = [];
-        var keyword;
-        while (chunks.length && (keyword = parseKeyword(chunks))) {
-          keywords.push(keyword);
-        }
-        if (keywords.length) {
-          return {
-            type: "u",
-            keywords,
-            attributes: []
-          };
-        }
-        var attributes = [];
-        while (chunks.length && ALPHANUM_3_82.test(chunks[0])) {
-          attributes.push(chunks.shift());
-        }
-        while (chunks.length && (keyword = parseKeyword(chunks))) {
-          keywords.push(keyword);
-        }
-        if (keywords.length || attributes.length) {
-          return {
-            type: "u",
-            attributes,
-            keywords
-          };
-        }
-        throw new RangeError("Malformed unicode_extension");
-      }
-      function parseKeyword(chunks) {
-        var key;
-        if (!KEY_REGEX.test(chunks[0])) {
-          return;
-        }
-        key = chunks.shift();
-        var type = [];
-        while (chunks.length && TYPE_REGEX.test(chunks[0])) {
-          type.push(chunks.shift());
-        }
-        var value = "";
-        if (type.length) {
-          value = type.join(exports.SEPARATOR);
-        }
-        return [key, value];
-      }
-      function parseTransformedExtension(chunks) {
-        var lang;
-        try {
-          lang = parseUnicodeLanguageId2(chunks);
-        } catch (e) {
-        }
-        var fields = [];
-        while (chunks.length && TKEY_REGEX.test(chunks[0])) {
-          var key = chunks.shift();
-          var value = [];
-          while (chunks.length && ALPHANUM_3_82.test(chunks[0])) {
-            value.push(chunks.shift());
-          }
-          if (!value.length) {
-            throw new RangeError('Missing tvalue for tkey "'.concat(key, '"'));
-          }
-          fields.push([key, value.join(exports.SEPARATOR)]);
-        }
-        if (fields.length) {
-          return {
-            type: "t",
-            fields,
-            lang
-          };
-        }
-        throw new RangeError("Malformed transformed_extension");
-      }
-      function parsePuExtension(chunks) {
-        var exts = [];
-        while (chunks.length && ALPHANUM_1_8.test(chunks[0])) {
-          exts.push(chunks.shift());
-        }
-        if (exts.length) {
-          return {
-            type: "x",
-            value: exts.join(exports.SEPARATOR)
-          };
-        }
-        throw new RangeError("Malformed private_use_extension");
-      }
-      function parseOtherExtensionValue(chunks) {
-        var exts = [];
-        while (chunks.length && ALPHANUM_2_8.test(chunks[0])) {
-          exts.push(chunks.shift());
-        }
-        if (exts.length) {
-          return exts.join(exports.SEPARATOR);
-        }
-        return "";
-      }
-      function parseExtensions(chunks) {
-        if (!chunks.length) {
-          return { extensions: [] };
-        }
-        var extensions = [];
-        var unicodeExtension;
-        var transformedExtension;
-        var puExtension;
-        var otherExtensionMap = {};
-        do {
-          var type = chunks.shift();
-          switch (type) {
-            case "u":
-            case "U":
-              if (unicodeExtension) {
-                throw new RangeError("There can only be 1 -u- extension");
-              }
-              unicodeExtension = parseUnicodeExtension(chunks);
-              extensions.push(unicodeExtension);
-              break;
-            case "t":
-            case "T":
-              if (transformedExtension) {
-                throw new RangeError("There can only be 1 -t- extension");
-              }
-              transformedExtension = parseTransformedExtension(chunks);
-              extensions.push(transformedExtension);
-              break;
-            case "x":
-            case "X":
-              if (puExtension) {
-                throw new RangeError("There can only be 1 -x- extension");
-              }
-              puExtension = parsePuExtension(chunks);
-              extensions.push(puExtension);
-              break;
-            default:
-              if (!OTHER_EXTENSION_TYPE.test(type)) {
-                throw new RangeError("Malformed extension type");
-              }
-              if (type in otherExtensionMap) {
-                throw new RangeError("There can only be 1 -".concat(type, "- extension"));
-              }
-              var extension = {
-                type,
-                value: parseOtherExtensionValue(chunks)
-              };
-              otherExtensionMap[extension.type] = extension;
-              extensions.push(extension);
-              break;
-          }
-        } while (chunks.length);
-        return { extensions };
-      }
-      function parseUnicodeLocaleId2(locale) {
-        var chunks = locale.split(exports.SEPARATOR);
-        var lang = parseUnicodeLanguageId2(chunks);
-        return tslib_1.__assign({ lang }, parseExtensions(chunks));
-      }
-    }
-  });
-
-  // node_modules/.aspect_rules_js/@formatjs+intl-getcanonicallocales@0.0.0/node_modules/@formatjs/intl-getcanonicallocales/src/emitter.js
-  var require_emitter = __commonJS({
-    "node_modules/.aspect_rules_js/@formatjs+intl-getcanonicallocales@0.0.0/node_modules/@formatjs/intl-getcanonicallocales/src/emitter.js"(exports) {
-      "use strict";
-      Object.defineProperty(exports, "__esModule", { value: true });
-      exports.emitUnicodeLanguageId = emitUnicodeLanguageId2;
-      exports.emitUnicodeLocaleId = emitUnicodeLocaleId2;
-      var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
-      function emitUnicodeLanguageId2(lang) {
-        if (!lang) {
-          return "";
-        }
-        return tslib_1.__spreadArray([lang.lang, lang.script, lang.region], lang.variants || [], true).filter(Boolean).join("-");
-      }
-      function emitUnicodeLocaleId2(_a) {
-        var lang = _a.lang, extensions = _a.extensions;
-        var chunks = [emitUnicodeLanguageId2(lang)];
-        for (var _i = 0, extensions_1 = extensions; _i < extensions_1.length; _i++) {
-          var ext = extensions_1[_i];
-          chunks.push(ext.type);
-          switch (ext.type) {
-            case "u":
-              chunks.push.apply(chunks, tslib_1.__spreadArray(tslib_1.__spreadArray([], ext.attributes, false), ext.keywords.reduce(function(all, kv) {
-                return all.concat(kv);
-              }, []), false));
-              break;
-            case "t":
-              chunks.push.apply(chunks, tslib_1.__spreadArray([emitUnicodeLanguageId2(ext.lang)], ext.fields.reduce(function(all, kv) {
-                return all.concat(kv);
-              }, []), false));
-              break;
-            default:
-              chunks.push(ext.value);
-              break;
-          }
-        }
-        return chunks.filter(Boolean).join("-");
-      }
-    }
-  });
-
-  // node_modules/.aspect_rules_js/@formatjs+intl-getcanonicallocales@0.0.0/node_modules/@formatjs/intl-getcanonicallocales/src/aliases.generated.js
-  var require_aliases_generated = __commonJS({
-    "node_modules/.aspect_rules_js/@formatjs+intl-getcanonicallocales@0.0.0/node_modules/@formatjs/intl-getcanonicallocales/src/aliases.generated.js"(exports) {
+  // node_modules/.aspect_rules_js/@formatjs+intl-getcanonicallocales@0.0.0/node_modules/@formatjs/intl-getcanonicallocales/src/aliases.generated.js
+  var require_aliases_generated = __commonJS({
+    "node_modules/.aspect_rules_js/@formatjs+intl-getcanonicallocales@0.0.0/node_modules/@formatjs/intl-getcanonicallocales/src/aliases.generated.js"(exports) {
       "use strict";
       Object.defineProperty(exports, "__esModule", { value: true });
       exports.variantAlias = exports.scriptAlias = exports.territoryAlias = exports.languageAlias = void 0;
@@ -9821,6 +9640,47 @@
     }
   });
 
+  // node_modules/.aspect_rules_js/@formatjs+intl-getcanonicallocales@0.0.0/node_modules/@formatjs/intl-getcanonicallocales/src/emitter.js
+  var require_emitter = __commonJS({
+    "node_modules/.aspect_rules_js/@formatjs+intl-getcanonicallocales@0.0.0/node_modules/@formatjs/intl-getcanonicallocales/src/emitter.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.emitUnicodeLanguageId = emitUnicodeLanguageId2;
+      exports.emitUnicodeLocaleId = emitUnicodeLocaleId2;
+      var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
+      function emitUnicodeLanguageId2(lang) {
+        if (!lang) {
+          return "";
+        }
+        return tslib_1.__spreadArray([lang.lang, lang.script, lang.region], lang.variants || [], true).filter(Boolean).join("-");
+      }
+      function emitUnicodeLocaleId2(_a) {
+        var lang = _a.lang, extensions = _a.extensions;
+        var chunks = [emitUnicodeLanguageId2(lang)];
+        for (var _i = 0, extensions_1 = extensions; _i < extensions_1.length; _i++) {
+          var ext = extensions_1[_i];
+          chunks.push(ext.type);
+          switch (ext.type) {
+            case "u":
+              chunks.push.apply(chunks, tslib_1.__spreadArray(tslib_1.__spreadArray([], ext.attributes, false), ext.keywords.reduce(function(all, kv) {
+                return all.concat(kv);
+              }, []), false));
+              break;
+            case "t":
+              chunks.push.apply(chunks, tslib_1.__spreadArray([emitUnicodeLanguageId2(ext.lang)], ext.fields.reduce(function(all, kv) {
+                return all.concat(kv);
+              }, []), false));
+              break;
+            default:
+              chunks.push(ext.value);
+              break;
+          }
+        }
+        return chunks.filter(Boolean).join("-");
+      }
+    }
+  });
+
   // node_modules/.aspect_rules_js/@formatjs+intl-getcanonicallocales@0.0.0/node_modules/@formatjs/intl-getcanonicallocales/src/likelySubtags.generated.js
   var require_likelySubtags_generated = __commonJS({
     "node_modules/.aspect_rules_js/@formatjs+intl-getcanonicallocales@0.0.0/node_modules/@formatjs/intl-getcanonicallocales/src/likelySubtags.generated.js"(exports) {
@@ -17570,18 +17430,258 @@
     }
   });
 
+  // node_modules/.aspect_rules_js/@formatjs+intl-getcanonicallocales@0.0.0/node_modules/@formatjs/intl-getcanonicallocales/src/parser.js
+  var require_parser = __commonJS({
+    "node_modules/.aspect_rules_js/@formatjs+intl-getcanonicallocales@0.0.0/node_modules/@formatjs/intl-getcanonicallocales/src/parser.js"(exports) {
+      "use strict";
+      Object.defineProperty(exports, "__esModule", { value: true });
+      exports.SEPARATOR = void 0;
+      exports.isUnicodeLanguageSubtag = isUnicodeLanguageSubtag2;
+      exports.isStructurallyValidLanguageTag = isStructurallyValidLanguageTag2;
+      exports.isUnicodeRegionSubtag = isUnicodeRegionSubtag2;
+      exports.isUnicodeScriptSubtag = isUnicodeScriptSubtag2;
+      exports.isUnicodeVariantSubtag = isUnicodeVariantSubtag;
+      exports.parseUnicodeLanguageId = parseUnicodeLanguageId2;
+      exports.parseUnicodeLocaleId = parseUnicodeLocaleId2;
+      var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
+      var ALPHANUM_1_8 = /^[a-z0-9]{1,8}$/i;
+      var ALPHANUM_2_8 = /^[a-z0-9]{2,8}$/i;
+      var ALPHANUM_3_82 = /^[a-z0-9]{3,8}$/i;
+      var KEY_REGEX = /^[a-z0-9][a-z]$/i;
+      var TYPE_REGEX = /^[a-z0-9]{3,8}$/i;
+      var ALPHA_4 = /^[a-z]{4}$/i;
+      var OTHER_EXTENSION_TYPE = /^[0-9a-svwyz]$/i;
+      var UNICODE_REGION_SUBTAG_REGEX = /^([a-z]{2}|[0-9]{3})$/i;
+      var UNICODE_VARIANT_SUBTAG_REGEX = /^([a-z0-9]{5,8}|[0-9][a-z0-9]{3})$/i;
+      var UNICODE_LANGUAGE_SUBTAG_REGEX = /^([a-z]{2,3}|[a-z]{5,8})$/i;
+      var TKEY_REGEX = /^[a-z][0-9]$/i;
+      exports.SEPARATOR = "-";
+      function isUnicodeLanguageSubtag2(lang) {
+        return UNICODE_LANGUAGE_SUBTAG_REGEX.test(lang);
+      }
+      function isStructurallyValidLanguageTag2(tag) {
+        try {
+          parseUnicodeLanguageId2(tag.split(exports.SEPARATOR));
+        } catch (e) {
+          return false;
+        }
+        return true;
+      }
+      function isUnicodeRegionSubtag2(region) {
+        return UNICODE_REGION_SUBTAG_REGEX.test(region);
+      }
+      function isUnicodeScriptSubtag2(script) {
+        return ALPHA_4.test(script);
+      }
+      function isUnicodeVariantSubtag(variant) {
+        return UNICODE_VARIANT_SUBTAG_REGEX.test(variant);
+      }
+      function parseUnicodeLanguageId2(chunks) {
+        if (typeof chunks === "string") {
+          chunks = chunks.split(exports.SEPARATOR);
+        }
+        var lang = chunks.shift();
+        if (!lang) {
+          throw new RangeError("Missing unicode_language_subtag");
+        }
+        if (lang === "root") {
+          return { lang: "root", variants: [] };
+        }
+        if (!isUnicodeLanguageSubtag2(lang)) {
+          throw new RangeError("Malformed unicode_language_subtag");
+        }
+        var script;
+        if (chunks.length && isUnicodeScriptSubtag2(chunks[0])) {
+          script = chunks.shift();
+        }
+        var region;
+        if (chunks.length && isUnicodeRegionSubtag2(chunks[0])) {
+          region = chunks.shift();
+        }
+        var variants = {};
+        while (chunks.length && isUnicodeVariantSubtag(chunks[0])) {
+          var variant = chunks.shift();
+          if (variant in variants) {
+            throw new RangeError('Duplicate variant "'.concat(variant, '"'));
+          }
+          variants[variant] = 1;
+        }
+        return {
+          lang,
+          script,
+          region,
+          variants: Object.keys(variants)
+        };
+      }
+      function parseUnicodeExtension(chunks) {
+        var keywords = [];
+        var keyword;
+        while (chunks.length && (keyword = parseKeyword(chunks))) {
+          keywords.push(keyword);
+        }
+        if (keywords.length) {
+          return {
+            type: "u",
+            keywords,
+            attributes: []
+          };
+        }
+        var attributes = [];
+        while (chunks.length && ALPHANUM_3_82.test(chunks[0])) {
+          attributes.push(chunks.shift());
+        }
+        while (chunks.length && (keyword = parseKeyword(chunks))) {
+          keywords.push(keyword);
+        }
+        if (keywords.length || attributes.length) {
+          return {
+            type: "u",
+            attributes,
+            keywords
+          };
+        }
+        throw new RangeError("Malformed unicode_extension");
+      }
+      function parseKeyword(chunks) {
+        var key;
+        if (!KEY_REGEX.test(chunks[0])) {
+          return;
+        }
+        key = chunks.shift();
+        var type = [];
+        while (chunks.length && TYPE_REGEX.test(chunks[0])) {
+          type.push(chunks.shift());
+        }
+        var value = "";
+        if (type.length) {
+          value = type.join(exports.SEPARATOR);
+        }
+        return [key, value];
+      }
+      function parseTransformedExtension(chunks) {
+        var lang;
+        try {
+          lang = parseUnicodeLanguageId2(chunks);
+        } catch (e) {
+        }
+        var fields = [];
+        while (chunks.length && TKEY_REGEX.test(chunks[0])) {
+          var key = chunks.shift();
+          var value = [];
+          while (chunks.length && ALPHANUM_3_82.test(chunks[0])) {
+            value.push(chunks.shift());
+          }
+          if (!value.length) {
+            throw new RangeError('Missing tvalue for tkey "'.concat(key, '"'));
+          }
+          fields.push([key, value.join(exports.SEPARATOR)]);
+        }
+        if (fields.length) {
+          return {
+            type: "t",
+            fields,
+            lang
+          };
+        }
+        throw new RangeError("Malformed transformed_extension");
+      }
+      function parsePuExtension(chunks) {
+        var exts = [];
+        while (chunks.length && ALPHANUM_1_8.test(chunks[0])) {
+          exts.push(chunks.shift());
+        }
+        if (exts.length) {
+          return {
+            type: "x",
+            value: exts.join(exports.SEPARATOR)
+          };
+        }
+        throw new RangeError("Malformed private_use_extension");
+      }
+      function parseOtherExtensionValue(chunks) {
+        var exts = [];
+        while (chunks.length && ALPHANUM_2_8.test(chunks[0])) {
+          exts.push(chunks.shift());
+        }
+        if (exts.length) {
+          return exts.join(exports.SEPARATOR);
+        }
+        return "";
+      }
+      function parseExtensions(chunks) {
+        if (!chunks.length) {
+          return { extensions: [] };
+        }
+        var extensions = [];
+        var unicodeExtension;
+        var transformedExtension;
+        var puExtension;
+        var otherExtensionMap = {};
+        do {
+          var type = chunks.shift();
+          switch (type) {
+            case "u":
+            case "U":
+              if (unicodeExtension) {
+                throw new RangeError("There can only be 1 -u- extension");
+              }
+              unicodeExtension = parseUnicodeExtension(chunks);
+              extensions.push(unicodeExtension);
+              break;
+            case "t":
+            case "T":
+              if (transformedExtension) {
+                throw new RangeError("There can only be 1 -t- extension");
+              }
+              transformedExtension = parseTransformedExtension(chunks);
+              extensions.push(transformedExtension);
+              break;
+            case "x":
+            case "X":
+              if (puExtension) {
+                throw new RangeError("There can only be 1 -x- extension");
+              }
+              puExtension = parsePuExtension(chunks);
+              extensions.push(puExtension);
+              break;
+            default:
+              if (!OTHER_EXTENSION_TYPE.test(type)) {
+                throw new RangeError("Malformed extension type");
+              }
+              if (type in otherExtensionMap) {
+                throw new RangeError("There can only be 1 -".concat(type, "- extension"));
+              }
+              var extension = {
+                type,
+                value: parseOtherExtensionValue(chunks)
+              };
+              otherExtensionMap[extension.type] = extension;
+              extensions.push(extension);
+              break;
+          }
+        } while (chunks.length);
+        return { extensions };
+      }
+      function parseUnicodeLocaleId2(locale) {
+        var chunks = locale.split(exports.SEPARATOR);
+        var lang = parseUnicodeLanguageId2(chunks);
+        return tslib_1.__assign({ lang }, parseExtensions(chunks));
+      }
+    }
+  });
+
   // node_modules/.aspect_rules_js/@formatjs+intl-getcanonicallocales@0.0.0/node_modules/@formatjs/intl-getcanonicallocales/src/canonicalizer.js
   var require_canonicalizer = __commonJS({
     "node_modules/.aspect_rules_js/@formatjs+intl-getcanonicallocales@0.0.0/node_modules/@formatjs/intl-getcanonicallocales/src/canonicalizer.js"(exports) {
       "use strict";
       Object.defineProperty(exports, "__esModule", { value: true });
       exports.canonicalizeUnicodeLanguageId = canonicalizeUnicodeLanguageId;
-      exports.canonicalizeUnicodeLocaleId = canonicalizeUnicodeLocaleId;
+      exports.CanonicalizeUnicodeLocaleId = CanonicalizeUnicodeLocaleId2;
       var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
       var aliases_generated_1 = require_aliases_generated();
-      var parser_1 = require_parser();
-      var likelySubtags_generated_1 = require_likelySubtags_generated();
       var emitter_1 = require_emitter();
+      var likelySubtags_generated_1 = require_likelySubtags_generated();
+      var parser_1 = require_parser();
       function canonicalizeAttrs(strs) {
         return Object.keys(strs.reduce(function(all, str) {
           all[str.toLowerCase()] = 1;
@@ -17734,7 +17834,7 @@
         }
         return finalLangAst;
       }
-      function canonicalizeUnicodeLocaleId(locale) {
+      function CanonicalizeUnicodeLocaleId2(locale) {
         locale.lang = canonicalizeUnicodeLanguageId(locale.lang);
         if (locale.extensions) {
           for (var _i = 0, _a = locale.extensions; _i < _a.length; _i++) {
@@ -17777,12 +17877,12 @@
     "node_modules/.aspect_rules_js/@formatjs+intl-getcanonicallocales@0.0.0/node_modules/@formatjs/intl-getcanonicallocales/index.js"(exports) {
       "use strict";
       Object.defineProperty(exports, "__esModule", { value: true });
-      exports.isUnicodeLanguageSubtag = exports.isUnicodeScriptSubtag = exports.isUnicodeRegionSubtag = exports.isStructurallyValidLanguageTag = exports.parseUnicodeLanguageId = exports.parseUnicodeLocaleId = void 0;
+      exports.parseUnicodeLocaleId = exports.parseUnicodeLanguageId = exports.isUnicodeScriptSubtag = exports.isUnicodeRegionSubtag = exports.isUnicodeLanguageSubtag = exports.isStructurallyValidLanguageTag = void 0;
       exports.getCanonicalLocales = getCanonicalLocales2;
       var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
-      var parser_1 = require_parser();
-      var emitter_1 = require_emitter();
       var canonicalizer_1 = require_canonicalizer();
+      var emitter_1 = require_emitter();
+      var parser_1 = require_parser();
       function CanonicalizeLocaleList3(locales) {
         if (locales === void 0) {
           return [];
@@ -17793,7 +17893,7 @@
         }
         for (var _i = 0, locales_1 = locales; _i < locales_1.length; _i++) {
           var locale = locales_1[_i];
-          var canonicalizedTag = (0, emitter_1.emitUnicodeLocaleId)((0, canonicalizer_1.canonicalizeUnicodeLocaleId)((0, parser_1.parseUnicodeLocaleId)(locale)));
+          var canonicalizedTag = (0, emitter_1.emitUnicodeLocaleId)((0, canonicalizer_1.CanonicalizeUnicodeLocaleId)((0, parser_1.parseUnicodeLocaleId)(locale)));
           if (seen.indexOf(canonicalizedTag) < 0) {
             seen.push(canonicalizedTag);
           }
@@ -17803,27 +17903,27 @@
       function getCanonicalLocales2(locales) {
         return CanonicalizeLocaleList3(locales);
       }
+      tslib_1.__exportStar(require_emitter(), exports);
       var parser_2 = require_parser();
-      Object.defineProperty(exports, "parseUnicodeLocaleId", { enumerable: true, get: function() {
-        return parser_2.parseUnicodeLocaleId;
-      } });
-      Object.defineProperty(exports, "parseUnicodeLanguageId", { enumerable: true, get: function() {
-        return parser_2.parseUnicodeLanguageId;
-      } });
       Object.defineProperty(exports, "isStructurallyValidLanguageTag", { enumerable: true, get: function() {
         return parser_2.isStructurallyValidLanguageTag;
       } });
+      Object.defineProperty(exports, "isUnicodeLanguageSubtag", { enumerable: true, get: function() {
+        return parser_2.isUnicodeLanguageSubtag;
+      } });
       Object.defineProperty(exports, "isUnicodeRegionSubtag", { enumerable: true, get: function() {
         return parser_2.isUnicodeRegionSubtag;
       } });
       Object.defineProperty(exports, "isUnicodeScriptSubtag", { enumerable: true, get: function() {
         return parser_2.isUnicodeScriptSubtag;
       } });
-      Object.defineProperty(exports, "isUnicodeLanguageSubtag", { enumerable: true, get: function() {
-        return parser_2.isUnicodeLanguageSubtag;
+      Object.defineProperty(exports, "parseUnicodeLanguageId", { enumerable: true, get: function() {
+        return parser_2.parseUnicodeLanguageId;
+      } });
+      Object.defineProperty(exports, "parseUnicodeLocaleId", { enumerable: true, get: function() {
+        return parser_2.parseUnicodeLocaleId;
       } });
       tslib_1.__exportStar(require_types(), exports);
-      tslib_1.__exportStar(require_emitter(), exports);
       tslib_1.__exportStar(require_likelySubtags_generated(), exports);
     }
   });
@@ -17995,15 +18095,21 @@
   var serializerDefault = function() {
     return JSON.stringify(arguments);
   };
-  function ObjectWithoutPrototypeCache() {
-    this.cache = /* @__PURE__ */ Object.create(null);
-  }
-  ObjectWithoutPrototypeCache.prototype.get = function(key) {
-    return this.cache[key];
-  };
-  ObjectWithoutPrototypeCache.prototype.set = function(key, value) {
-    this.cache[key] = value;
-  };
+  var ObjectWithoutPrototypeCache = (
+    /** @class */
+    function() {
+      function ObjectWithoutPrototypeCache2() {
+        this.cache = /* @__PURE__ */ Object.create(null);
+      }
+      ObjectWithoutPrototypeCache2.prototype.get = function(key) {
+        return this.cache[key];
+      };
+      ObjectWithoutPrototypeCache2.prototype.set = function(key, value) {
+        this.cache[key] = value;
+      };
+      return ObjectWithoutPrototypeCache2;
+    }()
+  );
   var cacheDefault = {
     create: function create() {
       return new ObjectWithoutPrototypeCache();