@formatjs/intl-locale 5.3.9 → 5.3.11

package/polyfill.iife.js

@@ -4,6 +4,21 @@ import { timezones } from "@formatjs_generated/cldr.locale/timezones.js";
 import { hourCycles } from "@formatjs_generated/cldr.locale/hour-cycles.js";
 import { calendars } from "@formatjs_generated/cldr.locale/calendars.js";
 import { weekData } from "@formatjs_generated/cldr.locale/week-data.js";
+//#region packages/ecma262-abstract/ToString.js
+/**
+* https://tc39.es/ecma262/#sec-tostring
+*/
+function ToString$1(o) {
+	if (typeof o === "symbol") throw TypeError("Cannot convert a Symbol value to a string");
+	return String(o);
+}
+//#endregion
+//#region packages/ecma402-abstract/IsUnicodeLocaleIdentifierType.js
+/** Tests the Unicode locale identifier `type` grammar, not locale support. */
+function IsUnicodeLocaleIdentifierType(value) {
+	return /^[a-z0-9]{3,8}(-[a-z0-9]{3,8})*(?![\s\S])/i.test(value);
+}
+//#endregion
 //#region packages/ecma262-abstract/HasOwnProperty.js
 /**
 * https://www.ecma-international.org/ecma-262/11.0/index.html#sec-hasownproperty
@@ -42,15 +57,6 @@ function CoerceOptionsToObject(options) {
 	return ToObject(options);
 }
 //#endregion
-//#region packages/ecma262-abstract/ToString.js
-/**
-* https://tc39.es/ecma262/#sec-tostring
-*/
-function ToString(o) {
-	if (typeof o === "symbol") throw TypeError("Cannot convert a Symbol value to a string");
-	return String(o);
-}
-//#endregion
 //#region packages/ecma402-abstract/GetOption.js
 /**
 * https://tc39.es/ecma402/#sec-getoption
@@ -61,12 +67,12 @@ function ToString(o) {
 * @param fallback
 */
 function GetOption(opts, prop, type, values, fallback) {
-	if (typeof opts !== "object") throw new TypeError("Options must be an object");
+	if (opts === null || typeof opts !== "object" && typeof opts !== "function") throw new TypeError("Options must be an object");
 	let value = opts[prop];
 	if (value !== void 0) {
 		if (type !== "boolean" && type !== "string") throw new TypeError("invalid type");
 		if (type === "boolean") value = Boolean(value);
-		if (type === "string") value = ToString(value);
+		if (type === "string") value = ToString$1(value);
 		if (values !== void 0 && !values.filter((val) => val == value).length) throw new RangeError(`${value} is not within ${values.join(", ")}`);
 		return value;
 	}
@@ -180,6 +186,13 @@ memoize((...args) => new Intl.ListFormat(...args), { strategy: strategies.variad
 //#endregion
 //#region node_modules/.aspect_rules_js/@formatjs+intl-supportedvaluesof@0.0.0/node_modules/@formatjs/intl-supportedvaluesof/index.js
 /**
+* https://tc39.es/ecma262/#sec-tostring
+*/
+function ToString(o) {
+	if (typeof o === "symbol") throw TypeError("Cannot convert a Symbol value to a string");
+	return String(o);
+}
+/**
 * Implementation: Memoized factory for Intl.DateTimeFormat instances
 *
 * Creates and caches DateTimeFormat instances to avoid repeated instantiation overhead.
@@ -251,24 +264,48 @@ const collations = [
 	"unihan",
 	"zhuyin"
 ];
-/**
-* Implementation: Tests if a collation is supported by attempting to create
-* a Collator with that collation and verifying it was accepted.
-*
-* CLDR Data: Candidate values come from CLDR collation types
-*/
+const collationCandidateLocales = {
+	"compat": ["ar"],
+	"trad": [
+		"bn",
+		"es",
+		"fi",
+		"kn",
+		"sa",
+		"sv",
+		"vi"
+	],
+	"digits-after": ["cs"],
+	"eor": [
+		"de",
+		"de-AT",
+		"en"
+	],
+	"phonebk": ["de", "de-AT"],
+	"private-kana": ["ja"],
+	"unihan": [
+		"ja",
+		"ko",
+		"zh",
+		"zh-Hant"
+	],
+	"searchjl": ["ko"],
+	"phonetic": ["ln"],
+	"emoji": ["en"],
+	"private-unihan": ["en"],
+	"dict": ["si"],
+	"pinyin": ["zh", "zh-Hant"],
+	"private-pinyin": ["zh", "zh-Hant"],
+	"stroke": ["zh", "zh-Hant"],
+	"zhuyin": ["zh", "zh-Hant"]
+};
 function isSupportedCollation(collation) {
-	try {
-		return Intl.Collator(`en-u-co-${collation}`).resolvedOptions().collation === collation;
+	const candidates = collationCandidateLocales[collation] || ["en"];
+	for (const locale of candidates) try {
+		if (new Intl.Collator(`${locale}-u-co-${collation}`).resolvedOptions().collation === collation) return true;
 	} catch {}
 	return false;
 }
-/**
-* ECMA-402 Spec: Returns supported collation identifiers
-* ECMA-402 Spec: Results must be sorted lexicographically
-*
-* Implementation: Filters CLDR list against actual runtime support
-*/
 function getSupportedCollations() {
 	return collations.filter(isSupportedCollation).sort();
 }
@@ -816,8 +853,8 @@ const timezones$1 = [
 	"America/Aruba",
 	"America/Asuncion",
 	"America/Atikokan",
-	"America/Bahia_Banderas",
 	"America/Bahia",
+	"America/Bahia_Banderas",
 	"America/Barbados",
 	"America/Belem",
 	"America/Belize",
@@ -840,8 +877,8 @@ const timezones$1 = [
 	"America/Cuiaba",
 	"America/Curacao",
 	"America/Danmarkshavn",
-	"America/Dawson_Creek",
 	"America/Dawson",
+	"America/Dawson_Creek",
 	"America/Denver",
 	"America/Detroit",
 	"America/Dominica",
@@ -910,8 +947,8 @@ const timezones$1 = [
 	"America/Pangnirtung",
 	"America/Paramaribo",
 	"America/Phoenix",
-	"America/Port_of_Spain",
 	"America/Port-au-Prince",
+	"America/Port_of_Spain",
 	"America/Porto_Velho",
 	"America/Puerto_Rico",
 	"America/Punta_Arenas",
@@ -1062,6 +1099,34 @@ const timezones$1 = [
 	"Australia/Melbourne",
 	"Australia/Perth",
 	"Australia/Sydney",
+	"Etc/GMT",
+	"Etc/GMT+1",
+	"Etc/GMT+10",
+	"Etc/GMT+11",
+	"Etc/GMT+12",
+	"Etc/GMT+2",
+	"Etc/GMT+3",
+	"Etc/GMT+4",
+	"Etc/GMT+5",
+	"Etc/GMT+6",
+	"Etc/GMT+7",
+	"Etc/GMT+8",
+	"Etc/GMT+9",
+	"Etc/GMT-1",
+	"Etc/GMT-10",
+	"Etc/GMT-11",
+	"Etc/GMT-12",
+	"Etc/GMT-13",
+	"Etc/GMT-14",
+	"Etc/GMT-2",
+	"Etc/GMT-3",
+	"Etc/GMT-4",
+	"Etc/GMT-5",
+	"Etc/GMT-6",
+	"Etc/GMT-7",
+	"Etc/GMT-8",
+	"Etc/GMT-9",
+	"Etc/UTC",
 	"Europe/Amsterdam",
 	"Europe/Andorra",
 	"Europe/Astrakhan",
@@ -1083,8 +1148,8 @@ const timezones$1 = [
 	"Europe/Istanbul",
 	"Europe/Jersey",
 	"Europe/Kaliningrad",
-	"Europe/Kyiv",
 	"Europe/Kirov",
+	"Europe/Kyiv",
 	"Europe/Lisbon",
 	"Europe/Ljubljana",
 	"Europe/London",
@@ -1140,7 +1205,6 @@ const timezones$1 = [
 	"Pacific/Chuuk",
 	"Pacific/Easter",
 	"Pacific/Efate",
-	"Pacific/Kanton",
 	"Pacific/Fakaofo",
 	"Pacific/Fiji",
 	"Pacific/Funafuti",
@@ -1149,6 +1213,7 @@ const timezones$1 = [
 	"Pacific/Guadalcanal",
 	"Pacific/Guam",
 	"Pacific/Honolulu",
+	"Pacific/Kanton",
 	"Pacific/Kiritimati",
 	"Pacific/Kosrae",
 	"Pacific/Kwajalein",
@@ -1170,7 +1235,8 @@ const timezones$1 = [
 	"Pacific/Tarawa",
 	"Pacific/Tongatapu",
 	"Pacific/Wake",
-	"Pacific/Wallis"
+	"Pacific/Wallis",
+	"UTC"
 ];
 /**
 * Implementation: Tests if a timezone is supported by attempting to create
@@ -1211,9 +1277,11 @@ const units = [
 	"terabyte",
 	"day",
 	"hour",
+	"microsecond",
 	"millisecond",
 	"minute",
 	"month",
+	"nanosecond",
 	"second",
 	"week",
 	"year",
@@ -1264,7 +1332,9 @@ function getSupportedUnits() {
 }
 /**
 * ECMA-402 Spec: Intl.supportedValuesOf(key)
+* ECMA-402 §8.3.2 Intl.supportedValuesOf, step 1.
 * https://tc39.es/ecma402/#sec-intl.supportedvaluesof
+* https://github.com/tc39/ecma402/blob/b1c961988b9a07894b1dc3dc2b5626ea48387d61/spec/intl.html#L103
 *
 * Returns an array containing the supported calendar, collation, currency,
 * numbering systems, time zone, or unit values supported by the implementation.
@@ -1276,7 +1346,8 @@ function getSupportedUnits() {
 * @param key - The category of values to return
 * @returns A sorted array of unique string values
 */
-function supportedValuesOf(key) {
+const supportedValuesOf = { supportedValuesOf(key) {
+	key = ToString(key);
 	switch (key) {
 		case "calendar": return getSupportedCalendars();
 		case "collation": return getSupportedCollations();
@@ -1286,9 +1357,519 @@ function supportedValuesOf(key) {
 		case "unit": return getSupportedUnits();
 		default: throw RangeError("Invalid key: " + key);
 	}
-}
+} }.supportedValuesOf;
 //#endregion
 //#region node_modules/.aspect_rules_js/@formatjs+intl-getcanonicallocales@0.0.0/node_modules/@formatjs/intl-getcanonicallocales/index.js
+function appendToList(list, ...values) {
+	for (const value of values) Object.defineProperty(list, list.length, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+}
+const languageAlias = {
+	"aa-saaho": "ssy",
+	"aam": "aas",
+	"aar": "aa",
+	"abk": "ab",
+	"adp": "dz",
+	"afr": "af",
+	"agp": "apf",
+	"ais": "ami",
+	"ajp": "apc",
+	"ajt": "aeb",
+	"aju": "jrb",
+	"aka": "ak",
+	"alb": "sq",
+	"als": "sq",
+	"amh": "am",
+	"ara": "ar",
+	"arb": "ar",
+	"arg": "an",
+	"arm": "hy",
+	"art-lojban": "jbo",
+	"asd": "snz",
+	"asm": "as",
+	"aue": "ktz",
+	"ava": "av",
+	"ave": "ae",
+	"aym": "ay",
+	"ayr": "ay",
+	"ayx": "nun",
+	"aze": "az",
+	"azj": "az",
+	"bak": "ba",
+	"bam": "bm",
+	"baq": "eu",
+	"baz": "nvo",
+	"bcc": "bal",
+	"bcl": "bik",
+	"bel": "be",
+	"ben": "bn",
+	"bgm": "bcg",
+	"bh": "bho",
+	"bhk": "fbl",
+	"bic": "bir",
+	"bih": "bho",
+	"bis": "bi",
+	"bjd": "drl",
+	"bjq": "bzc",
+	"bkb": "ebk",
+	"blg": "iba",
+	"bod": "bo",
+	"bos": "bs",
+	"bre": "br",
+	"btb": "beb",
+	"bul": "bg",
+	"bur": "my",
+	"bxk": "luy",
+	"bxr": "bua",
+	"cat": "ca",
+	"ccq": "rki",
+	"cel-gaulish": "xtg",
+	"ces": "cs",
+	"cha": "ch",
+	"che": "ce",
+	"chi": "zh",
+	"chu": "cu",
+	"chv": "cv",
+	"cjr": "mom",
+	"cka": "cmr",
+	"cld": "syr",
+	"cls": "sa",
+	"cmk": "xch",
+	"cmn": "zh",
+	"cnr": "sr-ME",
+	"cor": "kw",
+	"cos": "co",
+	"coy": "pij",
+	"cqu": "quh",
+	"cre": "cr",
+	"cwd": "cr",
+	"cym": "cy",
+	"cze": "cs",
+	"daf": "dnj",
+	"dan": "da",
+	"dap": "njz",
+	"dek": "sqm",
+	"deu": "de",
+	"dgo": "doi",
+	"dhd": "mwr",
+	"dik": "din",
+	"diq": "zza",
+	"dit": "dif",
+	"div": "dv",
+	"djl": "dze",
+	"dkl": "aqd",
+	"drh": "mn",
+	"drr": "kzk",
+	"drw": "fa-AF",
+	"dud": "uth",
+	"duj": "dwu",
+	"dut": "nl",
+	"dwl": "dbt",
+	"dzo": "dz",
+	"ekk": "et",
+	"ell": "el",
+	"elp": "amq",
+	"emk": "man",
+	"en-GB-oed": "en-GB-oxendict",
+	"eng": "en",
+	"epo": "eo",
+	"esk": "ik",
+	"est": "et",
+	"eus": "eu",
+	"ewe": "ee",
+	"fao": "fo",
+	"fas": "fa",
+	"fat": "ak",
+	"fij": "fj",
+	"fin": "fi",
+	"fra": "fr",
+	"fre": "fr",
+	"fry": "fy",
+	"fuc": "ff",
+	"ful": "ff",
+	"gav": "dev",
+	"gaz": "om",
+	"gbc": "wny",
+	"gbo": "grb",
+	"geo": "ka",
+	"ger": "de",
+	"gfx": "vaj",
+	"ggn": "gvr",
+	"ggo": "esg",
+	"ggr": "gtu",
+	"gio": "aou",
+	"gla": "gd",
+	"gle": "ga",
+	"glg": "gl",
+	"gli": "kzk",
+	"glv": "gv",
+	"gno": "gon",
+	"gom": "kok",
+	"gre": "el",
+	"grn": "gn",
+	"gti": "nyc",
+	"gug": "gn",
+	"guj": "gu",
+	"guv": "duz",
+	"gya": "gba",
+	"hat": "ht",
+	"hau": "ha",
+	"hbs": "sr-Latn",
+	"hdn": "hai",
+	"hea": "hmn",
+	"heb": "he",
+	"her": "hz",
+	"him": "srx",
+	"hin": "hi",
+	"hmo": "ho",
+	"hrr": "jal",
+	"hrv": "hr",
+	"hun": "hu",
+	"hy-arevmda": "hyw",
+	"hye": "hy",
+	"i-ami": "ami",
+	"i-bnn": "bnn",
+	"i-default": "en-x-i-default",
+	"i-enochian": "und-x-i-enochian",
+	"i-hak": "hak",
+	"i-klingon": "tlh",
+	"i-lux": "lb",
+	"i-mingo": "see-x-i-mingo",
+	"i-navajo": "nv",
+	"i-pwn": "pwn",
+	"i-tao": "tao",
+	"i-tay": "tay",
+	"i-tsu": "tsu",
+	"ibi": "opa",
+	"ibo": "ig",
+	"ice": "is",
+	"ido": "io",
+	"iii": "ii",
+	"ike": "iu",
+	"iku": "iu",
+	"ile": "ie",
+	"ill": "ilm",
+	"ilw": "gal",
+	"in": "id",
+	"ina": "ia",
+	"ind": "id",
+	"ipk": "ik",
+	"isl": "is",
+	"ita": "it",
+	"iw": "he",
+	"izi": "eza",
+	"jar": "jgk",
+	"jav": "jv",
+	"jeg": "oyb",
+	"ji": "yi",
+	"jpn": "ja",
+	"jw": "jv",
+	"kal": "kl",
+	"kan": "kn",
+	"kas": "ks",
+	"kat": "ka",
+	"kau": "kr",
+	"kaz": "kk",
+	"kdv": "zkd",
+	"kgc": "tdf",
+	"kgd": "ncq",
+	"kgh": "kml",
+	"kgm": "plu",
+	"khk": "mn",
+	"khm": "km",
+	"kik": "ki",
+	"kin": "rw",
+	"kir": "ky",
+	"kmr": "ku",
+	"knc": "kr",
+	"kng": "kg",
+	"koj": "kwv",
+	"kom": "kv",
+	"kon": "kg",
+	"kor": "ko",
+	"kpp": "jkm",
+	"kpv": "kv",
+	"krm": "bmf",
+	"ktr": "dtp",
+	"kua": "kj",
+	"kur": "ku",
+	"kvs": "gdj",
+	"kwq": "yam",
+	"kxe": "tvd",
+	"kxl": "kru",
+	"kzh": "dgl",
+	"kzj": "dtp",
+	"kzt": "dtp",
+	"lak": "ksp",
+	"lao": "lo",
+	"lat": "la",
+	"lav": "lv",
+	"lbk": "bnc",
+	"leg": "enl",
+	"lii": "raq",
+	"lim": "li",
+	"lin": "ln",
+	"lit": "lt",
+	"llo": "ngt",
+	"lmm": "rmx",
+	"ltz": "lb",
+	"lub": "lu",
+	"lug": "lg",
+	"lvs": "lv",
+	"mac": "mk",
+	"mah": "mh",
+	"mal": "ml",
+	"mao": "mi",
+	"mar": "mr",
+	"may": "ms",
+	"meg": "cir",
+	"mgx": "jbk",
+	"mhr": "chm",
+	"mkd": "mk",
+	"mlg": "mg",
+	"mlt": "mt",
+	"mnt": "wnn",
+	"mo": "ro",
+	"mof": "xnt",
+	"mol": "ro",
+	"mon": "mn",
+	"mri": "mi",
+	"msa": "ms",
+	"mst": "mry",
+	"mup": "raj",
+	"mwd": "dmw",
+	"mwj": "vaj",
+	"mya": "my",
+	"myd": "aog",
+	"myt": "mry",
+	"nad": "xny",
+	"nau": "na",
+	"nav": "nv",
+	"nbf": "nru",
+	"nbl": "nr",
+	"nbx": "gll",
+	"ncp": "kdz",
+	"nde": "nd",
+	"ndo": "ng",
+	"nep": "ne",
+	"nld": "nl",
+	"nln": "azd",
+	"nlr": "nrk",
+	"nno": "nn",
+	"nns": "nbr",
+	"nnx": "ngv",
+	"no-bok": "nb",
+	"no-bokmal": "nb",
+	"no-nyn": "nn",
+	"no-nynorsk": "nn",
+	"nob": "nb",
+	"nom": "cbr",
+	"noo": "dtd",
+	"nor": "no",
+	"npi": "ne",
+	"nte": "eko",
+	"nts": "pij",
+	"nxu": "bpp",
+	"nya": "ny",
+	"oci": "oc",
+	"ojg": "oj",
+	"oji": "oj",
+	"ori": "or",
+	"orm": "om",
+	"ory": "or",
+	"oss": "os",
+	"oun": "vaj",
+	"pan": "pa",
+	"pat": "kxr",
+	"pbu": "ps",
+	"pcr": "adx",
+	"per": "fa",
+	"pes": "fa",
+	"pli": "pi",
+	"plt": "mg",
+	"pmc": "huw",
+	"pmk": "crr",
+	"pmu": "phr",
+	"pnb": "lah",
+	"pol": "pl",
+	"por": "pt",
+	"ppa": "bfy",
+	"ppr": "lcq",
+	"prp": "gu",
+	"prs": "fa-AF",
+	"pry": "prt",
+	"pus": "ps",
+	"puz": "pub",
+	"que": "qu",
+	"quz": "qu",
+	"rmr": "emx",
+	"rmy": "rom",
+	"roh": "rm",
+	"ron": "ro",
+	"rum": "ro",
+	"run": "rn",
+	"rus": "ru",
+	"sag": "sg",
+	"san": "sa",
+	"sap": "aqt",
+	"sca": "hle",
+	"scc": "sr",
+	"scr": "hr",
+	"sgl": "isk",
+	"sgn-BE-FR": "sfb",
+	"sgn-BE-NL": "vgt",
+	"sgn-BR": "bzs",
+	"sgn-CH-DE": "sgg",
+	"sgn-CO": "csn",
+	"sgn-DE": "gsg",
+	"sgn-DK": "dsl",
+	"sgn-ES": "ssp",
+	"sgn-FR": "fsl",
+	"sgn-GB": "bfi",
+	"sgn-GR": "gss",
+	"sgn-IE": "isg",
+	"sgn-IT": "ise",
+	"sgn-JP": "jsl",
+	"sgn-MX": "mfs",
+	"sgn-NI": "ncs",
+	"sgn-NL": "dse",
+	"sgn-NO": "nsi",
+	"sgn-PT": "psr",
+	"sgn-SE": "swl",
+	"sgn-US": "ase",
+	"sgn-ZA": "sfs",
+	"sh": "sr-Latn",
+	"sin": "si",
+	"skk": "oyb",
+	"slk": "sk",
+	"slo": "sk",
+	"slv": "sl",
+	"smd": "kmb",
+	"sme": "se",
+	"smo": "sm",
+	"sna": "sn",
+	"snb": "iba",
+	"snd": "sd",
+	"som": "so",
+	"sot": "st",
+	"spa": "es",
+	"spy": "kln",
+	"sqi": "sq",
+	"src": "sc",
+	"srd": "sc",
+	"srp": "sr",
+	"ssw": "ss",
+	"sul": "sgd",
+	"sum": "ulw",
+	"sun": "su",
+	"swa": "sw",
+	"swc": "sw-CD",
+	"swe": "sv",
+	"swh": "sw",
+	"szd": "umi",
+	"tah": "ty",
+	"tam": "ta",
+	"tat": "tt",
+	"tdu": "dtp",
+	"tel": "te",
+	"tgg": "bjp",
+	"tgk": "tg",
+	"tgl": "fil",
+	"tha": "th",
+	"thc": "tpo",
+	"thw": "ola",
+	"thx": "oyb",
+	"tib": "bo",
+	"tid": "itd",
+	"tie": "ras",
+	"tir": "ti",
+	"tkk": "twm",
+	"tl": "fil",
+	"tlw": "weo",
+	"tmk": "tdg",
+	"tmp": "tyj",
+	"tne": "kak",
+	"tnf": "fa-AF",
+	"ton": "to",
+	"tpw": "tpn",
+	"tsf": "taj",
+	"tsn": "tn",
+	"tso": "ts",
+	"ttq": "tmh",
+	"tuk": "tk",
+	"tur": "tr",
+	"tw": "ak",
+	"twi": "ak",
+	"uig": "ug",
+	"ukr": "uk",
+	"umu": "del",
+	"und-aaland": "und-AX",
+	"und-arevela": "und",
+	"und-arevmda": "und",
+	"und-bokmal": "und",
+	"und-hakka": "und",
+	"und-hepburn-heploc": "und-alalc97",
+	"und-lojban": "und",
+	"und-nynorsk": "und",
+	"und-saaho": "und",
+	"und-xiang": "und",
+	"unp": "wro",
+	"uok": "ema",
+	"urd": "ur",
+	"uzb": "uz",
+	"uzn": "uz",
+	"ven": "ve",
+	"vie": "vi",
+	"vol": "vo",
+	"wel": "cy",
+	"wgw": "wgb",
+	"wit": "nol",
+	"wiw": "nwo",
+	"wln": "wa",
+	"wol": "wo",
+	"xba": "cax",
+	"xho": "xh",
+	"xia": "acn",
+	"xkh": "waw",
+	"xpe": "kpe",
+	"xrq": "dmw",
+	"xsj": "suj",
+	"xsl": "den",
+	"xss": "zko",
+	"ybd": "rki",
+	"ydd": "yi",
+	"yen": "ynq",
+	"yid": "yi",
+	"yiy": "yrm",
+	"yma": "lrr",
+	"ymt": "mtm",
+	"yor": "yo",
+	"yos": "zom",
+	"yuu": "yug",
+	"zai": "zap",
+	"zh-cmn": "zh",
+	"zh-cmn-Hans": "zh-Hans",
+	"zh-cmn-Hant": "zh-Hant",
+	"zh-gan": "gan",
+	"zh-guoyu": "zh",
+	"zh-hakka": "hak",
+	"zh-min": "nan-x-zh-min",
+	"zh-min-nan": "nan",
+	"zh-wuu": "wuu",
+	"zh-xiang": "hsn",
+	"zh-yue": "yue",
+	"zha": "za",
+	"zho": "zh",
+	"zir": "scv",
+	"zkb": "kjh",
+	"zsm": "ms",
+	"zul": "zu",
+	"zyb": "za"
+};
 function emitUnicodeLanguageId(lang) {
 	if (!lang) return "";
 	return [
@@ -1301,17 +1882,15 @@ function emitUnicodeLanguageId(lang) {
 function emitUnicodeLocaleId({ lang, extensions }) {
 	const chunks = [emitUnicodeLanguageId(lang)];
 	for (const ext of extensions) {
-		chunks.push(ext.type);
+		appendToList(chunks, ext.type);
 		switch (ext.type) {
 			case "u":
-				chunks.push(...ext.attributes, ...ext.keywords.reduce((all, kv) => all.concat(kv), []));
+				appendToList(chunks, ...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);
+				appendToList(chunks, emitUnicodeLanguageId(ext.lang).toLowerCase(), ...ext.fields.reduce((all, kv) => all.concat(kv), []));
 				break;
+			default: appendToList(chunks, ext.value);
 		}
 	}
 	return chunks.filter(Boolean).join("-");
@@ -9106,19 +9685,32 @@ const likelySubtags = {
 	"zza": "zza-Latn-TR",
 	"zzj": "zzj-Hani-CN"
 };
-const ALPHANUM_1_8 = /^[a-z0-9]{1,8}$/i;
-const ALPHANUM_2_8 = /^[a-z0-9]{2,8}$/i;
-const ALPHANUM_3_8$1 = /^[a-z0-9]{3,8}$/i;
-const KEY_REGEX = /^[a-z0-9][a-z]$/i;
-const TYPE_REGEX = /^[a-z0-9]{3,8}$/i;
-const ALPHA_4 = /^[a-z]{4}$/i;
-const OTHER_EXTENSION_TYPE = /^[0-9a-svwyz]$/i;
-const UNICODE_REGION_SUBTAG_REGEX = /^([a-z]{2}|[0-9]{3})$/i;
-const UNICODE_VARIANT_SUBTAG_REGEX = /^([a-z0-9]{5,8}|[0-9][a-z0-9]{3})$/i;
-const UNICODE_LANGUAGE_SUBTAG_REGEX = /^([a-z]{2,3}|[a-z]{5,8})$/i;
-const TKEY_REGEX = /^[a-z][0-9]$/i;
+function isLetter(code) {
+	return code >= 65 && code <= 90 || code >= 97 && code <= 122;
+}
+function isDigit(code) {
+	return code >= 48 && code <= 57;
+}
+function isSubtag(value, min, max, digits = false) {
+	if (value.length < min || value.length > max) return false;
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+		if (!isLetter(code) && !(digits && isDigit(code))) return false;
+	}
+	return true;
+}
+function isUnicodeKey(value) {
+	return value.length === 2 && isSubtag(value, 2, 2, true) && isLetter(value.charCodeAt(1));
+}
+function isTransformedKey(value) {
+	return value.length === 2 && isLetter(value.charCodeAt(0)) && isDigit(value.charCodeAt(1));
+}
+function isOtherExtensionType(value) {
+	const type = value.toLowerCase();
+	return isSubtag(type, 1, 1, true) && type !== "t" && type !== "u" && type !== "x";
+}
 function isUnicodeLanguageSubtag(lang) {
-	return UNICODE_LANGUAGE_SUBTAG_REGEX.test(lang);
+	return lang.length !== 4 && isSubtag(lang, 2, 8);
 }
 function isStructurallyValidLanguageTag(tag) {
 	try {
@@ -9129,13 +9721,13 @@ function isStructurallyValidLanguageTag(tag) {
 	return true;
 }
 function isUnicodeRegionSubtag(region) {
-	return UNICODE_REGION_SUBTAG_REGEX.test(region);
+	return isSubtag(region, 2, 2) || region.length === 3 && isDigit(region.charCodeAt(0)) && isDigit(region.charCodeAt(1)) && isDigit(region.charCodeAt(2));
 }
 function isUnicodeScriptSubtag(script) {
-	return ALPHA_4.test(script);
+	return isSubtag(script, 4, 4);
 }
 function isUnicodeVariantSubtag(variant) {
-	return UNICODE_VARIANT_SUBTAG_REGEX.test(variant);
+	return isSubtag(variant, 5, 8, true) || isSubtag(variant, 4, 4, true) && isDigit(variant.charCodeAt(0));
 }
 function parseUnicodeLanguageId(chunks) {
 	if (typeof chunks === "string") chunks = chunks.split("-");
@@ -9166,15 +9758,15 @@ function parseUnicodeLanguageId(chunks) {
 function parseUnicodeExtension(chunks) {
 	const keywords = [];
 	let keyword;
-	while (chunks.length && (keyword = parseKeyword(chunks))) keywords.push(keyword);
+	while (chunks.length && (keyword = parseKeyword(chunks))) appendToList(keywords, keyword);
 	if (keywords.length) return {
 		type: "u",
 		keywords,
 		attributes: []
 	};
 	const attributes = [];
-	while (chunks.length && ALPHANUM_3_8$1.test(chunks[0])) attributes.push(chunks.shift());
-	while (chunks.length && (keyword = parseKeyword(chunks))) keywords.push(keyword);
+	while (chunks.length && isSubtag(chunks[0], 3, 8, true)) appendToList(attributes, chunks.shift());
+	while (chunks.length && (keyword = parseKeyword(chunks))) appendToList(keywords, keyword);
 	if (keywords.length || attributes.length) return {
 		type: "u",
 		attributes,
@@ -9184,28 +9776,26 @@ function parseUnicodeExtension(chunks) {
 }
 function parseKeyword(chunks) {
 	let key;
-	if (!KEY_REGEX.test(chunks[0])) return;
+	if (!isUnicodeKey(chunks[0])) return;
 	key = chunks.shift();
 	const type = [];
-	while (chunks.length && TYPE_REGEX.test(chunks[0])) type.push(chunks.shift());
+	while (chunks.length && isSubtag(chunks[0], 3, 8, true)) appendToList(type, chunks.shift());
 	let value = "";
 	if (type.length) value = type.join("-");
 	return [key, value];
 }
 function parseTransformedExtension(chunks) {
 	let lang;
-	try {
-		lang = parseUnicodeLanguageId(chunks);
-	} catch {}
+	if (chunks.length && isUnicodeLanguageSubtag(chunks[0])) lang = parseUnicodeLanguageId(chunks);
 	const fields = [];
-	while (chunks.length && TKEY_REGEX.test(chunks[0])) {
+	while (chunks.length && isTransformedKey(chunks[0])) {
 		const key = chunks.shift();
 		const value = [];
-		while (chunks.length && ALPHANUM_3_8$1.test(chunks[0])) value.push(chunks.shift());
+		while (chunks.length && isSubtag(chunks[0], 3, 8, true)) appendToList(value, chunks.shift());
 		if (!value.length) throw new RangeError(`Missing tvalue for tkey "${key}"`);
-		fields.push([key, value.join("-")]);
+		appendToList(fields, [key, value.join("-")]);
 	}
-	if (fields.length) return {
+	if (lang || fields.length) return {
 		type: "t",
 		fields,
 		lang
@@ -9214,7 +9804,7 @@ function parseTransformedExtension(chunks) {
 }
 function parsePuExtension(chunks) {
 	const exts = [];
-	while (chunks.length && ALPHANUM_1_8.test(chunks[0])) exts.push(chunks.shift());
+	while (chunks.length && isSubtag(chunks[0], 1, 8, true)) appendToList(exts, chunks.shift());
 	if (exts.length) return {
 		type: "x",
 		value: exts.join("-")
@@ -9223,9 +9813,9 @@ function parsePuExtension(chunks) {
 }
 function parseOtherExtensionValue(chunks) {
 	const exts = [];
-	while (chunks.length && ALPHANUM_2_8.test(chunks[0])) exts.push(chunks.shift());
+	while (chunks.length && isSubtag(chunks[0], 2, 8, true)) appendToList(exts, chunks.shift());
 	if (exts.length) return exts.join("-");
-	return "";
+	throw new RangeError("Missing extension value");
 }
 function parseExtensions(chunks) {
 	if (!chunks.length) return { extensions: [] };
@@ -9235,36 +9825,35 @@ function parseExtensions(chunks) {
 	let puExtension;
 	const otherExtensionMap = {};
 	do {
-		const type = chunks.shift();
+		const type = chunks.shift().toLowerCase();
 		switch (type) {
 			case "u":
 			case "U":
 				if (unicodeExtension) throw new RangeError("There can only be 1 -u- extension");
 				unicodeExtension = parseUnicodeExtension(chunks);
-				extensions.push(unicodeExtension);
+				appendToList(extensions, unicodeExtension);
 				break;
 			case "t":
 			case "T":
 				if (transformedExtension) throw new RangeError("There can only be 1 -t- extension");
 				transformedExtension = parseTransformedExtension(chunks);
-				extensions.push(transformedExtension);
+				appendToList(extensions, transformedExtension);
 				break;
 			case "x":
 			case "X":
 				if (puExtension) throw new RangeError("There can only be 1 -x- extension");
 				puExtension = parsePuExtension(chunks);
-				extensions.push(puExtension);
+				appendToList(extensions, puExtension);
 				break;
 			default:
-				if (!OTHER_EXTENSION_TYPE.test(type)) throw new RangeError("Malformed extension type");
+				if (!isOtherExtensionType(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;
+				appendToList(extensions, extension);
 		}
 	} while (chunks.length);
 	return { extensions };
@@ -9276,12 +9865,53 @@ function parseUnicodeLocaleId(locale) {
 		...parseExtensions(chunks)
 	};
 }
+function compareLanguageAliasRules(a, b) {
+	const fields = (id) => [
+		Number(id.lang !== "und"),
+		Number(!!id.script),
+		Number(!!id.region),
+		id.variants.length
+	];
+	const left = fields(a.type), right = fields(b.type);
+	const difference = right.reduce((a, b) => a + b, 0) - left.reduce((a, b) => a + b, 0);
+	if (difference) return difference;
+	for (let i = 0; i < left.length; i++) if (!!left[i] !== !!right[i]) return right[i] ? 1 : -1;
+	const leftTag = emitUnicodeLanguageId(a.type), rightTag = emitUnicodeLanguageId(b.type);
+	return leftTag < rightTag ? -1 : leftTag > rightTag ? 1 : 0;
+}
+Object.keys(languageAlias).reduce((rules, from) => {
+	const to = languageAlias[from];
+	let type;
+	const source = from.split("-");
+	try {
+		type = parseUnicodeLanguageId(source);
+	} catch {
+		return rules;
+	}
+	if (source.length) return rules;
+	const target = to.split("-");
+	const replacement = parseUnicodeLanguageId(target);
+	if (target.length) throw new Error(`Invalid language alias replacement: ${to}`);
+	appendToList(rules, {
+		type,
+		replacement
+	});
+	return rules;
+}, []).sort(compareLanguageAliasRules).reduce((groups, rule) => {
+	appendToList(groups[rule.type.lang] ||= [], rule);
+	return groups;
+}, Object.create(null));
+typeof Intl !== "undefined" && Intl.Locale?.prototype.toString;
 //#endregion
 //#region packages/intl-locale/get_internal_slots.ts
 const internalSlotMap = /* @__PURE__ */ new WeakMap();
-function getInternalSlots(x, internalSlotsList = []) {
+function getInternalSlotsIfPresent(x) {
+	return internalSlotMap.get(x);
+}
+function getInternalSlots(x, internalSlotsList) {
 	let internalSlots = internalSlotMap.get(x);
 	if (!internalSlots) {
+		if (internalSlotsList === void 0) throw new TypeError("Intl.Locale method called on incompatible receiver");
 		internalSlots = Object.create(null, internalSlotsList.reduce((all, prop) => {
 			all[prop] = {
 				enumerable: false,
@@ -9296,29 +9926,36 @@ function getInternalSlots(x, internalSlotsList = []) {
 }
 //#endregion
 //#region packages/intl-locale/preference-data.ts
-function getCalendarPreferenceDataForRegion(region) {
-	return (calendars[(region ? region.toUpperCase() : null) || ""] || calendars["001"]).map((c) => {
-		if (c === "gregorian") return "gregory";
-		if (c === "islamic-civil") return "islamicc";
-		return c;
-	});
+function getCalendarPreferenceDataForRegion(region, regionOverride, language) {
+	for (const candidate of [regionOverride, region]) {
+		if (!candidate) continue;
+		const territory = candidate.toUpperCase();
+		const values = calendars[`${language}-${territory}`] || calendars[territory];
+		if (values) return values.map((c) => c === "gregorian" ? "gregory" : c);
+	}
+	return ["gregory"];
 }
-function getHourCyclesPreferenceDataForLocaleOrRegion(locale, region) {
-	const _locale = locale.toLowerCase();
-	const _region = region ? region.toUpperCase() : "";
-	return [...hourCycles[_locale] || hourCycles[_region] || hourCycles[`${_locale}-001`] || hourCycles["001"]];
+function getHourCyclesPreferenceDataForLocaleOrRegion(language, region, regionOverride) {
+	for (const candidate of [regionOverride, region]) {
+		if (!candidate) continue;
+		const territory = candidate.toUpperCase();
+		const values = hourCycles[`${language}-${territory}`] || hourCycles[territory];
+		if (values) return [...values];
+	}
+	return ["h23"];
 }
 function getTimeZonePreferenceForRegion(region) {
 	const territory = region.toLowerCase();
 	if (timezones[territory]) return [...timezones[territory]];
 	return [];
 }
-function getWeekDataForRegion(region) {
-	return weekData[(region ? region.toUpperCase() : "") || "001"] || weekData["001"];
+function getWeekDataForRegion(region, regionOverride) {
+	const _region = region ? region.toUpperCase() : "";
+	const override = (regionOverride || "").toUpperCase();
+	return weekData[override] || weekData[_region] || weekData["001"];
 }
 //#endregion
 //#region packages/intl-locale/index.ts
-const ALPHANUM_3_8 = /^[a-z0-9]{3,8}$/i;
 const RELEVANT_EXTENSION_KEYS = [
 	"ca",
 	"co",
@@ -9328,17 +9965,23 @@ const RELEVANT_EXTENSION_KEYS = [
 	"nu",
 	"fw"
 ];
-const UNICODE_TYPE_REGEX = /^[a-z0-9]{3,8}(-[a-z0-9]{3,8})*$/i;
 function applyOptionsToTag(tag, options) {
 	invariant(typeof tag === "string", "language tag must be a string");
 	invariant(isStructurallyValidLanguageTag(tag), "malformed language tag", RangeError);
+	tag = Intl.getCanonicalLocales(tag)[0];
 	const language = GetOption(options, "language", "string", void 0, void 0);
 	if (language !== void 0) invariant(isUnicodeLanguageSubtag(language), "Malformed unicode_language_subtag", RangeError);
 	const script = GetOption(options, "script", "string", void 0, void 0);
 	if (script !== void 0) invariant(isUnicodeScriptSubtag(script), "Malformed unicode_script_subtag", RangeError);
 	const region = GetOption(options, "region", "string", void 0, void 0);
 	if (region !== void 0) invariant(isUnicodeRegionSubtag(region), "Malformed unicode_region_subtag", RangeError);
+	const variants = GetOption(options, "variants", "string", void 0, void 0);
 	const languageId = parseUnicodeLanguageId(tag);
+	if (variants !== void 0) {
+		const subtags = variants.replace(/[A-Z]/g, (character) => character.toLowerCase()).split("-");
+		if (subtags.some((variant) => !isUnicodeVariantSubtag(variant)) || new Set(subtags).size !== subtags.length) throw new RangeError("Malformed unicode_variant_subtag");
+		languageId.variants = subtags;
+	}
 	if (language !== void 0) languageId.lang = language;
 	if (script !== void 0) languageId.script = script;
 	if (region !== void 0) languageId.region = region;
@@ -9380,6 +10023,8 @@ function applyUnicodeExtensionToTag(tag, options, relevantExtensionKeys) {
 		});
 	} else unicodeExtension.keywords = keywords;
 	result.locale = Intl.getCanonicalLocales(emitUnicodeLocaleId(ast))[0];
+	const canonicalExtension = parseUnicodeLocaleId(result.locale).extensions.find((extension) => extension.type === "u");
+	for (const key of relevantExtensionKeys) result[key] = canonicalExtension?.keywords.find((keyword) => keyword[0] === key)?.[1];
 	return result;
 }
 function mergeUnicodeLanguageId(lang, script, region, variants = [], replacement) {
@@ -9398,49 +10043,38 @@ function mergeUnicodeLanguageId(lang, script, region, variants = [], replacement
 }
 function addLikelySubtags(tag) {
 	const ast = parseUnicodeLocaleId(tag);
-	const { lang, script, region, variants } = ast.lang;
-	if (script && region) {
-		const match = likelySubtags[emitUnicodeLanguageId({
+	const { lang, variants } = ast.lang;
+	const script = ast.lang.script === "Zzzz" ? void 0 : ast.lang.script;
+	const region = ast.lang.region === "ZZ" ? void 0 : ast.lang.region;
+	if (lang !== "und" && script && region) return tag;
+	for (const candidate of [
+		{
 			lang,
 			script,
 			region,
 			variants: []
-		})];
-		if (match) {
-			ast.lang = mergeUnicodeLanguageId(void 0, void 0, void 0, variants, parseUnicodeLanguageId(match));
-			return emitUnicodeLocaleId(ast);
-		}
-	}
-	if (script) {
-		const match = likelySubtags[emitUnicodeLanguageId({
+		},
+		{
 			lang,
 			script,
 			variants: []
-		})];
-		if (match) {
-			ast.lang = mergeUnicodeLanguageId(void 0, void 0, region, variants, parseUnicodeLanguageId(match));
-			return emitUnicodeLocaleId(ast);
-		}
-	}
-	if (region) {
-		const match = likelySubtags[emitUnicodeLanguageId({
+		},
+		{
 			lang,
 			region,
 			variants: []
-		})];
-		if (match) {
-			ast.lang = mergeUnicodeLanguageId(void 0, script, void 0, variants, parseUnicodeLanguageId(match));
-			return emitUnicodeLocaleId(ast);
+		},
+		{
+			lang,
+			variants: []
 		}
+	]) {
+		const match = likelySubtags[emitUnicodeLanguageId(candidate)];
+		if (!match) continue;
+		ast.lang = mergeUnicodeLanguageId(lang, script, region, variants, parseUnicodeLanguageId(match));
+		return emitUnicodeLocaleId(ast);
 	}
-	const match = likelySubtags[lang] || likelySubtags[emitUnicodeLanguageId({
-		lang: "und",
-		script,
-		variants: []
-	})];
-	if (!match) throw new Error(`No match for addLikelySubtags`);
-	ast.lang = mergeUnicodeLanguageId(void 0, script, region, variants, parseUnicodeLanguageId(match));
-	return emitUnicodeLocaleId(ast);
+	return tag;
 }
 /**
 * From: https://github.com/unicode-org/icu/blob/4231ca5be053a22a1be24eb891817458c97db709/icu4j/main/classes/core/src/com/ibm/icu/util/ULocale.java#L2395
@@ -9449,11 +10083,11 @@ function addLikelySubtags(tag) {
 function removeLikelySubtags(tag) {
 	let maxLocale = addLikelySubtags(tag);
 	if (!maxLocale) return tag;
+	const ast = parseUnicodeLocaleId(maxLocale);
 	maxLocale = emitUnicodeLanguageId({
 		...parseUnicodeLanguageId(maxLocale),
 		variants: []
 	});
-	const ast = parseUnicodeLocaleId(tag);
 	const { lang: { lang, script, region, variants } } = ast;
 	if (addLikelySubtags(emitUnicodeLanguageId({
 		lang,
@@ -9482,7 +10116,7 @@ function removeLikelySubtags(tag) {
 			lang: mergeUnicodeLanguageId(lang, script, void 0, variants)
 		});
 	}
-	return tag;
+	return emitUnicodeLocaleId(ast);
 }
 function createArrayFromListOrRestricted(list, restricted) {
 	let result = list;
@@ -9493,13 +10127,19 @@ function calendarsOfLocale(loc) {
 	const locInternalSlots = getInternalSlots(loc);
 	const restricted = locInternalSlots.calendar;
 	const locale = locInternalSlots.locale;
-	let region;
-	if (locale !== "root") region = loc.maximize().region;
-	return createArrayFromListOrRestricted(getCalendarPreferenceDataForRegion(region), restricted);
+	const { region, regionOverride } = regionPreference(loc);
+	return createArrayFromListOrRestricted(getCalendarPreferenceDataForRegion(region, regionOverride, parseUnicodeLanguageId(locale).lang), restricted);
 }
 function collationsOfLocale(loc) {
-	const restricted = getInternalSlots(loc).collation;
-	const supportedCollations = supportedValuesOf("collation").filter((co) => co !== "standard" && co !== "search");
+	const locInternalSlots = getInternalSlots(loc);
+	const restricted = locInternalSlots.collation;
+	if (restricted !== void 0) return [restricted];
+	const locale = locInternalSlots.locale;
+	if (!Intl.Collator.supportedLocalesOf([locale], { localeMatcher: "lookup" }).length) return ["emoji", "eor"];
+	const supportedCollations = supportedValuesOf("collation").filter((co) => co !== "standard" && co !== "search" && new Intl.Collator(locale, {
+		collation: co,
+		localeMatcher: "lookup"
+	}).resolvedOptions().collation === co);
 	supportedCollations.sort();
 	return createArrayFromListOrRestricted(supportedCollations, restricted);
 }
@@ -9507,9 +10147,8 @@ function hourCyclesOfLocale(loc) {
 	const locInternalSlots = getInternalSlots(loc);
 	const restricted = locInternalSlots.hourCycle;
 	const locale = locInternalSlots.locale;
-	let region;
-	if (locale !== "root") region = loc.maximize().region;
-	return createArrayFromListOrRestricted(getHourCyclesPreferenceDataForLocaleOrRegion(locale, region), restricted);
+	const { region, regionOverride } = regionPreference(loc);
+	return createArrayFromListOrRestricted(getHourCyclesPreferenceDataForLocaleOrRegion(parseUnicodeLanguageId(locale).lang, region, regionOverride), restricted);
 }
 function numberingSystemsOfLocale(loc) {
 	const locInternalSlots = getInternalSlots(loc);
@@ -9533,13 +10172,25 @@ function translateCharacterOrder(order) {
 	return "ltr";
 }
 function characterDirectionOfLocale(loc) {
-	return translateCharacterOrder(characterOrders[loc.minimize().toString()]);
+	const locale = loc.minimize().toString();
+	return translateCharacterOrder(characterOrders[locale]);
 }
-function weekInfoOfLocale(loc) {
+function regionPreference(loc) {
 	const locale = getInternalSlots(loc).locale;
-	let region;
-	if (locale !== "root") region = loc.maximize().region;
-	return getWeekDataForRegion(region);
+	const ast = parseUnicodeLocaleId(locale);
+	const extension = ast.extensions.find((ext) => ext.type === "u");
+	const subdivisionRegion = (key) => {
+		const match = (extension?.keywords.find((entry) => entry[0] === key)?.[1])?.match(/^([a-z]{2}|[0-9]{3})[a-z0-9]{1,4}$/i);
+		return match ? new Locale(`und-${match[1]}`).region : void 0;
+	};
+	return {
+		region: ast.lang.region || subdivisionRegion("sd") || parseUnicodeLanguageId(addLikelySubtags(locale)).region || "001",
+		regionOverride: subdivisionRegion("rg")
+	};
+}
+function weekInfoOfLocale(loc) {
+	const { region, regionOverride } = regionPreference(loc);
+	return getWeekDataForRegion(region, regionOverride);
 }
 const TABLE_1 = [
 	"sun",
@@ -9551,7 +10202,7 @@ const TABLE_1 = [
 	"sat"
 ];
 function weekdayToString(fw) {
-	return TABLE_1[+fw];
+	return /^[0-7]$/.test(fw) ? TABLE_1[Number(fw) % 7] : fw;
 }
 var Locale = class Locale {
 	constructor(tag, opts) {
@@ -9568,30 +10219,30 @@ var Locale = class Locale {
 		if (relevantExtensionKeys.indexOf("kf") > -1) internalSlotsList.push("caseFirst");
 		if (relevantExtensionKeys.indexOf("kn") > -1) internalSlotsList.push("numeric");
 		if (tag === void 0) throw new TypeError("First argument to Intl.Locale constructor can't be empty or missing");
-		if (typeof tag !== "string" && typeof tag !== "object") throw new TypeError("tag must be a string or object");
+		if (tag === null || typeof tag !== "string" && typeof tag !== "object" && typeof tag !== "function") throw new TypeError("tag must be a string or object");
 		let tagInternalSlots;
-		if (typeof tag === "object" && (tagInternalSlots = getInternalSlots(tag)) && HasOwnProperty(tagInternalSlots, "initializedLocale")) tag = tagInternalSlots.locale;
-		else tag = tag.toString();
+		if (typeof tag === "object" && (tagInternalSlots = getInternalSlotsIfPresent(tag)) && HasOwnProperty(tagInternalSlots, "initializedLocale")) tag = tagInternalSlots.locale;
+		else tag = ToString$1(tag);
 		let internalSlots = getInternalSlots(this, internalSlotsList);
 		let options = CoerceOptionsToObject(opts);
 		tag = applyOptionsToTag(tag, options);
 		const opt = Object.create(null);
 		const calendar = GetOption(options, "calendar", "string", void 0, void 0);
 		if (calendar !== void 0) {
-			if (!UNICODE_TYPE_REGEX.test(calendar)) throw new RangeError("invalid calendar");
+			if (!IsUnicodeLocaleIdentifierType(calendar)) throw new RangeError("invalid calendar");
 		}
 		opt.ca = calendar;
 		const collation = GetOption(options, "collation", "string", void 0, void 0);
 		if (collation !== void 0) {
-			if (!UNICODE_TYPE_REGEX.test(collation)) throw new RangeError("invalid collation");
+			if (!IsUnicodeLocaleIdentifierType(collation)) throw new RangeError("invalid collation");
 		}
 		opt.co = collation;
 		let fw = GetOption(options, "firstDayOfWeek", "string", void 0, void 0);
 		if (fw !== void 0) {
 			fw = weekdayToString(fw);
-			if (!ALPHANUM_3_8.test(fw)) throw new RangeError("Invalid firstDayOfWeek");
+			if (!IsUnicodeLocaleIdentifierType(fw)) throw new RangeError("Invalid firstDayOfWeek");
 		}
-		opt.fw = fw;
+		opt.fw = fw?.toLowerCase();
 		opt.hc = GetOption(options, "hourCycle", "string", [
 			"h11",
 			"h12",
@@ -9609,7 +10260,7 @@ var Locale = class Locale {
 		opt.kn = kn;
 		const numberingSystem = GetOption(options, "numberingSystem", "string", void 0, void 0);
 		if (numberingSystem !== void 0) {
-			if (!UNICODE_TYPE_REGEX.test(numberingSystem)) throw new RangeError("Invalid numberingSystem");
+			if (!IsUnicodeLocaleIdentifierType(numberingSystem)) throw new RangeError("Invalid numberingSystem");
 		}
 		opt.nu = numberingSystem;
 		const r = applyUnicodeExtensionToTag(tag, opt, relevantExtensionKeys);
@@ -9619,7 +10270,7 @@ var Locale = class Locale {
 		internalSlots.firstDayOfWeek = r.fw;
 		internalSlots.hourCycle = r.hc;
 		if (relevantExtensionKeys.indexOf("kf") > -1) internalSlots.caseFirst = r.kf;
-		if (relevantExtensionKeys.indexOf("kn") > -1) internalSlots.numeric = SameValue(r.kn, "true");
+		if (relevantExtensionKeys.indexOf("kn") > -1) internalSlots.numeric = r.kn === "" || SameValue(r.kn, "true");
 		internalSlots.numberingSystem = r.nu;
 	}
 	/**
@@ -9628,7 +10279,8 @@ var Locale = class Locale {
 	maximize() {
 		const locale = getInternalSlots(this).locale;
 		try {
-			return new Locale(addLikelySubtags(locale));
+			const maximizedLocale = addLikelySubtags(locale);
+			return new Locale(maximizedLocale);
 		} catch {
 			return new Locale(locale);
 		}
@@ -9639,13 +10291,16 @@ var Locale = class Locale {
 	minimize() {
 		const locale = getInternalSlots(this).locale;
 		try {
-			return new Locale(removeLikelySubtags(locale));
+			const minimizedLocale = removeLikelySubtags(locale);
+			return new Locale(minimizedLocale);
 		} catch {
 			return new Locale(locale);
 		}
 	}
 	toString() {
-		return getInternalSlots(this).locale;
+		const slots = getInternalSlots(this);
+		if (!HasOwnProperty(slots, "initializedLocale")) throw new TypeError("Error uninitialized locale");
+		return slots.locale;
 	}
 	get baseName() {
 		const locale = getInternalSlots(this).locale;
@@ -9759,7 +10414,9 @@ var Locale = class Locale {
 	}
 	/**
 	* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/getWeekInfo
-	* https://tc39.es/proposal-intl-locale-info/#sec-Intl.Locale.prototype.getWeekInfo
+	* ECMA-402 §15.3.22 Intl.Locale.prototype.getWeekInfo, steps 3–7.
+	* https://tc39.es/ecma402/#sec-Intl.Locale.prototype.getWeekInfo
+	* https://github.com/tc39/ecma402/blob/b1c961988b9a07894b1dc3dc2b5626ea48387d61/spec/locale.html#L420-L424
 	*/
 	getWeekInfo() {
 		const info = Object.create(Object.prototype);
@@ -9768,10 +10425,10 @@ var Locale = class Locale {
 		const wi = weekInfoOfLocale(this);
 		const we = wi.weekend;
 		createDataProperty(info, "firstDay", wi.firstDay);
-		createDataProperty(info, "weekend", we);
-		createDataProperty(info, "minimalDays", wi.minimalDays);
+		createDataProperty(info, "weekend", [...we]);
 		const fw = internalSlots.firstDayOfWeek;
-		if (fw !== void 0) info.firstDay = fw;
+		const day = TABLE_1.indexOf(fw);
+		if (day !== -1) info.firstDay = day || 7;
 		return info;
 	}
 	static {