@formatjs/intl-getcanonicallocales 2.5.2 → 2.5.3

package/index.d.ts

@@ -1,5 +1,5 @@
 export declare function getCanonicalLocales(locales?: string[] | string): string[];
-export { parseUnicodeLocaleId, parseUnicodeLanguageId, isStructurallyValidLanguageTag, isUnicodeRegionSubtag, isUnicodeScriptSubtag, isUnicodeLanguageSubtag, } from './src/parser';
-export * from './src/types';
 export * from './src/emitter';
+export { isStructurallyValidLanguageTag, isUnicodeLanguageSubtag, isUnicodeRegionSubtag, isUnicodeScriptSubtag, parseUnicodeLanguageId, parseUnicodeLocaleId, } from './src/parser';
+export * from './src/types';
 export * from './src/likelySubtags.generated';

package/index.js

@@ -1,11 +1,11 @@
 "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 = getCanonicalLocales;
 var tslib_1 = require("tslib");
-var parser_1 = require("./src/parser");
-var emitter_1 = require("./src/emitter");
 var canonicalizer_1 = require("./src/canonicalizer");
+var emitter_1 = require("./src/emitter");
+var parser_1 = require("./src/parser");
 /**
  * https://tc39.es/ecma402/#sec-canonicalizelocalelist
  * @param locales
@@ -20,7 +20,7 @@ function CanonicalizeLocaleList(locales) {
     }
     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);
         }
@@ -30,14 +30,13 @@ function CanonicalizeLocaleList(locales) {
 function getCanonicalLocales(locales) {
     return CanonicalizeLocaleList(locales);
 }
+tslib_1.__exportStar(require("./src/emitter"), exports);
 var parser_2 = require("./src/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("./src/types"), exports);
-tslib_1.__exportStar(require("./src/emitter"), exports);
 tslib_1.__exportStar(require("./src/likelySubtags.generated"), exports);
-//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@formatjs/intl-getcanonicallocales",
-  "version": "2.5.2",
+  "version": "2.5.3",
   "description": "Intl.getCanonicalLocales polyfill",
   "keywords": [
     "intl",

package/polyfill-force.js

@@ -21,4 +21,3 @@ Object.defineProperty(Intl, 'getCanonicalLocales', {
     enumerable: false,
     configurable: true,
 });
-//# sourceMappingURL=polyfill-force.js.map

package/polyfill.iife.js

@@ -16,260 +16,6 @@
     return a;
   };
 
-  // packages/intl-getcanonicallocales/src/parser.ts
-  var ALPHANUM_1_8 = /^[a-z0-9]{1,8}$/i;
-  var ALPHANUM_2_8 = /^[a-z0-9]{2,8}$/i;
-  var ALPHANUM_3_8 = /^[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;
-  var SEPARATOR = "-";
-  function isUnicodeLanguageSubtag(lang) {
-    return UNICODE_LANGUAGE_SUBTAG_REGEX.test(lang);
-  }
-  function isUnicodeRegionSubtag(region) {
-    return UNICODE_REGION_SUBTAG_REGEX.test(region);
-  }
-  function isUnicodeScriptSubtag(script) {
-    return ALPHA_4.test(script);
-  }
-  function isUnicodeVariantSubtag(variant) {
-    return UNICODE_VARIANT_SUBTAG_REGEX.test(variant);
-  }
-  function parseUnicodeLanguageId(chunks) {
-    if (typeof chunks === "string") {
-      chunks = chunks.split(SEPARATOR);
-    }
-    const lang = chunks.shift();
-    if (!lang) {
-      throw new RangeError("Missing unicode_language_subtag");
-    }
-    if (lang === "root") {
-      return { lang: "root", variants: [] };
-    }
-    if (!isUnicodeLanguageSubtag(lang)) {
-      throw new RangeError("Malformed unicode_language_subtag");
-    }
-    let script;
-    if (chunks.length && isUnicodeScriptSubtag(chunks[0])) {
-      script = chunks.shift();
-    }
-    let region;
-    if (chunks.length && isUnicodeRegionSubtag(chunks[0])) {
-      region = chunks.shift();
-    }
-    const variants = {};
-    while (chunks.length && isUnicodeVariantSubtag(chunks[0])) {
-      const variant = chunks.shift();
-      if (variant in variants) {
-        throw new RangeError(`Duplicate variant "${variant}"`);
-      }
-      variants[variant] = 1;
-    }
-    return {
-      lang,
-      script,
-      region,
-      variants: Object.keys(variants)
-    };
-  }
-  function parseUnicodeExtension(chunks) {
-    const keywords = [];
-    let keyword;
-    while (chunks.length && (keyword = parseKeyword(chunks))) {
-      keywords.push(keyword);
-    }
-    if (keywords.length) {
-      return {
-        type: "u",
-        keywords,
-        attributes: []
-      };
-    }
-    const attributes = [];
-    while (chunks.length && ALPHANUM_3_8.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) {
-    let key;
-    if (!KEY_REGEX.test(chunks[0])) {
-      return;
-    }
-    key = chunks.shift();
-    const type = [];
-    while (chunks.length && TYPE_REGEX.test(chunks[0])) {
-      type.push(chunks.shift());
-    }
-    let value = "";
-    if (type.length) {
-      value = type.join(SEPARATOR);
-    }
-    return [key, value];
-  }
-  function parseTransformedExtension(chunks) {
-    let lang;
-    try {
-      lang = parseUnicodeLanguageId(chunks);
-    } catch (e) {
-    }
-    const fields = [];
-    while (chunks.length && TKEY_REGEX.test(chunks[0])) {
-      const key = chunks.shift();
-      const value = [];
-      while (chunks.length && ALPHANUM_3_8.test(chunks[0])) {
-        value.push(chunks.shift());
-      }
-      if (!value.length) {
-        throw new RangeError(`Missing tvalue for tkey "${key}"`);
-      }
-      fields.push([key, value.join(SEPARATOR)]);
-    }
-    if (fields.length) {
-      return {
-        type: "t",
-        fields,
-        lang
-      };
-    }
-    throw new RangeError("Malformed transformed_extension");
-  }
-  function parsePuExtension(chunks) {
-    const exts = [];
-    while (chunks.length && ALPHANUM_1_8.test(chunks[0])) {
-      exts.push(chunks.shift());
-    }
-    if (exts.length) {
-      return {
-        type: "x",
-        value: exts.join(SEPARATOR)
-      };
-    }
-    throw new RangeError("Malformed private_use_extension");
-  }
-  function parseOtherExtensionValue(chunks) {
-    const exts = [];
-    while (chunks.length && ALPHANUM_2_8.test(chunks[0])) {
-      exts.push(chunks.shift());
-    }
-    if (exts.length) {
-      return exts.join(SEPARATOR);
-    }
-    return "";
-  }
-  function parseExtensions(chunks) {
-    if (!chunks.length) {
-      return { extensions: [] };
-    }
-    const extensions = [];
-    let unicodeExtension;
-    let transformedExtension;
-    let puExtension;
-    const otherExtensionMap = {};
-    do {
-      const 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 -${type}- extension`);
-          }
-          const extension = {
-            type,
-            value: parseOtherExtensionValue(chunks)
-          };
-          otherExtensionMap[extension.type] = extension;
-          extensions.push(extension);
-          break;
-      }
-    } while (chunks.length);
-    return { extensions };
-  }
-  function parseUnicodeLocaleId(locale) {
-    const chunks = locale.split(SEPARATOR);
-    const lang = parseUnicodeLanguageId(chunks);
-    return __spreadValues({
-      lang
-    }, parseExtensions(chunks));
-  }
-
-  // packages/intl-getcanonicallocales/src/emitter.ts
-  function emitUnicodeLanguageId(lang) {
-    if (!lang) {
-      return "";
-    }
-    return [lang.lang, lang.script, lang.region, ...lang.variants || []].filter(Boolean).join("-");
-  }
-  function emitUnicodeLocaleId({
-    lang,
-    extensions
-  }) {
-    const chunks = [emitUnicodeLanguageId(lang)];
-    for (const ext of extensions) {
-      chunks.push(ext.type);
-      switch (ext.type) {
-        case "u":
-          chunks.push(
-            ...ext.attributes,
-            ...ext.keywords.reduce((all, kv) => all.concat(kv), [])
-          );
-          break;
-        case "t":
-          chunks.push(
-            emitUnicodeLanguageId(ext.lang),
-            ...ext.fields.reduce((all, kv) => all.concat(kv), [])
-          );
-          break;
-        default:
-          chunks.push(ext.value);
-          break;
-      }
-    }
-    return chunks.filter(Boolean).join("-");
-  }
-
   // packages/intl-getcanonicallocales/src/aliases.generated.ts
   var languageAlias = {
     "aa-saaho": "ssy",
@@ -1421,6 +1167,41 @@
     "polytoni": "polyton"
   };
 
+  // packages/intl-getcanonicallocales/src/emitter.ts
+  function emitUnicodeLanguageId(lang) {
+    if (!lang) {
+      return "";
+    }
+    return [lang.lang, lang.script, lang.region, ...lang.variants || []].filter(Boolean).join("-");
+  }
+  function emitUnicodeLocaleId({
+    lang,
+    extensions
+  }) {
+    const chunks = [emitUnicodeLanguageId(lang)];
+    for (const ext of extensions) {
+      chunks.push(ext.type);
+      switch (ext.type) {
+        case "u":
+          chunks.push(
+            ...ext.attributes,
+            ...ext.keywords.reduce((all, kv) => all.concat(kv), [])
+          );
+          break;
+        case "t":
+          chunks.push(
+            emitUnicodeLanguageId(ext.lang),
+            ...ext.fields.reduce((all, kv) => all.concat(kv), [])
+          );
+          break;
+        default:
+          chunks.push(ext.value);
+          break;
+      }
+    }
+    return chunks.filter(Boolean).join("-");
+  }
+
   // packages/intl-getcanonicallocales/src/likelySubtags.generated.ts
   var likelySubtags = {
     "aa": "aa-Latn-ET",
@@ -9163,6 +8944,225 @@
     "zzj": "zzj-Hani-CN"
   };
 
+  // packages/intl-getcanonicallocales/src/parser.ts
+  var ALPHANUM_1_8 = /^[a-z0-9]{1,8}$/i;
+  var ALPHANUM_2_8 = /^[a-z0-9]{2,8}$/i;
+  var ALPHANUM_3_8 = /^[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;
+  var SEPARATOR = "-";
+  function isUnicodeLanguageSubtag(lang) {
+    return UNICODE_LANGUAGE_SUBTAG_REGEX.test(lang);
+  }
+  function isUnicodeRegionSubtag(region) {
+    return UNICODE_REGION_SUBTAG_REGEX.test(region);
+  }
+  function isUnicodeScriptSubtag(script) {
+    return ALPHA_4.test(script);
+  }
+  function isUnicodeVariantSubtag(variant) {
+    return UNICODE_VARIANT_SUBTAG_REGEX.test(variant);
+  }
+  function parseUnicodeLanguageId(chunks) {
+    if (typeof chunks === "string") {
+      chunks = chunks.split(SEPARATOR);
+    }
+    const lang = chunks.shift();
+    if (!lang) {
+      throw new RangeError("Missing unicode_language_subtag");
+    }
+    if (lang === "root") {
+      return { lang: "root", variants: [] };
+    }
+    if (!isUnicodeLanguageSubtag(lang)) {
+      throw new RangeError("Malformed unicode_language_subtag");
+    }
+    let script;
+    if (chunks.length && isUnicodeScriptSubtag(chunks[0])) {
+      script = chunks.shift();
+    }
+    let region;
+    if (chunks.length && isUnicodeRegionSubtag(chunks[0])) {
+      region = chunks.shift();
+    }
+    const variants = {};
+    while (chunks.length && isUnicodeVariantSubtag(chunks[0])) {
+      const variant = chunks.shift();
+      if (variant in variants) {
+        throw new RangeError(`Duplicate variant "${variant}"`);
+      }
+      variants[variant] = 1;
+    }
+    return {
+      lang,
+      script,
+      region,
+      variants: Object.keys(variants)
+    };
+  }
+  function parseUnicodeExtension(chunks) {
+    const keywords = [];
+    let keyword;
+    while (chunks.length && (keyword = parseKeyword(chunks))) {
+      keywords.push(keyword);
+    }
+    if (keywords.length) {
+      return {
+        type: "u",
+        keywords,
+        attributes: []
+      };
+    }
+    const attributes = [];
+    while (chunks.length && ALPHANUM_3_8.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) {
+    let key;
+    if (!KEY_REGEX.test(chunks[0])) {
+      return;
+    }
+    key = chunks.shift();
+    const type = [];
+    while (chunks.length && TYPE_REGEX.test(chunks[0])) {
+      type.push(chunks.shift());
+    }
+    let value = "";
+    if (type.length) {
+      value = type.join(SEPARATOR);
+    }
+    return [key, value];
+  }
+  function parseTransformedExtension(chunks) {
+    let lang;
+    try {
+      lang = parseUnicodeLanguageId(chunks);
+    } catch (e) {
+    }
+    const fields = [];
+    while (chunks.length && TKEY_REGEX.test(chunks[0])) {
+      const key = chunks.shift();
+      const value = [];
+      while (chunks.length && ALPHANUM_3_8.test(chunks[0])) {
+        value.push(chunks.shift());
+      }
+      if (!value.length) {
+        throw new RangeError(`Missing tvalue for tkey "${key}"`);
+      }
+      fields.push([key, value.join(SEPARATOR)]);
+    }
+    if (fields.length) {
+      return {
+        type: "t",
+        fields,
+        lang
+      };
+    }
+    throw new RangeError("Malformed transformed_extension");
+  }
+  function parsePuExtension(chunks) {
+    const exts = [];
+    while (chunks.length && ALPHANUM_1_8.test(chunks[0])) {
+      exts.push(chunks.shift());
+    }
+    if (exts.length) {
+      return {
+        type: "x",
+        value: exts.join(SEPARATOR)
+      };
+    }
+    throw new RangeError("Malformed private_use_extension");
+  }
+  function parseOtherExtensionValue(chunks) {
+    const exts = [];
+    while (chunks.length && ALPHANUM_2_8.test(chunks[0])) {
+      exts.push(chunks.shift());
+    }
+    if (exts.length) {
+      return exts.join(SEPARATOR);
+    }
+    return "";
+  }
+  function parseExtensions(chunks) {
+    if (!chunks.length) {
+      return { extensions: [] };
+    }
+    const extensions = [];
+    let unicodeExtension;
+    let transformedExtension;
+    let puExtension;
+    const otherExtensionMap = {};
+    do {
+      const 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 -${type}- extension`);
+          }
+          const extension = {
+            type,
+            value: parseOtherExtensionValue(chunks)
+          };
+          otherExtensionMap[extension.type] = extension;
+          extensions.push(extension);
+          break;
+      }
+    } while (chunks.length);
+    return { extensions };
+  }
+  function parseUnicodeLocaleId(locale) {
+    const chunks = locale.split(SEPARATOR);
+    const lang = parseUnicodeLanguageId(chunks);
+    return __spreadValues({
+      lang
+    }, parseExtensions(chunks));
+  }
+
   // packages/intl-getcanonicallocales/src/canonicalizer.ts
   function canonicalizeAttrs(strs) {
     return Object.keys(
@@ -9328,7 +9328,7 @@
     }
     return finalLangAst;
   }
-  function canonicalizeUnicodeLocaleId(locale) {
+  function CanonicalizeUnicodeLocaleId(locale) {
     locale.lang = canonicalizeUnicodeLanguageId(locale.lang);
     if (locale.extensions) {
       for (const extension of locale.extensions) {
@@ -9366,7 +9366,7 @@
     }
     for (const locale of locales) {
       const canonicalizedTag = emitUnicodeLocaleId(
-        canonicalizeUnicodeLocaleId(parseUnicodeLocaleId(locale))
+        CanonicalizeUnicodeLocaleId(parseUnicodeLocaleId(locale))
       );
       if (seen.indexOf(canonicalizedTag) < 0) {
         seen.push(canonicalizedTag);

package/polyfill.js

@@ -24,4 +24,3 @@ if ((0, should_polyfill_1.shouldPolyfill)()) {
         configurable: true,
     });
 }
-//# sourceMappingURL=polyfill.js.map

package/should-polyfill.js

@@ -9,4 +9,3 @@ function shouldPolyfill() {
         Intl.getCanonicalLocales('und-x-private')[0] ===
             'x-private');
 }
-//# sourceMappingURL=should-polyfill.js.map

package/src/aliases.generated.js

@@ -1152,4 +1152,3 @@ exports.variantAlias = {
     "heploc": "alalc97",
     "polytoni": "polyton"
 };
-//# sourceMappingURL=aliases.generated.js.map

package/src/canonicalizer.d.ts

@@ -1,4 +1,4 @@
-import { UnicodeLocaleId, UnicodeLanguageId } from './types';
+import { UnicodeLanguageId, UnicodeLocaleId } from './types';
 /**
  * CAVEAT: We don't do this section in the spec bc they have no JSON data
  * Use the bcp47 data to replace keys, types, tfields, and tvalues by their canonical forms. See Section 3.6.4 U Extension Data Files) and Section 3.7.1 T Extension Data Files. The aliases are in the alias attribute value, while the canonical is in the name attribute value. For example,
@@ -16,4 +16,4 @@ export declare function canonicalizeUnicodeLanguageId(unicodeLanguageId: Unicode
  * IMPORTANT: This modifies the object inline
  * @param locale
  */
-export declare function canonicalizeUnicodeLocaleId(locale: UnicodeLocaleId): UnicodeLocaleId;
+export declare function CanonicalizeUnicodeLocaleId(locale: UnicodeLocaleId): UnicodeLocaleId;

package/src/canonicalizer.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.canonicalizeUnicodeLanguageId = canonicalizeUnicodeLanguageId;
-exports.canonicalizeUnicodeLocaleId = canonicalizeUnicodeLocaleId;
+exports.CanonicalizeUnicodeLocaleId = CanonicalizeUnicodeLocaleId;
 var tslib_1 = require("tslib");
 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;
@@ -194,7 +194,7 @@ function canonicalizeUnicodeLanguageId(unicodeLanguageId) {
  * IMPORTANT: This modifies the object inline
  * @param locale
  */
-function canonicalizeUnicodeLocaleId(locale) {
+function CanonicalizeUnicodeLocaleId(locale) {
     locale.lang = canonicalizeUnicodeLanguageId(locale.lang);
     if (locale.extensions) {
         for (var _i = 0, _a = locale.extensions; _i < _a.length; _i++) {
@@ -221,4 +221,3 @@ function canonicalizeUnicodeLocaleId(locale) {
     }
     return locale;
 }
-//# sourceMappingURL=canonicalizer.js.map

package/src/emitter.js

@@ -30,4 +30,3 @@ function emitUnicodeLocaleId(_a) {
     }
     return chunks.filter(Boolean).join('-');
 }
-//# sourceMappingURL=emitter.js.map

package/src/likelySubtags.generated.js

@@ -7743,4 +7743,3 @@ exports.likelySubtags = {
     "zza": "zza-Latn-TR",
     "zzj": "zzj-Hani-CN"
 };
-//# sourceMappingURL=likelySubtags.generated.js.map

package/src/parser.js

@@ -241,4 +241,3 @@ function parseUnicodeLocaleId(locale) {
     var lang = parseUnicodeLanguageId(chunks);
     return tslib_1.__assign({ lang: lang }, parseExtensions(chunks));
 }
-//# sourceMappingURL=parser.js.map

package/src/types.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map