@formatjs/intl-pluralrules 6.3.12 → 6.3.14

package/polyfill.iife.js

@@ -1,4 +1,391 @@
-import { supportedLocales } from "@formatjs_generated/cldr.supported-locales/intl-pluralrules.js";
+//#region node_modules/.aspect_rules_js/@formatjs_generated+cldr.supported-locales@0.0.0/node_modules/@formatjs_generated/cldr.supported-locales/default-content.js
+const defaultContent = {
+	"aa": ["aa-ET"],
+	"ab": ["ab-GE"],
+	"af": ["af-ZA"],
+	"agq": ["agq-CM"],
+	"ak": ["ak-GH"],
+	"am": ["am-ET"],
+	"an": ["an-ES"],
+	"ann": ["ann-NG"],
+	"apc": ["apc-SY"],
+	"ar": ["ar-001"],
+	"arn": ["arn-CL"],
+	"as": ["as-IN"],
+	"asa": ["asa-TZ"],
+	"ast": ["ast-ES"],
+	"az-Arab": ["az-Arab-IR"],
+	"az-Cyrl": ["az-Cyrl-AZ"],
+	"az-Latn": ["az-Latn-AZ"],
+	"ba": ["ba-RU"],
+	"bal-Arab": ["bal-Arab-PK"],
+	"bal-Latn": ["bal-Latn-PK"],
+	"bas": ["bas-CM"],
+	"be": ["be-BY"],
+	"bem": ["bem-ZM"],
+	"bew": ["bew-ID"],
+	"bez": ["bez-TZ"],
+	"bg": ["bg-BG"],
+	"bgc": ["bgc-IN"],
+	"bgn": ["bgn-PK"],
+	"bho": ["bho-IN"],
+	"blo": ["blo-BJ"],
+	"blt": ["blt-VN"],
+	"bm": ["bm-ML"],
+	"bm-Nkoo": ["bm-Nkoo-ML"],
+	"bn": ["bn-BD"],
+	"bo": ["bo-CN"],
+	"bqi": ["bqi-IR"],
+	"br": ["br-FR"],
+	"brx": ["brx-IN"],
+	"bs-Cyrl": ["bs-Cyrl-BA"],
+	"bs-Latn": ["bs-Latn-BA"],
+	"bss": ["bss-CM"],
+	"bua": ["bua-RU"],
+	"byn": ["byn-ER"],
+	"ca": ["ca-ES"],
+	"cad": ["cad-US"],
+	"cch": ["cch-NG"],
+	"ccp": ["ccp-BD"],
+	"ce": ["ce-RU"],
+	"ceb": ["ceb-PH"],
+	"cgg": ["cgg-UG"],
+	"cho": ["cho-US"],
+	"chr": ["chr-US"],
+	"cic": ["cic-US"],
+	"ckb": ["ckb-IQ"],
+	"co": ["co-FR"],
+	"cop": ["cop-EG"],
+	"cs": ["cs-CZ"],
+	"csw": ["csw-CA"],
+	"cu": ["cu-RU"],
+	"cv": ["cv-RU"],
+	"cy": ["cy-GB"],
+	"da": ["da-DK"],
+	"dav": ["dav-KE"],
+	"de": ["de-DE"],
+	"dje": ["dje-NE"],
+	"doi": ["doi-IN"],
+	"dsb": ["dsb-DE"],
+	"dua": ["dua-CM"],
+	"dv": ["dv-MV"],
+	"dyo": ["dyo-SN"],
+	"dz": ["dz-BT"],
+	"ebu": ["ebu-KE"],
+	"ee": ["ee-GH"],
+	"el": ["el-GR"],
+	"en-Dsrt": ["en-Dsrt-US"],
+	"en-Shaw": ["en-Shaw-GB"],
+	"en": ["en-US"],
+	"eo": ["eo-001"],
+	"es": ["es-ES"],
+	"et": ["et-EE"],
+	"eu": ["eu-ES"],
+	"ewo": ["ewo-CM"],
+	"fa": ["fa-IR"],
+	"ff-Adlm": ["ff-Adlm-GN"],
+	"ff-Latn": ["ff-Latn-SN"],
+	"fi": ["fi-FI"],
+	"fil": ["fil-PH"],
+	"fo": ["fo-FO"],
+	"fr": ["fr-FR"],
+	"frr": ["frr-DE"],
+	"fur": ["fur-IT"],
+	"fy": ["fy-NL"],
+	"ga": ["ga-IE"],
+	"gaa": ["gaa-GH"],
+	"gd": ["gd-GB"],
+	"gez": ["gez-ET"],
+	"gl": ["gl-ES"],
+	"gn": ["gn-PY"],
+	"gsw": ["gsw-CH"],
+	"gu": ["gu-IN"],
+	"guz": ["guz-KE"],
+	"gv": ["gv-IM"],
+	"ha-Arab": ["ha-Arab-NG"],
+	"ha": ["ha-NG"],
+	"haw": ["haw-US"],
+	"he": ["he-IL"],
+	"hi": ["hi-IN"],
+	"hi-Latn": ["hi-Latn-IN"],
+	"hnj-Hmnp": ["hnj-Hmnp-US"],
+	"hr": ["hr-HR"],
+	"hsb": ["hsb-DE"],
+	"ht": ["ht-HT"],
+	"hu": ["hu-HU"],
+	"hy": ["hy-AM"],
+	"ia": ["ia-001"],
+	"id": ["id-ID"],
+	"ie": ["ie-EE"],
+	"ig": ["ig-NG"],
+	"ii": ["ii-CN"],
+	"io": ["io-001"],
+	"is": ["is-IS"],
+	"it": ["it-IT"],
+	"iu": ["iu-CA"],
+	"iu-Latn": ["iu-Latn-CA"],
+	"ja": ["ja-JP"],
+	"jbo": ["jbo-001"],
+	"jgo": ["jgo-CM"],
+	"jmc": ["jmc-TZ"],
+	"jv": ["jv-ID"],
+	"ka": ["ka-GE"],
+	"kaa-Cyrl": ["kaa-Cyrl-UZ"],
+	"kaa-Latn": ["kaa-Latn-UZ"],
+	"kab": ["kab-DZ"],
+	"kaj": ["kaj-NG"],
+	"kam": ["kam-KE"],
+	"kcg": ["kcg-NG"],
+	"kde": ["kde-TZ"],
+	"kea": ["kea-CV"],
+	"kek": ["kek-GT"],
+	"ken": ["ken-CM"],
+	"kgp": ["kgp-BR"],
+	"khq": ["khq-ML"],
+	"ki": ["ki-KE"],
+	"kk-Arab": ["kk-Arab-CN"],
+	"kk-Cyrl": ["kk-Cyrl-KZ"],
+	"kkj": ["kkj-CM"],
+	"kl": ["kl-GL"],
+	"kln": ["kln-KE"],
+	"km": ["km-KH"],
+	"kn": ["kn-IN"],
+	"ko": ["ko-KR"],
+	"kok-Deva": ["kok-Deva-IN"],
+	"kok-Latn": ["kok-Latn-IN"],
+	"kpe": ["kpe-LR"],
+	"ks-Arab": ["ks-Arab-IN"],
+	"ks-Deva": ["ks-Deva-IN"],
+	"ksb": ["ksb-TZ"],
+	"ksf": ["ksf-CM"],
+	"ksh": ["ksh-DE"],
+	"ku-Arab": ["ku-Arab-IQ"],
+	"ku-Latn": ["ku-Latn-TR"],
+	"kw": ["kw-GB"],
+	"kxv-Deva": ["kxv-Deva-IN"],
+	"kxv-Latn": ["kxv-Latn-IN"],
+	"kxv-Orya": ["kxv-Orya-IN"],
+	"kxv-Telu": ["kxv-Telu-IN"],
+	"ky": ["ky-KG"],
+	"la": ["la-VA"],
+	"lag": ["lag-TZ"],
+	"lb": ["lb-LU"],
+	"lg": ["lg-UG"],
+	"lij": ["lij-IT"],
+	"lkt": ["lkt-US"],
+	"lld": ["lld-IT"],
+	"lmo": ["lmo-IT"],
+	"ln": ["ln-CD"],
+	"lo": ["lo-LA"],
+	"lrc": ["lrc-IR"],
+	"lt": ["lt-LT"],
+	"ltg": ["ltg-LV"],
+	"lu": ["lu-CD"],
+	"luo": ["luo-KE"],
+	"luy": ["luy-KE"],
+	"lv": ["lv-LV"],
+	"lzz": ["lzz-TR"],
+	"mai": ["mai-IN"],
+	"mas": ["mas-KE"],
+	"mdf": ["mdf-RU"],
+	"mer": ["mer-KE"],
+	"mfe": ["mfe-MU"],
+	"mg": ["mg-MG"],
+	"mgh": ["mgh-MZ"],
+	"mgo": ["mgo-CM"],
+	"mhn": ["mhn-IT"],
+	"mi": ["mi-NZ"],
+	"mic": ["mic-CA"],
+	"mk": ["mk-MK"],
+	"ml": ["ml-IN"],
+	"mn": ["mn-MN"],
+	"mn-Mong": ["mn-Mong-CN"],
+	"mni-Beng": ["mni-Beng-IN"],
+	"mni-Mtei": ["mni-Mtei-IN"],
+	"moh": ["moh-CA"],
+	"mr": ["mr-IN"],
+	"ms-Arab": ["ms-Arab-MY"],
+	"ms": ["ms-MY"],
+	"mt": ["mt-MT"],
+	"mua": ["mua-CM"],
+	"mus": ["mus-US"],
+	"mww-Hmnp": ["mww-Hmnp-US"],
+	"my": ["my-MM"],
+	"myv": ["myv-RU"],
+	"mzn": ["mzn-IR"],
+	"naq": ["naq-NA"],
+	"nb": ["nb-NO"],
+	"nd": ["nd-ZW"],
+	"nds": ["nds-DE"],
+	"ne": ["ne-NP"],
+	"nl": ["nl-NL"],
+	"nmg": ["nmg-CM"],
+	"nn": ["nn-NO"],
+	"nnh": ["nnh-CM"],
+	"nqo": ["nqo-GN"],
+	"nr": ["nr-ZA"],
+	"nso": ["nso-ZA"],
+	"nus": ["nus-SS"],
+	"nv": ["nv-US"],
+	"ny": ["ny-MW"],
+	"nyn": ["nyn-UG"],
+	"oc": ["oc-FR"],
+	"oka": ["oka-CA"],
+	"om": ["om-ET"],
+	"or": ["or-IN"],
+	"os": ["os-GE"],
+	"osa": ["osa-US"],
+	"pa-Arab": ["pa-Arab-PK"],
+	"pa-Guru": ["pa-Guru-IN"],
+	"pap": ["pap-CW"],
+	"pcm": ["pcm-NG"],
+	"pi-Latn": ["pi-Latn-GB"],
+	"pis": ["pis-SB"],
+	"pl": ["pl-PL"],
+	"pms": ["pms-IT"],
+	"prg": ["prg-PL"],
+	"ps": ["ps-AF"],
+	"pt": ["pt-BR"],
+	"qu": ["qu-PE"],
+	"quc": ["quc-GT"],
+	"raj": ["raj-IN"],
+	"rhg-Rohg": ["rhg-Rohg-MM"],
+	"rif": ["rif-MA"],
+	"rm": ["rm-CH"],
+	"rn": ["rn-BI"],
+	"ro": ["ro-RO"],
+	"rof": ["rof-TZ"],
+	"ru": ["ru-RU"],
+	"rw": ["rw-RW"],
+	"rwk": ["rwk-TZ"],
+	"sa": ["sa-IN"],
+	"sah": ["sah-RU"],
+	"saq": ["saq-KE"],
+	"sat-Deva": ["sat-Deva-IN"],
+	"sat-Olck": ["sat-Olck-IN"],
+	"sbp": ["sbp-TZ"],
+	"sc": ["sc-IT"],
+	"scn": ["scn-IT"],
+	"sd-Arab": ["sd-Arab-PK"],
+	"sd-Deva": ["sd-Deva-IN"],
+	"sdh": ["sdh-IR"],
+	"se": ["se-NO"],
+	"seh": ["seh-MZ"],
+	"ses": ["ses-ML"],
+	"sg": ["sg-CF"],
+	"sgs": ["sgs-LT"],
+	"shi-Latn": ["shi-Latn-MA"],
+	"shi-Tfng": ["shi-Tfng-MA"],
+	"shn": ["shn-MM"],
+	"si": ["si-LK"],
+	"sid": ["sid-ET"],
+	"sk": ["sk-SK"],
+	"skr": ["skr-PK"],
+	"sl": ["sl-SI"],
+	"sma": ["sma-SE"],
+	"smj": ["smj-SE"],
+	"smn": ["smn-FI"],
+	"sms": ["sms-FI"],
+	"sn": ["sn-ZW"],
+	"so": ["so-SO"],
+	"sq": ["sq-AL"],
+	"sr-Cyrl": ["sr-Cyrl-RS"],
+	"sr-Latn": ["sr-Latn-RS"],
+	"ss": ["ss-ZA"],
+	"ssy": ["ssy-ER"],
+	"st": ["st-ZA"],
+	"su-Latn": ["su-Latn-ID"],
+	"suz-Deva": ["suz-Deva-NP"],
+	"suz-Sunu": ["suz-Sunu-NP"],
+	"sv": ["sv-SE"],
+	"sw": ["sw-TZ"],
+	"syr": ["syr-IQ"],
+	"szl": ["szl-PL"],
+	"ta": ["ta-IN"],
+	"te": ["te-IN"],
+	"teo": ["teo-UG"],
+	"tg": ["tg-TJ"],
+	"th": ["th-TH"],
+	"ti": ["ti-ET"],
+	"tig": ["tig-ER"],
+	"tk": ["tk-TM"],
+	"tn": ["tn-ZA"],
+	"to": ["to-TO"],
+	"tok": ["tok-001"],
+	"tpi": ["tpi-PG"],
+	"tr": ["tr-TR"],
+	"trv": ["trv-TW"],
+	"trw": ["trw-PK"],
+	"ts": ["ts-ZA"],
+	"tt": ["tt-RU"],
+	"twq": ["twq-NE"],
+	"tyv": ["tyv-RU"],
+	"tzm": ["tzm-MA"],
+	"ug": ["ug-CN"],
+	"uk": ["uk-UA"],
+	"ur": ["ur-PK"],
+	"uz-Arab": ["uz-Arab-AF"],
+	"uz-Cyrl": ["uz-Cyrl-UZ"],
+	"uz-Latn": ["uz-Latn-UZ"],
+	"vai-Latn": ["vai-Latn-LR"],
+	"vai-Vaii": ["vai-Vaii-LR"],
+	"ve": ["ve-ZA"],
+	"vec": ["vec-IT"],
+	"vi": ["vi-VN"],
+	"vmw": ["vmw-MZ"],
+	"vo": ["vo-001"],
+	"vun": ["vun-TZ"],
+	"wa": ["wa-BE"],
+	"wae": ["wae-CH"],
+	"wal": ["wal-ET"],
+	"wbp": ["wbp-AU"],
+	"wo": ["wo-SN"],
+	"xh": ["xh-ZA"],
+	"xnr": ["xnr-IN"],
+	"xog": ["xog-UG"],
+	"yav": ["yav-CM"],
+	"yi": ["yi-UA"],
+	"yo": ["yo-NG"],
+	"yrl": ["yrl-BR"],
+	"yue-Hans": ["yue-Hans-CN"],
+	"yue-Hant": ["yue-Hant-HK"],
+	"za": ["za-CN"],
+	"zgh": ["zgh-MA"],
+	"zh-Hans": ["zh-Hans-CN"],
+	"zh-Hant": ["zh-Hant-TW"],
+	"zh-Latn": ["zh-Latn-CN"],
+	"zu": ["zu-ZA"]
+};
+//#endregion
+//#region packages/ecma402-abstract/registerLocaleData.js
+const explicitLocales = /* @__PURE__ */ new WeakMap();
+function registerLocaleData(locale, data, localeData, availableLocales) {
+	let loaded = explicitLocales.get(localeData);
+	if (!loaded) {
+		loaded = /* @__PURE__ */ new Set();
+		explicitLocales.set(localeData, loaded);
+	}
+	loaded.add(locale);
+	const locales = [locale, ...defaultContent[locale] || []];
+	for (const tag of locales) {
+		if (tag === locale || !loaded.has(tag) || localeData[tag] === void 0) localeData[tag] = data;
+		availableLocales.add(tag);
+	}
+	for (const tag of locales) {
+		const parts = tag.split("-");
+		const fallbacks = [];
+		while (parts.length > 1) {
+			if (parts.length > 2 && parts[1].length === 4) fallbacks.push([parts[0], ...parts.slice(2)].join("-"));
+			parts.pop();
+			fallbacks.push(parts.join("-"));
+		}
+		for (const fallback of fallbacks) {
+			if (localeData[fallback] === void 0) localeData[fallback] = localeData[tag];
+			availableLocales.add(fallback);
+		}
+	}
+}
+//#endregion
 //#region packages/ecma402-abstract/CanonicalizeLocaleList.js
 /**
 * http://ecma-international.org/ecma-402/7.0/index.html#sec-canonicalizelocalelist
@@ -3261,7 +3648,20 @@ const regions = {
 		"ZW"
 	]
 };
-const UNICODE_EXTENSION_SEQUENCE_REGEX = /-u(?:-[0-9a-z]{2,8})+/gi;
+function splitUnicodeExtension(locale) {
+	const subtags = locale.split("-");
+	for (let i = 1; i < subtags.length; i++) {
+		if (subtags[i] === "x") break;
+		if (subtags[i] !== "u") continue;
+		let end = i + 1;
+		while (end < subtags.length && subtags[end].length > 1) end++;
+		return {
+			locale: [...subtags.slice(0, i), ...subtags.slice(end)].join("-"),
+			extension: "-" + subtags.slice(i, end).join("-")
+		};
+	}
+	return { locale };
+}
 /**
 * Asserts that a condition is true, throwing an error if it is not.
 * Used for runtime validation and type narrowing.
@@ -3277,7 +3677,7 @@ const UNICODE_EXTENSION_SEQUENCE_REGEX = /-u(?:-[0-9a-z]{2,8})+/gi;
 * // locale is now narrowed to non-undefined type
 * ```
 */
-function invariant$3(condition, message, Err = Error) {
+function invariant$2(condition, message, Err = Error) {
 	if (!condition) throw new Err(message);
 }
 const DEFAULT_MATCHING_THRESHOLD = 838;
@@ -3561,7 +3961,7 @@ function BestFitMatcher(availableLocales, requestedLocales, getDefaultLocale) {
 	let extension;
 	const noExtensionLocales = [];
 	const noExtensionLocaleMap = requestedLocales.reduce((all, l) => {
-		const noExtensionLocale = l.replace(UNICODE_EXTENSION_SEQUENCE_REGEX, "");
+		const { locale: noExtensionLocale } = splitUnicodeExtension(l);
 		noExtensionLocales.push(noExtensionLocale);
 		all[noExtensionLocale] = l;
 		return all;
@@ -3569,7 +3969,7 @@ function BestFitMatcher(availableLocales, requestedLocales, getDefaultLocale) {
 	const result = findBestMatch(noExtensionLocales, availableLocales);
 	if (result.matchedSupportedLocale && result.matchedDesiredLocale) {
 		foundLocale = result.matchedSupportedLocale;
-		extension = noExtensionLocaleMap[result.matchedDesiredLocale].slice(result.matchedDesiredLocale.length) || void 0;
+		extension = splitUnicodeExtension(noExtensionLocaleMap[result.matchedDesiredLocale]).extension;
 	}
 	if (!foundLocale) return { locale: getDefaultLocale() };
 	return {
@@ -3579,14 +3979,14 @@ function BestFitMatcher(availableLocales, requestedLocales, getDefaultLocale) {
 }
 function CanonicalizeUValue(ukey, uvalue) {
 	let lowerValue = uvalue.toLowerCase();
-	invariant$3(ukey !== void 0, `ukey must be defined`);
+	invariant$2(ukey !== void 0, `ukey must be defined`);
 	return lowerValue;
 }
 function CanonicalizeUnicodeLocaleId(locale) {
 	return Intl.getCanonicalLocales(locale)[0];
 }
 function InsertUnicodeExtensionAndCanonicalize(locale, attributes, keywords) {
-	invariant$3(locale.indexOf("-u-") === -1, "Expected locale to not have a Unicode locale extension");
+	invariant$2(splitUnicodeExtension(locale).extension === void 0, "Expected locale to not have a Unicode locale extension");
 	let extension = "-u";
 	for (const attr of attributes) extension += `-${attr}`;
 	for (const kw of keywords) {
@@ -3635,11 +4035,11 @@ function BestAvailableLocale(availableLocales, locale) {
 function LookupMatcher(availableLocales, requestedLocales, getDefaultLocale) {
 	const result = { locale: "" };
 	for (const locale of requestedLocales) {
-		const noExtensionLocale = locale.replace(UNICODE_EXTENSION_SEQUENCE_REGEX, "");
+		const { locale: noExtensionLocale, extension } = splitUnicodeExtension(locale);
 		const availableLocale = BestAvailableLocale(availableLocales, noExtensionLocale);
 		if (availableLocale) {
 			result.locale = availableLocale;
-			if (locale !== noExtensionLocale) result.extension = locale.slice(noExtensionLocale.length, locale.length);
+			if (extension) result.extension = extension;
 			return result;
 		}
 	}
@@ -3647,8 +4047,8 @@ function LookupMatcher(availableLocales, requestedLocales, getDefaultLocale) {
 	return result;
 }
 function UnicodeExtensionComponents(extension) {
-	invariant$3(extension === extension.toLowerCase(), "Expected extension to be lowercase");
-	invariant$3(extension.slice(0, 3) === "-u-", "Expected extension to be a Unicode locale extension");
+	invariant$2(extension === extension.toLowerCase(), "Expected extension to be lowercase");
+	invariant$2(extension.slice(0, 3) === "-u-", "Expected extension to be a Unicode locale extension");
 	const attributes = [];
 	const keywords = [];
 	let keyword;
@@ -3660,7 +4060,7 @@ function UnicodeExtensionComponents(extension) {
 		if (e === -1) len = size - k;
 		else len = e - k;
 		let subtag = extension.slice(k, k + len);
-		invariant$3(len >= 2, "Expected a subtag to have at least 2 characters");
+		invariant$2(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);
 		} else if (len === 2) {
@@ -3671,7 +4071,7 @@ function UnicodeExtensionComponents(extension) {
 			if (keywords.find((k) => k.key === keyword?.key) === void 0) keywords.push(keyword);
 		} else if (keyword?.value === "") keyword.value = subtag;
 		else {
-			invariant$3(keyword !== void 0, "Expected keyword to be defined");
+			invariant$2(keyword !== void 0, "Expected keyword to be defined");
 			keyword.value += "-" + subtag;
 		}
 		k += len + 1;
@@ -3695,10 +4095,9 @@ function ResolveLocale(availableLocales, requestedLocales, options, relevantExte
 	};
 	let foundLocale = r.locale;
 	let foundLocaleData = localeData[foundLocale];
-	const result = {
-		locale: "en",
-		dataLocale: foundLocale
-	};
+	const result = Object.create(null);
+	result.locale = "en";
+	result.dataLocale = foundLocale;
 	let components;
 	let keywords;
 	if (r.extension) {
@@ -3708,9 +4107,9 @@ function ResolveLocale(availableLocales, requestedLocales, options, relevantExte
 	let supportedKeywords = [];
 	for (const key of relevantExtensionKeys) {
 		let keyLocaleData = foundLocaleData?.[key] ?? [];
-		invariant$3(Array.isArray(keyLocaleData), `keyLocaleData for ${key} must be an array`);
+		invariant$2(Array.isArray(keyLocaleData), `keyLocaleData for ${key} must be an array`);
 		let value = keyLocaleData[0];
-		invariant$3(value === void 0 || typeof value === "string", `value must be a string or undefined`);
+		invariant$2(value == null || typeof value === "string", `value must be a string, null, or undefined`);
 		let supportedKeyword;
 		let entry = keywords.find((k) => k.key === key);
 		if (entry) {
@@ -3732,12 +4131,12 @@ function ResolveLocale(availableLocales, requestedLocales, options, relevantExte
 			}
 		}
 		let optionsValue = options[key];
-		invariant$3(optionsValue == null || typeof optionsValue === "string", `optionsValue must be a string or undefined`);
+		invariant$2(optionsValue == null || typeof optionsValue === "string", `optionsValue must be a string or undefined`);
 		if (typeof optionsValue === "string") {
 			optionsValue = CanonicalizeUValue(key.toLowerCase(), optionsValue);
 			if (optionsValue === "") optionsValue = "true";
 		}
-		if (optionsValue !== value && keyLocaleData.indexOf(optionsValue) > -1) {
+		if (optionsValue !== void 0 && optionsValue !== value && keyLocaleData.indexOf(optionsValue) > -1) {
 			value = optionsValue;
 			supportedKeyword = void 0;
 		}
@@ -3760,8 +4159,8 @@ function ResolveLocale(availableLocales, requestedLocales, options, relevantExte
 function LookupSupportedLocales(availableLocales, requestedLocales) {
 	const subset = [];
 	for (const locale of requestedLocales) {
-		const availableLocale = BestAvailableLocale(availableLocales, locale.replace(UNICODE_EXTENSION_SEQUENCE_REGEX, ""));
-		if (availableLocale) subset.push(availableLocale);
+		const { locale: noExtensionLocale } = splitUnicodeExtension(locale);
+		if (BestAvailableLocale(availableLocales, noExtensionLocale)) subset.push(locale);
 	}
 	return subset;
 }
@@ -3797,7 +4196,7 @@ 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");
@@ -4128,7 +4527,8 @@ var BigDecimal = class BigDecimal {
 			const leading = absMantissa / bigintPow10(shift);
 			log10Mantissa = Math.log10(Number(leading)) + shift;
 		}
-		return new BigDecimal(log10Mantissa + this._exponent);
+		const totalLog10 = log10Mantissa + this._exponent;
+		return new BigDecimal(totalLog10);
 	}
 	eq(y) {
 		const other = BigDecimal._coerce(y);
@@ -4285,7 +4685,7 @@ var BigDecimal = class BigDecimal {
 };
 //#endregion
 //#region packages/ecma262-abstract/ToPrimitive.js
-function invariant$2(condition, message, Err = Error) {
+function invariant$1(condition, message, Err = Error) {
 	if (!condition) throw new Err(message);
 }
 function IsCallable(fn) {
@@ -4315,7 +4715,7 @@ function ToPrimitive(input, preferredType) {
 			if (preferredType === void 0) hint = "default";
 			else if (preferredType === "string") hint = "string";
 			else {
-				invariant$2(preferredType === "number", "preferredType must be \"string\" or \"number\"");
+				invariant$1(preferredType === "number", "preferredType must be \"string\" or \"number\"");
 				hint = "number";
 			}
 			let result = exoticToPrim.call(input, hint);
@@ -4336,6 +4736,7 @@ function ToPrimitive(input, preferredType) {
 function ToIntlMathematicalValue(input) {
 	if (typeof input === "bigint") return new BigDecimal(input.toString());
 	let primValue = ToPrimitive(input, "number");
+	if (typeof primValue === "symbol") throw new TypeError("Cannot convert a Symbol value to a number");
 	if (primValue === void 0) return new BigDecimal(NaN);
 	if (primValue === true) return new BigDecimal(1);
 	if (primValue === false) return new BigDecimal(0);
@@ -4360,7 +4761,9 @@ function CoerceOptionsToObject(options) {
 //#endregion
 //#region packages/ecma402-abstract/DefaultNumberOption.js
 /**
+* ECMA-402 §9.2.13 DefaultNumberOption, step 2.
 * https://tc39.es/ecma402/#sec-defaultnumberoption
+* https://github.com/tc39/ecma402/blob/b1c961988b9a07894b1dc3dc2b5626ea48387d61/spec/negotiation.html#L437
 * @param val
 * @param min
 * @param max
@@ -4368,7 +4771,7 @@ function CoerceOptionsToObject(options) {
 */
 function DefaultNumberOption(inputVal, min, max, fallback) {
 	if (inputVal === void 0) return fallback;
-	const val = Number(inputVal);
+	const val = +inputVal;
 	if (isNaN(val) || val < min || val > max) throw new RangeError(`${val} is outside of range [${min}, ${max}]`);
 	return Math.floor(val);
 }
@@ -4411,7 +4814,7 @@ function ensureIntl() {
 	});
 	return Intl;
 }
-function invariant$1(condition, message, Err = Error) {
+function invariant(condition, message, Err = Error) {
 	if (!condition) throw new Err(message);
 }
 memoize((...args) => new Intl.NumberFormat(...args), { strategy: strategies.variadic });
@@ -4447,8 +4850,8 @@ function SetNumberFormatDigitOptions(internalSlots, opts, mnfdDefault, mxfdDefau
 	let mxsd = opts.maximumSignificantDigits;
 	internalSlots.minimumIntegerDigits = mnid;
 	const roundingIncrement = GetNumberOption(opts, "roundingIncrement", 1, 5e3, 1);
-	invariant$1(VALID_ROUNDING_INCREMENTS.has(roundingIncrement), `Invalid rounding increment value: ${roundingIncrement}.
-Valid values are ${Array.from(VALID_ROUNDING_INCREMENTS).join(", ")}.`);
+	invariant(VALID_ROUNDING_INCREMENTS.has(roundingIncrement), `Invalid rounding increment value: ${roundingIncrement}.
+Valid values are ${Array.from(VALID_ROUNDING_INCREMENTS).join(", ")}.`, RangeError);
 	const roundingMode = GetOption(opts, "roundingMode", "string", [
 		"ceil",
 		"floor",
@@ -4478,26 +4881,30 @@ Valid values are ${Array.from(VALID_ROUNDING_INCREMENTS).join(", ")}.`);
 		needSd = hasSd;
 		if (hasSd || !hasFd && notation === "compact") needFd = false;
 	}
-	if (needSd) if (hasSd) {
-		internalSlots.minimumSignificantDigits = DefaultNumberOption(mnsd, 1, 21, 1);
-		internalSlots.maximumSignificantDigits = DefaultNumberOption(mxsd, internalSlots.minimumSignificantDigits, 21, 21);
-	} else {
-		internalSlots.minimumSignificantDigits = 1;
-		internalSlots.maximumSignificantDigits = 21;
+	if (needSd) {
+		if (hasSd) {
+			internalSlots.minimumSignificantDigits = DefaultNumberOption(mnsd, 1, 21, 1);
+			internalSlots.maximumSignificantDigits = DefaultNumberOption(mxsd, internalSlots.minimumSignificantDigits, 21, 21);
+		} else {
+			internalSlots.minimumSignificantDigits = 1;
+			internalSlots.maximumSignificantDigits = 21;
+		}
 	}
-	if (needFd) if (hasFd) {
-		mnfd = DefaultNumberOption(mnfd, 0, 100, void 0);
-		mxfd = DefaultNumberOption(mxfd, 0, 100, void 0);
-		if (mnfd === void 0) {
-			invariant$1(mxfd !== void 0, "maximumFractionDigits must be defined");
-			mnfd = Math.min(mnfdDefault, mxfd);
-		} else if (mxfd === void 0) mxfd = Math.max(mxfdDefault, mnfd);
-		else if (mnfd > mxfd) throw new RangeError(`Invalid range, ${mnfd} > ${mxfd}`);
-		internalSlots.minimumFractionDigits = mnfd;
-		internalSlots.maximumFractionDigits = mxfd;
-	} else {
-		internalSlots.minimumFractionDigits = mnfdDefault;
-		internalSlots.maximumFractionDigits = mxfdDefault;
+	if (needFd) {
+		if (hasFd) {
+			mnfd = DefaultNumberOption(mnfd, 0, 100, void 0);
+			mxfd = DefaultNumberOption(mxfd, 0, 100, void 0);
+			if (mnfd === void 0) {
+				invariant(mxfd !== void 0, "maximumFractionDigits must be defined");
+				mnfd = Math.min(mnfdDefault, mxfd);
+			} else if (mxfd === void 0) mxfd = Math.max(mxfdDefault, mnfd);
+			else if (mnfd > mxfd) throw new RangeError(`Invalid range, ${mnfd} > ${mxfd}`);
+			internalSlots.minimumFractionDigits = mnfd;
+			internalSlots.maximumFractionDigits = mxfd;
+		} else {
+			internalSlots.minimumFractionDigits = mnfdDefault;
+			internalSlots.maximumFractionDigits = mxfdDefault;
+		}
 	}
 	if (!needSd && !needFd) {
 		internalSlots.minimumFractionDigits = 0;
@@ -4520,8 +4927,8 @@ Valid values are ${Array.from(VALID_ROUNDING_INCREMENTS).join(", ")}.`);
 		internalSlots.roundingPriority = "auto";
 	}
 	if (roundingIncrement !== 1) {
-		invariant$1(internalSlots.roundingType === "fractionDigits", "Invalid roundingType", TypeError);
-		invariant$1(internalSlots.maximumFractionDigits === internalSlots.minimumFractionDigits, "With roundingIncrement > 1, maximumFractionDigits and minimumFractionDigits must be equal.", RangeError);
+		invariant(internalSlots.roundingType === "fractionDigits", "Invalid roundingType", TypeError);
+		invariant(internalSlots.maximumFractionDigits === internalSlots.minimumFractionDigits, "With roundingIncrement > 1, maximumFractionDigits and minimumFractionDigits must be equal.", RangeError);
 	}
 }
 //#endregion
@@ -4536,13 +4943,19 @@ function InitializePluralRules(pl, locales, options, { availableLocales, relevan
 	const r = ResolveLocale(availableLocales, requestedLocales, opt, relevantExtensionKeys, localeData, getDefaultLocale);
 	internalSlots.locale = r.locale;
 	internalSlots.type = GetOption(opts, "type", "string", ["cardinal", "ordinal"], "cardinal");
-	const notation = GetOption(opts, "notation", "string", ["standard", "compact"], "standard");
+	const notation = GetOption(opts, "notation", "string", [
+		"standard",
+		"scientific",
+		"engineering",
+		"compact"
+	], "standard");
 	internalSlots.notation = notation;
+	const compactDisplay = GetOption(opts, "compactDisplay", "string", ["short", "long"], "short");
 	if (notation === "compact") {
-		internalSlots.compactDisplay = GetOption(opts, "compactDisplay", "string", ["short", "long"], "short");
-		if (typeof Intl !== "undefined" && Intl.NumberFormat && Intl.NumberFormat.localeData) internalSlots.dataLocaleData = Intl.NumberFormat.localeData[r.locale];
+		internalSlots.compactDisplay = compactDisplay;
+		internalSlots.compactExponents = localeData[r.dataLocale]?.compactExponents;
 	}
-	SetNumberFormatDigitOptions(internalSlots, opts, 0, 3, "standard");
+	SetNumberFormatDigitOptions(internalSlots, opts, 0, 3, notation);
 	return pl;
 }
 //#endregion
@@ -4561,62 +4974,8 @@ function Type(x) {
 	if (typeof x === "bigint") return "BigInt";
 }
 //#endregion
-//#region packages/ecma402-abstract/NumberFormat/decimal-cache.js
-/**
-* Cached function to compute powers of 10 for Decimal.js operations.
-* This cache significantly reduces overhead in ComputeExponent and ToRawFixed
-* by memoizing expensive Decimal.pow(10, n) calculations.
-*
-* Common exponents (e.g., -20 to 20) are used repeatedly in number formatting,
-* so caching provides substantial performance benefits.
-*
-* @param exponent - Can be a number or Decimal. If Decimal, it will be converted to string for cache key.
-*/
-const getPowerOf10 = memoize((exponent) => {
-	return BigDecimal.pow(10, exponent);
-});
-//#endregion
-//#region packages/ecma402-abstract/NumberFormat/ComputeExponentForMagnitude.js
-/**
-* The abstract operation ComputeExponentForMagnitude computes an exponent by which to scale a
-* number of the given magnitude (power of ten of the most significant digit) according to the
-* locale and the desired notation (scientific, engineering, or compact).
-*/
-function ComputeExponentForMagnitude(internalSlots, magnitude) {
-	const { notation, dataLocaleData, numberingSystem } = internalSlots;
-	switch (notation) {
-		case "standard": return 0;
-		case "scientific": return magnitude.toNumber();
-		case "engineering": return magnitude.div(3).floor().times(3).toNumber();
-		default: {
-			invariant$1(notation === "compact", "Invalid notation");
-			const { compactDisplay, style, currencyDisplay } = internalSlots;
-			let thresholdMap;
-			if (style === "currency" && currencyDisplay !== "name") thresholdMap = (dataLocaleData.numbers.currency[numberingSystem] || dataLocaleData.numbers.currency[dataLocaleData.numbers.nu[0]]).short;
-			else {
-				const decimal = dataLocaleData.numbers.decimal[numberingSystem] || dataLocaleData.numbers.decimal[dataLocaleData.numbers.nu[0]];
-				thresholdMap = compactDisplay === "long" ? decimal.long : decimal.short;
-			}
-			if (!thresholdMap) return 0;
-			const num = getPowerOf10(magnitude).toString();
-			const thresholds = Object.keys(thresholdMap);
-			if (num < thresholds[0]) return 0;
-			if (num > thresholds[thresholds.length - 1]) {
-				const magnitudeKey = thresholds[thresholds.length - 1];
-				if (thresholdMap[magnitudeKey].other === "0") return 0;
-				return magnitudeKey.length - thresholdMap[magnitudeKey].other.match(/0+/)[0].length;
-			}
-			const i = thresholds.indexOf(num);
-			if (i === -1) return 0;
-			const magnitudeKey = thresholds[i];
-			if (thresholdMap[magnitudeKey].other === "0") return 0;
-			return magnitudeKey.length - thresholdMap[magnitudeKey].other.match(/0+/)[0].length;
-		}
-	}
-}
-//#endregion
 //#region packages/ecma402-abstract/constants.js
-const ZERO$1 = new BigDecimal(0);
+const ZERO = new BigDecimal(0);
 const NEGATIVE_ZERO = new BigDecimal(-0);
 //#endregion
 //#region packages/ecma402-abstract/NumberFormat/GetUnsignedRoundingMode.js
@@ -4651,21 +5010,36 @@ function GetUnsignedRoundingMode(roundingMode, isNegative) {
 function ApplyUnsignedRoundingMode(x, r1, r2, unsignedRoundingMode) {
 	if (x.eq(r1) || r1.eq(r2)) return r1;
 	if (x.eq(r2)) return r2;
-	invariant$1(r1.lessThan(x) && x.lessThan(r2), `x should be between r1 and r2 but x=${x}, r1=${r1}, r2=${r2}`);
+	invariant(r1.lessThan(x) && x.lessThan(r2), `x should be between r1 and r2 but x=${x}, r1=${r1}, r2=${r2}`);
 	if (unsignedRoundingMode === "zero") return r1;
 	if (unsignedRoundingMode === "infinity") return r2;
 	const d1 = x.minus(r1);
 	const d2 = r2.minus(x);
 	if (d1.lessThan(d2)) return r1;
 	if (d2.lessThan(d1)) return r2;
-	invariant$1(d1.eq(d2), "d1 should be equal to d2");
+	invariant(d1.eq(d2), "d1 should be equal to d2");
 	if (unsignedRoundingMode === "half-zero") return r1;
 	if (unsignedRoundingMode === "half-infinity") return r2;
-	invariant$1(unsignedRoundingMode === "half-even", "unsignedRoundingMode should be half-even");
+	invariant(unsignedRoundingMode === "half-even", "unsignedRoundingMode should be half-even");
 	if (r1.div(r2.minus(r1)).mod(2).isZero()) return r1;
 	return r2;
 }
 //#endregion
+//#region packages/ecma402-abstract/NumberFormat/decimal-cache.js
+/**
+* Cached function to compute powers of 10 for Decimal.js operations.
+* This cache significantly reduces overhead in ComputeExponent and ToRawFixed
+* by memoizing expensive Decimal.pow(10, n) calculations.
+*
+* Common exponents (e.g., -20 to 20) are used repeatedly in number formatting,
+* so caching provides substantial performance benefits.
+*
+* @param exponent - Can be a number or Decimal. If Decimal, it will be converted to string for cache key.
+*/
+const getPowerOf10 = memoize((exponent) => {
+	return BigDecimal.pow(10, exponent);
+});
+//#endregion
 //#region packages/ecma402-abstract/NumberFormat/ToRawFixed.js
 function ToRawFixedFn(n, f) {
 	return n.times(getPowerOf10(-f));
@@ -4823,7 +5197,7 @@ function ToRawPrecision(x, minPrecision, maxPrecision, unsignedRoundingMode) {
 	if (x.isZero()) {
 		m = repeat("0", p);
 		e = 0;
-		xFinal = ZERO$1;
+		xFinal = ZERO;
 	} else {
 		const { n1, e1, r1 } = findN1E1R1(x, p);
 		const { n2, e2, r2 } = findN2E2R2(x, p);
@@ -4848,7 +5222,7 @@ function ToRawPrecision(x, minPrecision, maxPrecision, unsignedRoundingMode) {
 		m = m.slice(0, e + 1) + "." + m.slice(m.length - (p - (e + 1)));
 		int = e + 1;
 	} else {
-		invariant$1(e < 0, "e should be less than 0");
+		invariant(e < 0, "e should be less than 0");
 		m = "0." + repeat("0", -e - 1) + m;
 		int = 1;
 	}
@@ -4864,7 +5238,7 @@ function ToRawPrecision(x, minPrecision, maxPrecision, unsignedRoundingMode) {
 		formattedString: m,
 		roundedNumber: xFinal,
 		integerDigitsCount: int,
-		roundingMagnitude: e
+		roundingMagnitude: e - p + 1
 	};
 }
 //#endregion
@@ -4877,9 +5251,9 @@ function FormatNumericToString(intlObject, _x) {
 	let sign;
 	if (x.isZero() && x.isNegative()) {
 		sign = "negative";
-		x = ZERO$1;
+		x = ZERO;
 	} else {
-		invariant$1(x.isFinite(), "NumberFormatDigitInternalSlots value is not finite");
+		invariant(x.isFinite(), "NumberFormatDigitInternalSlots value is not finite");
 		if (x.lessThan(0)) sign = "negative";
 		else sign = "positive";
 		if (sign === "negative") x = x.negated();
@@ -4897,14 +5271,14 @@ function FormatNumericToString(intlObject, _x) {
 		default:
 			let sResult = ToRawPrecision(x, intlObject.minimumSignificantDigits, intlObject.maximumSignificantDigits, unsignedRoundingMode);
 			let fResult = ToRawFixed(x, intlObject.minimumFractionDigits, intlObject.maximumFractionDigits, intlObject.roundingIncrement, unsignedRoundingMode);
-			if (intlObject.roundingType === "morePrecision") if (sResult.roundingMagnitude <= fResult.roundingMagnitude) result = sResult;
-			else result = fResult;
-			else {
-				invariant$1(intlObject.roundingType === "lessPrecision", "Invalid roundingType");
+			if (intlObject.roundingType === "morePrecision") {
+				if (sResult.roundingMagnitude <= fResult.roundingMagnitude) result = sResult;
+				else result = fResult;
+			} else {
+				invariant(intlObject.roundingType === "lessPrecision", "Invalid roundingType");
 				if (sResult.roundingMagnitude <= fResult.roundingMagnitude) result = fResult;
 				else result = sResult;
 			}
-			break;
 	}
 	x = result.roundedNumber;
 	let string = result.formattedString;
@@ -4915,44 +5289,22 @@ function FormatNumericToString(intlObject, _x) {
 	const int = result.integerDigitsCount;
 	const minInteger = intlObject.minimumIntegerDigits;
 	if (int < minInteger) string = repeat("0", minInteger - int) + string;
-	if (sign === "negative") if (x.isZero()) x = NEGATIVE_ZERO;
-	else x = x.negated();
+	if (sign === "negative") {
+		if (x.isZero()) x = NEGATIVE_ZERO;
+		else x = x.negated();
+	}
 	return {
 		roundedNumber: x,
 		formattedString: string
 	};
 }
 //#endregion
-//#region packages/ecma262-abstract/ToNumber.js
-const ZERO = new BigDecimal(0);
-function invariant(condition, message, Err = Error) {
-	if (!condition) throw new Err(message);
-}
-/**
-* https://tc39.es/ecma262/#sec-tonumber
-*/
-function ToNumber(arg) {
-	if (typeof arg === "number") return new BigDecimal(arg);
-	if (typeof arg === "bigint") return new BigDecimal(arg.toString());
-	invariant(typeof arg !== "symbol", "Symbol is not supported", TypeError);
-	if (arg === void 0) return new BigDecimal(NaN);
-	if (arg === null || arg === 0) return ZERO;
-	if (arg === true) return new BigDecimal(1);
-	if (typeof arg === "string") try {
-		return new BigDecimal(arg);
-	} catch {
-		return new BigDecimal(NaN);
-	}
-	invariant(typeof arg === "object", "object expected", TypeError);
-	let primValue = ToPrimitive(arg, "number");
-	invariant(typeof primValue !== "object", "object expected", TypeError);
-	return ToNumber(primValue);
-}
-//#endregion
 //#region packages/ecma402-abstract/PluralRules/GetOperands.js
 /**
-* ECMA-402 Spec: GetOperands abstract operation
-* https://tc39.es/ecma402/#sec-getoperands
+* CLDR operands for the implementation-defined PluralRuleSelect
+* ECMA-402 §17.5.1 PluralRuleSelect, decimalString parameter and return definition.
+* https://tc39.es/ecma402/#sec-pluralruleselect
+* https://github.com/tc39/ecma402/blob/b1c961988b9a07894b1dc3dc2b5626ea48387d61/spec/pluralrules.html#L285-L290
 *
 * Implementation: Extended to support compact exponent (c/e operands)
 *
@@ -4960,34 +5312,34 @@ function ToNumber(arg) {
 * @param exponent Compact decimal exponent (c/e operand), defaults to 0
 */
 function GetOperands(s, exponent = 0) {
-	invariant$1(typeof s === "string", `GetOperands should have been called with a string`);
-	const n = ToNumber(s);
-	invariant$1(n.isFinite(), "n should be finite");
+	invariant(typeof s === "string", `GetOperands should have been called with a string`);
+	const n = new BigDecimal(s);
+	invariant(n.isFinite(), "n should be finite");
 	let dp = s.indexOf(".");
 	let iv;
 	let f;
 	let v;
 	let fv = "";
 	if (dp === -1) {
-		iv = n;
-		f = ZERO$1;
+		iv = s;
+		f = ZERO;
 		v = 0;
 	} else {
 		iv = s.slice(0, dp);
 		fv = s.slice(dp, s.length);
-		f = ToNumber(fv);
+		f = new BigDecimal(fv);
 		v = fv.length;
 	}
-	const i = ToNumber(iv).abs();
+	const i = new BigDecimal(iv).abs();
 	let w;
 	let t;
 	if (!f.isZero()) {
 		const ft = fv.replace(/0+$/, "");
 		w = ft.length;
-		t = ToNumber(ft);
+		t = new BigDecimal(ft);
 	} else {
 		w = 0;
-		t = ZERO$1;
+		t = ZERO;
 	}
 	return {
 		Number: n,
@@ -5018,8 +5370,8 @@ function GetOperands(s, exponent = 0) {
 */
 function ResolvePluralInternal(pl, n, { getInternalSlots, PluralRuleSelect }) {
 	const internalSlots = getInternalSlots(pl);
-	invariant$1(Type(internalSlots) === "Object", "pl has to be an object");
-	invariant$1("initializedPluralRules" in internalSlots, "pluralrules must be initialized");
+	invariant(Type(internalSlots) === "Object", "pl has to be an object");
+	invariant("initializedPluralRules" in internalSlots, "pluralrules must be initialized");
 	if (!n.isFinite()) return {
 		formattedString: String(n),
 		pluralCategory: "other"
@@ -5027,11 +5379,19 @@ function ResolvePluralInternal(pl, n, { getInternalSlots, PluralRuleSelect }) {
 	const { locale, type, notation } = internalSlots;
 	const s = FormatNumericToString(internalSlots, n).formattedString;
 	let exponent = 0;
-	if (notation === "compact" && !n.isZero()) {
-		if (internalSlots.dataLocaleData?.numbers) try {
-			exponent = ComputeExponentForMagnitude(internalSlots, new BigDecimal(Math.floor(Math.log10(Math.abs(n.toNumber())))));
-		} catch {
-			exponent = 0;
+	if (notation === "compact") {
+		const patterns = internalSlots.compactExponents?.[internalSlots.compactDisplay || "short"];
+		const integer = (s[0] === "-" ? s.slice(1) : s).split(".")[0];
+		let first = 0;
+		while (first < integer.length && integer[first] === "0") first++;
+		const magnitude = integer.length - first - 1;
+		let selectedMagnitude = -1;
+		if (patterns) for (const key in patterns) {
+			const threshold = Number(key);
+			if (threshold <= magnitude && threshold > selectedMagnitude) {
+				selectedMagnitude = threshold;
+				exponent = patterns[threshold];
+			}
 		}
 	}
 	return {
@@ -5061,7 +5421,9 @@ function ResolvePlural(pl, n, { getInternalSlots, PluralRuleSelect }) {
 * It resolves the appropriate plural form for a range by determining the plural forms of both the
 * start and end values, then consulting locale-specific range data.
 *
+* ECMA-402 §17.5.4 ResolvePluralRange, steps 1–3.
 * Specification: https://tc39.es/ecma402/#sec-resolvepluralrange
+* https://github.com/tc39/ecma402/blob/b1c961988b9a07894b1dc3dc2b5626ea48387d61/spec/pluralrules.html#L356-L358
 *
 * @param pluralRules - An initialized PluralRules object
 * @param x - Mathematical value for the range start
@@ -5069,10 +5431,10 @@ function ResolvePlural(pl, n, { getInternalSlots, PluralRuleSelect }) {
 * @returns The plural category for the range (zero, one, two, few, many, or other)
 */
 function ResolvePluralRange(pluralRules, x, y, { getInternalSlots, PluralRuleSelect, PluralRuleSelectRange }) {
-	if (!x.isFinite() || !y.isFinite()) throw new RangeError("selectRange requires start and end values to be finite numbers");
+	if (x.isNaN() || y.isNaN()) throw new RangeError("selectRange requires start and end values not to be NaN");
 	const internalSlots = getInternalSlots(pluralRules);
-	invariant$1(Type(internalSlots) === "Object", "pluralRules has to be an object");
-	invariant$1("initializedPluralRules" in internalSlots, "pluralrules must be initialized");
+	invariant(Type(internalSlots) === "Object", "pluralRules has to be an object");
+	invariant("initializedPluralRules" in internalSlots, "pluralrules must be initialized");
 	const xp = ResolvePluralInternal(pluralRules, x, {
 		getInternalSlots,
 		PluralRuleSelect
@@ -5151,11 +5513,13 @@ var PluralRules = class PluralRules {
 	}
 	resolvedOptions() {
 		validateInstance(this, "resolvedOptions");
-		const opts = Object.create(null);
+		const opts = {};
 		const internalSlots = getInternalSlots(this);
 		opts.locale = internalSlots.locale;
 		opts.type = internalSlots.type;
 		[
+			"notation",
+			"compactDisplay",
 			"minimumIntegerDigits",
 			"minimumFractionDigits",
 			"maximumFractionDigits",
@@ -5165,7 +5529,21 @@ var PluralRules = class PluralRules {
 			const val = internalSlots[field];
 			if (val !== void 0) opts[field] = val;
 		});
-		opts.pluralCategories = [...PluralRules.localeData[opts.locale].categories[opts.type]];
+		const categories = PluralRules.localeData[internalSlots.locale].categories[internalSlots.type];
+		opts.pluralCategories = [
+			"zero",
+			"one",
+			"two",
+			"few",
+			"many",
+			"other"
+		].filter((category) => categories.includes(category));
+		for (const field of [
+			"roundingIncrement",
+			"roundingMode",
+			"roundingPriority",
+			"trailingZeroDisplay"
+		]) opts[field] = internalSlots[field];
 		return opts;
 	}
 	select(val) {
@@ -5204,7 +5582,7 @@ var PluralRules = class PluralRules {
 	* pr.selectRange(BigInt(1), BigInt(2)); // "other"
 	*
 	* @throws {TypeError} If start or end is undefined
-	* @throws {RangeError} If start or end is not a finite number (Infinity, NaN)
+	* @throws {RangeError} If start or end converts to NaN
 	*
 	* @note Chrome's native implementation (as of early 2025) has a bug where it throws
 	* "Cannot convert a BigInt value to a number" when using BigInt arguments. This is
@@ -5229,8 +5607,7 @@ var PluralRules = class PluralRules {
 	}
 	static __addLocaleData(...data) {
 		for (const { data: d, locale } of data) {
-			PluralRules.localeData[locale] = d;
-			PluralRules.availableLocales.add(locale);
+			registerLocaleData(locale, d, PluralRules.localeData, PluralRules.availableLocales);
 			if (!PluralRules.__defaultLocale) PluralRules.__defaultLocale = locale;
 		}
 	}
@@ -5288,6 +5665,234 @@ try {
 	});
 } catch {}
 //#endregion
+//#region node_modules/.aspect_rules_js/@formatjs_generated+cldr.supported-locales@0.0.0/node_modules/@formatjs_generated/cldr.supported-locales/intl-pluralrules.js
+const supportedLocales = [
+	"af",
+	"ak",
+	"am",
+	"an",
+	"ar",
+	"ars",
+	"as",
+	"asa",
+	"ast",
+	"az",
+	"bal",
+	"be",
+	"bem",
+	"bez",
+	"bg",
+	"bho",
+	"blo",
+	"bm",
+	"bn",
+	"bo",
+	"br",
+	"brx",
+	"bs",
+	"ca",
+	"ce",
+	"ceb",
+	"cgg",
+	"chr",
+	"ckb",
+	"cs",
+	"csw",
+	"cv",
+	"cy",
+	"da",
+	"de",
+	"doi",
+	"dsb",
+	"dv",
+	"dz",
+	"ee",
+	"el",
+	"en",
+	"eo",
+	"es",
+	"et",
+	"eu",
+	"fa",
+	"ff",
+	"fi",
+	"fil",
+	"fo",
+	"fr",
+	"fur",
+	"fy",
+	"ga",
+	"gd",
+	"gl",
+	"gsw",
+	"gu",
+	"guw",
+	"gv",
+	"ha",
+	"haw",
+	"he",
+	"hi",
+	"hnj",
+	"hr",
+	"hsb",
+	"hu",
+	"hy",
+	"ia",
+	"id",
+	"ie",
+	"ig",
+	"ii",
+	"io",
+	"is",
+	"it",
+	"iu",
+	"ja",
+	"jbo",
+	"jgo",
+	"jmc",
+	"jv",
+	"jw",
+	"ka",
+	"kab",
+	"kaj",
+	"kcg",
+	"kde",
+	"kea",
+	"kk",
+	"kkj",
+	"kl",
+	"km",
+	"kn",
+	"ko",
+	"kok",
+	"kok-Latn",
+	"ks",
+	"ksb",
+	"ksh",
+	"ku",
+	"kw",
+	"ky",
+	"lag",
+	"lb",
+	"lg",
+	"lij",
+	"lkt",
+	"lld",
+	"ln",
+	"lo",
+	"lt",
+	"lv",
+	"mas",
+	"mg",
+	"mgo",
+	"mk",
+	"ml",
+	"mn",
+	"mo",
+	"mr",
+	"ms",
+	"mt",
+	"my",
+	"nah",
+	"naq",
+	"nb",
+	"nd",
+	"ne",
+	"nl",
+	"nn",
+	"nnh",
+	"no",
+	"nqo",
+	"nr",
+	"nso",
+	"ny",
+	"nyn",
+	"om",
+	"or",
+	"os",
+	"osa",
+	"pa",
+	"pap",
+	"pcm",
+	"pl",
+	"prg",
+	"ps",
+	"pt",
+	"pt-PT",
+	"rm",
+	"ro",
+	"rof",
+	"ru",
+	"rwk",
+	"sah",
+	"saq",
+	"sat",
+	"sc",
+	"scn",
+	"sd",
+	"sdh",
+	"se",
+	"seh",
+	"ses",
+	"sg",
+	"sgs",
+	"sh",
+	"shi",
+	"si",
+	"sk",
+	"sl",
+	"sma",
+	"smi",
+	"smj",
+	"smn",
+	"sms",
+	"sn",
+	"so",
+	"sq",
+	"sr",
+	"ss",
+	"ssy",
+	"st",
+	"su",
+	"sv",
+	"sw",
+	"syr",
+	"ta",
+	"te",
+	"teo",
+	"th",
+	"ti",
+	"tig",
+	"tk",
+	"tl",
+	"tn",
+	"to",
+	"tpi",
+	"tr",
+	"ts",
+	"tzm",
+	"ug",
+	"uk",
+	"und",
+	"ur",
+	"uz",
+	"ve",
+	"vec",
+	"vi",
+	"vo",
+	"vun",
+	"wa",
+	"wae",
+	"wo",
+	"xh",
+	"xog",
+	"yi",
+	"yo",
+	"yue",
+	"zh",
+	"zu"
+];
+//#endregion
 //#region packages/intl-pluralrules/should-polyfill.ts
 function supportedLocalesOf(locale) {
 	if (!locale) return true;