@formatjs/intl-getcanonicallocales 3.2.11 → 3.2.12

package/polyfill.js

@@ -1,4 +1,251 @@
+//#region packages/intl-getcanonicallocales/appendToList.ts
+function appendToList(list, ...values) {
+	for (const value of values) Object.defineProperty(list, list.length, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+}
+//#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 node_modules/.aspect_rules_js/@formatjs_generated+cldr.core@0.0.0/node_modules/@formatjs_generated/cldr.core/aliases.js
+const subdivisionAlias = {
+	"cn11": "cnbj",
+	"cn12": "cntj",
+	"cn13": "cnhe",
+	"cn14": "cnsx",
+	"cn15": "cnmn",
+	"cn21": "cnln",
+	"cn22": "cnjl",
+	"cn23": "cnhl",
+	"cn31": "cnsh",
+	"cn32": "cnjs",
+	"cn33": "cnzj",
+	"cn34": "cnah",
+	"cn35": "cnfj",
+	"cn36": "cnjx",
+	"cn37": "cnsd",
+	"cn41": "cnha",
+	"cn42": "cnhb",
+	"cn43": "cnhn",
+	"cn44": "cngd",
+	"cn45": "cngx",
+	"cn46": "cnhi",
+	"cn50": "cncq",
+	"cn51": "cnsc",
+	"cn52": "cngz",
+	"cn53": "cnyn",
+	"cn54": "cnxz",
+	"cn61": "cnsn",
+	"cn62": "cngs",
+	"cn63": "cnqh",
+	"cn64": "cnnx",
+	"cn65": "cnxj",
+	"cn71": "twzzzz",
+	"cn91": "hkzzzz",
+	"cn92": "mozzzz",
+	"cz10a": "cz110",
+	"cz10b": "cz111",
+	"cz10c": "cz112",
+	"cz10d": "cz113",
+	"cz10e": "cz114",
+	"cz10f": "cz115",
+	"cz611": "cz663",
+	"cz612": "cz632",
+	"cz613": "cz633",
+	"cz614": "cz634",
+	"cz615": "cz635",
+	"cz621": "cz641",
+	"cz622": "cz642",
+	"cz623": "cz643",
+	"cz624": "cz644",
+	"cz626": "cz646",
+	"cz627": "cz647",
+	"czjc": "cz31",
+	"czjm": "cz64",
+	"czka": "cz41",
+	"czkr": "cz52",
+	"czli": "cz51",
+	"czmo": "cz80",
+	"czol": "cz71",
+	"czpa": "cz53",
+	"czpl": "cz32",
+	"czpr": "cz10",
+	"czst": "cz20",
+	"czus": "cz42",
+	"czvy": "cz63",
+	"czzl": "cz72",
+	"fi01": "axzzzz",
+	"fra": "frges",
+	"frb": "frnaq",
+	"frbl": "blzzzz",
+	"frc": "frara",
+	"frcp": "cpzzzz",
+	"frd": "frbfc",
+	"fre": "frbre",
+	"frf": "frcvl",
+	"frg": "frges",
+	"frgf": "gfzzzz",
+	"frgp": "gpzzzz",
+	"frgua": "gpzzzz",
+	"frh": "frcor",
+	"fri": "frbfc",
+	"frj": "fridf",
+	"frk": "frocc",
+	"frl": "frnaq",
+	"frlre": "rezzzz",
+	"frm": "frges",
+	"frmay": "ytzzzz",
+	"frmf": "mfzzzz",
+	"frmq": "mqzzzz",
+	"frn": "frocc",
+	"frnc": "nczzzz",
+	"fro": "frhdf",
+	"frp": "frnor",
+	"frpf": "pfzzzz",
+	"frpm": "pmzzzz",
+	"frq": "frnor",
+	"frr": "frpdl",
+	"frre": "rezzzz",
+	"frs": "frhdf",
+	"frt": "frnaq",
+	"frtf": "tfzzzz",
+	"fru": "frpac",
+	"frv": "frara",
+	"frwf": "wfzzzz",
+	"fryt": "ytzzzz",
+	"laxn": "laxs",
+	"lud": "lucl",
+	"lug": "luec",
+	"lul": "luca",
+	"mrnkc": "mr13",
+	"nlaw": "awzzzz",
+	"nlcw": "cwzzzz",
+	"nlsx": "sxzzzz",
+	"no23": "no50",
+	"nzn": "nzauk",
+	"nzs": "nzcan",
+	"omba": "ombj",
+	"omsh": "omsj",
+	"plds": "pl02",
+	"plkp": "pl04",
+	"pllb": "pl08",
+	"plld": "pl10",
+	"pllu": "pl06",
+	"plma": "pl12",
+	"plmz": "pl14",
+	"plop": "pl16",
+	"plpd": "pl20",
+	"plpk": "pl18",
+	"plpm": "pl22",
+	"plsk": "pl26",
+	"plsl": "pl24",
+	"plwn": "pl28",
+	"plwp": "pl30",
+	"plzp": "pl32",
+	"shta": "tazzzz",
+	"tteto": "tttob",
+	"ttrcm": "ttmrc",
+	"ttwto": "tttob",
+	"twkhq": "twkhh",
+	"twtnq": "twtnn",
+	"twtpq": "twnwt",
+	"twtxq": "twtxg",
+	"usas": "aszzzz",
+	"usgu": "guzzzz",
+	"usmp": "mpzzzz",
+	"uspr": "przzzz",
+	"usum": "umzzzz",
+	"usvi": "vizzzz"
+};
+const extensionAlias = {
+	"t": {
+		"d0": { "name": "charname" },
+		"m0": {
+			"beta-metsehaf": "betamets",
+			"ies-jes": "iesjes",
+			"names": "prprname",
+			"tekie-alibekit": "tekieali"
+		}
+	},
+	"u": {
+		"ca": {
+			"ethiopic-amete-alem": "ethioaa",
+			"islamicc": "islamic-civil"
+		},
+		"kb": { "yes": "true" },
+		"kc": { "yes": "true" },
+		"kh": { "yes": "true" },
+		"kk": { "yes": "true" },
+		"kn": { "yes": "true" },
+		"ks": {
+			"primary": "level1",
+			"tertiary": "level3"
+		},
+		"ms": { "imperial": "uksystem" },
+		"tz": {
+			"aqams": "aqmcm",
+			"aukns": "auhba",
+			"caffs": "cawnp",
+			"camtr": "cator",
+			"canpg": "cator",
+			"capnt": "caiql",
+			"cathu": "cator",
+			"cayzf": "caedm",
+			"cet": "bebru",
+			"cnckg": "cnsha",
+			"cnhrb": "cnsha",
+			"cnkhg": "cnurc",
+			"cst6cdt": "uschi",
+			"cuba": "cuhav",
+			"eet": "grath",
+			"egypt": "egcai",
+			"eire": "iedub",
+			"est": "papty",
+			"est5edt": "usnyc",
+			"factory": "unk",
+			"gaza": "gazastrp",
+			"gmt0": "gmt",
+			"hongkong": "hkhkg",
+			"hst": "ushnl",
+			"iceland": "isrey",
+			"iran": "irthr",
+			"israel": "jeruslm",
+			"jamaica": "jmkin",
+			"japan": "jptyo",
+			"libya": "lytip",
+			"met": "bebru",
+			"mncoq": "mnuln",
+			"mst": "usphx",
+			"mst7mdt": "usden",
+			"mxstis": "mxtij",
+			"navajo": "usden",
+			"poland": "plwaw",
+			"portugal": "ptlis",
+			"prc": "cnsha",
+			"pst8pdt": "uslax",
+			"roc": "twtpe",
+			"rok": "krsel",
+			"turkey": "trist",
+			"uaozh": "uaiev",
+			"uauzh": "uaiev",
+			"uct": "utc",
+			"umjon": "ushnl",
+			"usnavajo": "usden",
+			"wet": "ptlis",
+			"zulu": "utc"
+		}
+	}
+};
 const languageAlias = {
 	"aa-saaho": "ssy",
 	"aam": "aas",
@@ -1162,17 +1409,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("-");
@@ -8971,28 +9216,41 @@ const likelySubtags = {
 };
 //#endregion
 //#region packages/intl-getcanonicallocales/parser.ts
-const ALPHANUM_1_8 = /^[a-z0-9]{1,8}$/i;
-const ALPHANUM_2_8 = /^[a-z0-9]{2,8}$/i;
-const ALPHANUM_3_8 = /^[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 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("-");
@@ -9023,15 +9281,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.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,
@@ -9041,28 +9299,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.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
@@ -9071,7 +9327,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("-")
@@ -9080,9 +9336,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: [] };
@@ -9092,36 +9348,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 };
@@ -9141,14 +9396,17 @@ function canonicalizeAttrs(strs) {
 		return all;
 	}, {})).sort();
 }
-function canonicalizeKVs(arr) {
-	const all = {};
+function canonicalizeKVs(arr, extension) {
+	const seen = /* @__PURE__ */ new Set();
 	const result = [];
-	for (const kv of arr) {
-		if (kv[0] in all) continue;
-		all[kv[0]] = 1;
-		if (!kv[1] || kv[1] === "true") result.push([kv[0].toLowerCase()]);
-		else result.push([kv[0].toLowerCase(), kv[1].toLowerCase()]);
+	for (const [rawKey, rawValue] of arr) {
+		const key = rawKey.toLowerCase();
+		if (seen.has(key)) continue;
+		seen.add(key);
+		const value = rawValue?.toLowerCase() || "";
+		let canonical = extensionAlias[extension]?.[key]?.[value] || value;
+		if (extension === "u" && (key === "rg" || key === "sd")) canonical = subdivisionAlias[canonical] || canonical;
+		appendToList(result, !canonical || extension === "u" && canonical === "true" ? [key] : [key, canonical]);
 	}
 	return result.sort(compareKV);
 }
@@ -9160,89 +9418,69 @@ function compareExtension(e1, e2) {
 }
 function mergeVariants(v1, v2) {
 	const result = [...v1];
-	for (const v of v2) if (v1.indexOf(v) < 0) result.push(v);
+	for (const v of v2) if (v1.indexOf(v) < 0) appendToList(result, v);
 	return result;
 }
-/**
-* 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,
-Because of the following bcp47 data:
-<key name="ms"…>…<type name="uksystem" … alias="imperial" … />…</key>
-We get the following transformation:
-en-u-ms-imperial ⇒ en-u-ms-uksystem
-* @param lang 
-*/
+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;
+}
+const languageAliasRules = 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));
 function canonicalizeUnicodeLanguageId(unicodeLanguageId) {
-	/**
-	* If the language subtag matches the type attribute of a languageAlias element in Supplemental Data, replace the language subtag with the replacement value.
-	*  1. If there are additional subtags in the replacement value, add them to the result, but only if there is no corresponding subtag already in the tag.
-	*  2. Five special deprecated grandfathered codes (such as i-default) are in type attributes, and are also replaced.
-	*/
+	unicodeLanguageId.lang = unicodeLanguageId.lang.toLowerCase();
+	if (unicodeLanguageId.script) unicodeLanguageId.script = unicodeLanguageId.script[0].toUpperCase() + unicodeLanguageId.script.slice(1).toLowerCase();
+	if (unicodeLanguageId.region) unicodeLanguageId.region = unicodeLanguageId.region.toUpperCase();
+	unicodeLanguageId.variants = unicodeLanguageId.variants.map((v) => v.toLowerCase());
+	const original = emitUnicodeLanguageId(unicodeLanguageId);
 	let finalLangAst = unicodeLanguageId;
-	if (unicodeLanguageId.variants.length) {
-		let replacedLang = "";
-		for (const variant of unicodeLanguageId.variants) if (replacedLang = languageAlias[emitUnicodeLanguageId({
-			lang: unicodeLanguageId.lang,
-			variants: [variant]
-		})]) {
-			const replacedLangAst = parseUnicodeLanguageId(replacedLang.split("-"));
-			finalLangAst = {
-				lang: replacedLangAst.lang,
-				script: finalLangAst.script || replacedLangAst.script,
-				region: finalLangAst.region || replacedLangAst.region,
-				variants: mergeVariants(finalLangAst.variants, replacedLangAst.variants)
-			};
-			break;
-		}
-	}
-	if (finalLangAst.script && finalLangAst.region) {
-		const replacedLang = languageAlias[emitUnicodeLanguageId({
-			lang: finalLangAst.lang,
-			script: finalLangAst.script,
-			region: finalLangAst.region,
-			variants: []
-		})];
-		if (replacedLang) {
-			const replacedLangAst = parseUnicodeLanguageId(replacedLang.split("-"));
-			finalLangAst = {
-				lang: replacedLangAst.lang,
-				script: replacedLangAst.script,
-				region: replacedLangAst.region,
-				variants: finalLangAst.variants
-			};
-		}
-	}
-	if (finalLangAst.region) {
-		const replacedLang = languageAlias[emitUnicodeLanguageId({
-			lang: finalLangAst.lang,
-			region: finalLangAst.region,
-			variants: []
-		})];
-		if (replacedLang) {
-			const replacedLangAst = parseUnicodeLanguageId(replacedLang.split("-"));
-			finalLangAst = {
-				lang: replacedLangAst.lang,
-				script: finalLangAst.script || replacedLangAst.script,
-				region: replacedLangAst.region,
-				variants: finalLangAst.variants
-			};
-		}
-	}
-	const replacedLang = languageAlias[emitUnicodeLanguageId({
-		lang: finalLangAst.lang,
-		variants: []
-	})];
-	if (replacedLang) {
-		const replacedLangAst = parseUnicodeLanguageId(replacedLang.split("-"));
+	const matches = ({ type }) => (!type.script || type.script === finalLangAst.script) && (!type.region || type.region === finalLangAst.region) && type.variants.every((variant) => finalLangAst.variants.includes(variant));
+	const languageRule = languageAliasRules[finalLangAst.lang]?.find(matches);
+	const undRule = finalLangAst.lang === "und" ? void 0 : languageAliasRules.und?.find(matches);
+	const matched = !languageRule ? undRule : !undRule ? languageRule : compareLanguageAliasRules(languageRule, undRule) <= 0 ? languageRule : undRule;
+	if (matched) {
+		const { type, replacement } = matched;
 		finalLangAst = {
-			lang: replacedLangAst.lang,
-			script: finalLangAst.script || replacedLangAst.script,
-			region: finalLangAst.region || replacedLangAst.region,
-			variants: finalLangAst.variants
+			lang: type.lang !== "und" || finalLangAst.lang === "und" ? replacement.lang : finalLangAst.lang,
+			script: type.script ? replacement.script : finalLangAst.script || replacement.script,
+			region: type.region ? replacement.region : finalLangAst.region || replacement.region,
+			variants: mergeVariants(finalLangAst.variants.filter((v) => !type.variants.includes(v)), replacement.variants)
 		};
+		return canonicalizeUnicodeLanguageId(finalLangAst);
 	}
 	if (finalLangAst.region) {
-		const regionAlias = territoryAlias[finalLangAst.region.toUpperCase()];
+		const region = finalLangAst.region.toUpperCase();
+		const regionAlias = territoryAlias[region];
 		let replacedRegion;
 		if (regionAlias) {
 			const regions = regionAlias.split(" ");
@@ -9275,7 +9513,7 @@ function canonicalizeUnicodeLanguageId(unicodeLanguageId) {
 		}
 		finalLangAst.variants.sort();
 	}
-	return finalLangAst;
+	return emitUnicodeLanguageId(finalLangAst) === original ? finalLangAst : canonicalizeUnicodeLanguageId(finalLangAst);
 }
 /**
 * Canonicalize based on
@@ -9289,16 +9527,14 @@ function CanonicalizeUnicodeLocaleId(locale) {
 	if (locale.extensions) {
 		for (const extension of locale.extensions) switch (extension.type) {
 			case "u":
-				extension.keywords = canonicalizeKVs(extension.keywords);
+				extension.keywords = canonicalizeKVs(extension.keywords, "u");
 				if (extension.attributes) extension.attributes = canonicalizeAttrs(extension.attributes);
 				break;
 			case "t":
 				if (extension.lang) extension.lang = canonicalizeUnicodeLanguageId(extension.lang);
-				extension.fields = canonicalizeKVs(extension.fields);
-				break;
-			default:
-				extension.value = extension.value.toLowerCase();
+				extension.fields = canonicalizeKVs(extension.fields, "t");
 				break;
+			default: extension.value = extension.value.toLowerCase();
 		}
 		locale.extensions.sort(compareExtension);
 	}
@@ -9306,38 +9542,38 @@ function CanonicalizeUnicodeLocaleId(locale) {
 }
 //#endregion
 //#region packages/intl-getcanonicallocales/index.ts
-/**
-* Check if value is an Intl.Locale object by checking for [[InitializedLocale]] internal slot
-* We detect this by checking if it's an Intl.Locale instance
-*
-* Per ECMA-402 #sec-canonicalizelocalelist step 7.c:
-* "If Type(kValue) is Object and kValue has an [[InitializedLocale]] internal slot, then
-*  Let tag be kValue.[[Locale]]"
-*
-* https://tc39.es/ecma402/#sec-canonicalizelocalelist
-*/
-function isLocaleObject(value) {
-	return typeof value === "object" && value !== null && typeof value.toString === "function" && typeof value.baseName === "string" && typeof value.language === "string";
+const originalLocaleToString = typeof Intl !== "undefined" ? Intl.Locale?.prototype.toString : void 0;
+function localeString(value) {
+	if (value === null || typeof value !== "object" && typeof value !== "function") return void 0;
+	const currentLocaleToString = typeof Intl !== "undefined" ? Intl.Locale?.prototype.toString : void 0;
+	for (const method of [originalLocaleToString, currentLocaleToString]) if (method) try {
+		const tag = method.call(value);
+		if (typeof tag === "string") return tag;
+	} catch {}
 }
 /**
+* ECMA-402 §9.2.1 CanonicalizeLocaleList, steps 3–7.
 * https://tc39.es/ecma402/#sec-canonicalizelocalelist
-* @param locales
+* https://github.com/tc39/ecma402/blob/b1c961988b9a07894b1dc3dc2b5626ea48387d61/spec/negotiation.html#L51-L70
 */
 function CanonicalizeLocaleList(locales) {
 	if (locales === void 0) return [];
+	if (locales === null) throw new TypeError("Cannot convert null to an object");
+	const singleLocale = localeString(locales);
+	const list = typeof locales === "string" ? [locales] : singleLocale !== void 0 ? [singleLocale] : Object(locales);
+	const length = +list.length;
+	const len = isNaN(length) ? 0 : Math.min(Math.max(Math.floor(length), 0), 9007199254740991);
 	const seen = [];
-	if (typeof locales === "string" || isLocaleObject(locales)) locales = [locales];
-	const O = Object(locales);
-	const len = typeof O.length === "number" ? O.length : 0;
 	for (let k = 0; k < len; k++) {
-		if (!(k in O)) continue;
-		const kValue = O[k];
-		let tag;
-		if (typeof kValue === "string") tag = kValue;
-		else if (isLocaleObject(kValue)) tag = kValue.toString();
-		else throw new TypeError(`Invalid locale type: expected string or Intl.Locale, got ${typeof kValue}`);
-		const canonicalizedTag = emitUnicodeLocaleId(CanonicalizeUnicodeLocaleId(parseUnicodeLocaleId(tag)));
-		if (seen.indexOf(canonicalizedTag) < 0) seen.push(canonicalizedTag);
+		if (!(k in list)) continue;
+		const value = list[k];
+		if (value === null || ![
+			"string",
+			"object",
+			"function"
+		].includes(typeof value)) throw new TypeError("Locale list entries must be strings or objects");
+		const canonicalizedTag = emitUnicodeLocaleId(CanonicalizeUnicodeLocaleId(parseUnicodeLocaleId(localeString(value) ?? ToString(value))));
+		if (seen.indexOf(canonicalizedTag) < 0) appendToList(seen, canonicalizedTag);
 	}
 	return seen;
 }