@formatjs/intl-pluralrules 6.3.13 → 6.3.15

package/index.js

@@ -1,5 +1,393 @@
 import { LookupSupportedLocales, ResolveLocale } from "@formatjs/intl-localematcher";
 import Decimal$1, { Decimal } from "@formatjs/bigdecimal";
+//#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
@@ -37,7 +425,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");
@@ -67,7 +455,7 @@ function SupportedLocales(availableLocales, requestedLocales, options) {
 }
 //#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) {
@@ -97,7 +485,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);
@@ -118,6 +506,7 @@ function ToPrimitive(input, preferredType) {
 function ToIntlMathematicalValue(input) {
 	if (typeof input === "bigint") return new Decimal(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 Decimal(NaN);
 	if (primValue === true) return new Decimal(1);
 	if (primValue === false) return new Decimal(0);
@@ -142,7 +531,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
@@ -150,7 +541,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);
 }
@@ -242,7 +633,7 @@ function repeat(s, times) {
 	for (let i = 0; i < arr.length; i++) arr[i] = s;
 	return arr.join("");
 }
-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 });
@@ -278,8 +669,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",
@@ -309,26 +700,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;
@@ -351,8 +746,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
@@ -367,13 +762,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
@@ -392,62 +793,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 Decimal.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 Decimal(0);
+const ZERO = new Decimal(0);
 const NEGATIVE_ZERO = new Decimal(-0);
 //#endregion
 //#region packages/ecma402-abstract/NumberFormat/GetUnsignedRoundingMode.js
@@ -482,21 +829,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 Decimal.pow(10, exponent);
+});
+//#endregion
 //#region packages/ecma402-abstract/NumberFormat/ToRawFixed.js
 function ToRawFixedFn(n, f) {
 	return n.times(getPowerOf10(-f));
@@ -654,7 +1016,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);
@@ -679,7 +1041,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;
 	}
@@ -695,7 +1057,7 @@ function ToRawPrecision(x, minPrecision, maxPrecision, unsignedRoundingMode) {
 		formattedString: m,
 		roundedNumber: xFinal,
 		integerDigitsCount: int,
-		roundingMagnitude: e
+		roundingMagnitude: e - p + 1
 	};
 }
 //#endregion
@@ -708,9 +1070,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();
@@ -728,14 +1090,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;
@@ -746,44 +1108,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 Decimal(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 Decimal(arg);
-	if (typeof arg === "bigint") return new Decimal(arg.toString());
-	invariant(typeof arg !== "symbol", "Symbol is not supported", TypeError);
-	if (arg === void 0) return new Decimal(NaN);
-	if (arg === null || arg === 0) return ZERO;
-	if (arg === true) return new Decimal(1);
-	if (typeof arg === "string") try {
-		return new Decimal(arg);
-	} catch {
-		return new Decimal(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)
 *
@@ -791,34 +1131,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 Decimal$1(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 Decimal$1(fv);
 		v = fv.length;
 	}
-	const i = ToNumber(iv).abs();
+	const i = new Decimal$1(iv).abs();
 	let w;
 	let t;
 	if (!f.isZero()) {
 		const ft = fv.replace(/0+$/, "");
 		w = ft.length;
-		t = ToNumber(ft);
+		t = new Decimal$1(ft);
 	} else {
 		w = 0;
-		t = ZERO$1;
+		t = ZERO;
 	}
 	return {
 		Number: n,
@@ -849,8 +1189,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"
@@ -858,11 +1198,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 Decimal$1(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 {
@@ -892,7 +1240,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
@@ -900,10 +1250,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
@@ -982,11 +1332,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",
@@ -996,7 +1348,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) {
@@ -1035,7 +1401,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
@@ -1060,8 +1426,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;
 		}
 	}